From 633339fd94696454fde427457682a07b73cd9f7b Mon Sep 17 00:00:00 2001
From: Joachim Schoeberl <joachim.schoeberl@tuwien.ac.at>
Date: Tue, 5 Dec 2023 09:46:42 +0100
Subject: [PATCH 01/20] Runge-Kutta time-stepping

---
 demos/test_ode.cc | 57 +++++++++++++++++++++++++++++++++++--
 src/nonlinfunc.h  | 56 +++++++++++++++++++++++++++++++++++++
 src/ode.h         | 71 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 182 insertions(+), 2 deletions(-)

diff --git a/demos/test_ode.cc b/demos/test_ode.cc
index 19072aa97..4df8baa9e 100644
--- a/demos/test_ode.cc
+++ b/demos/test_ode.cc
@@ -24,13 +24,66 @@ class MassSpring : public NonlinearFunction
 };
 
 
+Matrix<> Gauss2a { { 0.25, 0.25 - sqrt(3)/6 }, { 0.25 + sqrt(3)/6, 0.25 } };
+Vector<> Gauss2b { 0.5, 0.5 };
+Vector<> Gauss2c { 0.5 - sqrt(3)/6, 0.5 + sqrt(3)/6 };
+
+Vector<> Gauss3c { 0.5 - sqrt(15)/10, 0.5, 0.5+sqrt(15)/10 };
+
+
+auto ComputeABfromC (const Vector<> & c)
+{
+  int s = c.Size();
+  Matrix M(s, s);
+  Vector tmp(s);
+  
+  for (int i = 0; i < s; i++)
+    for (int j = 0; j < s; j++)
+      M(i,j) = std::pow(c(j), i);
+  CalcInverse(M);
+  
+  for (int i = 0; i < s; i++)
+    tmp(i) = 1.0 / (i+1);
+
+  Vector b = M * tmp;
+  cout << "b = " << b << endl;
+
+  Matrix a(s,s);
+
+  for (int j = 0; j < s; j++)
+    {
+      for (int i = 0; i < s; i++)
+        tmp(i) = std::pow(c(j),i+1) / (i+1);
+      a.Row(j) = M * tmp;
+    }
+  /*
+  cout << "b = " << b << endl;
+  cout << "a = " << a << endl;
+  */
+  return tuple { a, b };
+}
+  
+
+
 int main()
 {
   double tend = 4*M_PI;
-  int steps = 100;
+  int steps = 200;
   Vector<> y { 1, 0 };
   auto rhs = make_shared<MassSpring>();
-  
+
+  /*
   SolveODE_IE(tend, steps, y, rhs,
               [](double t, VectorView<double> y) { cout << t << "  " << y(0) << " " << y(1) << endl; });
+  */
+
+  auto [a,b] = ComputeABfromC (Gauss3c);
+  SolveODE_RK(tend, steps, a, b, Gauss3c, y, rhs, 
+              [](double t, VectorView<double> y) { cout << t << "  " << y(0) << " " << y(1) << endl; });
+
+  
+  /*
+  SolveODE_RK(tend, steps, Gauss2a, Gauss2b, Gauss2c, y, rhs, 
+              [](double t, VectorView<double> y) { cout << t << "  " << y(0) << " " << y(1) << endl; });
+  */
 }
diff --git a/src/nonlinfunc.h b/src/nonlinfunc.h
index 246369093..681a5372f 100644
--- a/src/nonlinfunc.h
+++ b/src/nonlinfunc.h
@@ -226,6 +226,62 @@ namespace ASC_ode
     }
   };
 
+
+  class MultipleFunc : public NonlinearFunction
+  {
+    shared_ptr<NonlinearFunction> func;
+    size_t num, fdimx, fdimf;
+  public:
+    MultipleFunc (shared_ptr<NonlinearFunction> _func, int _num)
+      : func(_func), num(_num)
+    {
+      fdimx = func->DimX();
+      fdimf = func->DimF();
+    }
+
+    virtual size_t DimX() const { return num * fdimx; } 
+    virtual size_t DimF() const { return num * fdimf; }
+    virtual void Evaluate (VectorView<double> x, VectorView<double> f) const
+    {
+      for (size_t i = 0; i < num; i++)
+        func->Evaluate(x.Range(i*fdimx, (i+1)*fdimx),
+                       f.Range(i*fdimf, (i+1)*fdimf));
+    }
+    virtual void EvaluateDeriv (VectorView<double> x, MatrixView<double> df) const
+    {
+      df = 0.0;
+      for (size_t i = 0; i < num; i++)
+        func->EvaluateDeriv(x.Range(i*fdimx, (i+1)*fdimx),
+                            df.Rows(i*fdimf, (i+1)*fdimf).Cols(i*fdimx, (i+1)*fdimx));
+    }
+  };
+
+
+  class MatVecFunc : public NonlinearFunction
+  {
+    Matrix<> a;
+    size_t n;
+  public:
+    MatVecFunc (Matrix<> _a, size_t _n)
+      : a(_a), n(_n) { }
+
+    virtual size_t DimX() const { return n*a.Height(); } 
+    virtual size_t DimF() const { return n*a.Width(); }
+    virtual void Evaluate (VectorView<double> x, VectorView<double> f) const
+    {
+      MatrixView<> mx(a.Width(), n, n, x.Data());
+      MatrixView<> mf(a.Height(), n, n, f.Data());
+      mf = a * mx;
+    }
+    virtual void EvaluateDeriv (VectorView<double> x, MatrixView<double> df) const
+    {
+      df = 0.0;
+      for (size_t i = 0; i < a.Height(); i++)
+        for (size_t j = 0; j < a.Width(); j++)
+          df.Rows(i*n, (i+1)*n).Cols(j*n, (j+1)*n).Diag() = a(i,j);
+    }
+  };
+
   
 }
 
diff --git a/src/ode.h b/src/ode.h
index 75f222372..6298805a0 100644
--- a/src/ode.h
+++ b/src/ode.h
@@ -31,11 +31,82 @@ namespace ASC_ode
       }
   }
 
+
+
+  
+
+
+  // implicit Euler method for dy/dt = rhs(y)
+  void SolveODE_RK(double tend, int steps,
+                   Matrix<> a, Vector<> b, Vector<> c,
+                   VectorView<double> y, shared_ptr<NonlinearFunction> rhs,
+                   std::function<void(double,VectorView<double>)> callback = nullptr)
+  {
+    double dt = tend/steps;
+    int s = c.Size();
+    int n = y.Size();
+
+    /*
+    auto multiple_rhs = make_shared<MultipleFunc>(rhs, s);
+    Vector<> my(s*y.Size());
+    Vector<> mf(s*y.Size());  
+    auto myold = make_shared<ConstantFunction>(my);
+    auto mynew = make_shared<IdentityFunction>(s*n);
+    auto equ = mynew-myold - dt * Compose(make_shared<MatVecFunc>(a, n), multiple_rhs);
+                                          
+      
+    double t = 0;
+    for (int i = 0; i < steps; i++)
+      {
+        cout << "step " << i << endl;
+        for (int j = 0; j < s; j++)
+          my.Range(j*n, (j+1)*n) = y;
+        myold->Set(my);
+        
+        NewtonSolver (equ, my);
+
+        multiple_rhs->Evaluate(my, mf);
+        for (int j = 0; j < s; j++)
+          y += dt * b(j) * mf.Range(j*n, (j+1)*n);
+        
+        t += dt;
+        if (callback) callback(t, y);
+      }
+    */
+
+    auto multiple_rhs = make_shared<MultipleFunc>(rhs, s);
+    Vector<> mk(s*y.Size());
+    Vector<> my(s*y.Size());    
+    auto myold = make_shared<ConstantFunction>(my);
+    auto knew = make_shared<IdentityFunction>(s*n);
+    auto equ = knew - Compose(multiple_rhs, myold+dt*make_shared<MatVecFunc>(a, n));
+      
+    double t = 0;
+    for (int i = 0; i < steps; i++)
+      {
+        cout << "step " << i << endl;
+        for (int j = 0; j < s; j++)
+          my.Range(j*n, (j+1)*n) = y;
+        myold->Set(my);
+
+        mk = 0.0;
+        NewtonSolver (equ, mk);
+
+        for (int j = 0; j < s; j++)
+          y += dt * b(j) * mk.Range(j*n, (j+1)*n);
+        
+        t += dt;
+        if (callback) callback(t, y);
+      }
+
+  }
+
   
 
   
   
   
+  
   // Newmark and generalized alpha:
   // https://miaodi.github.io/finite%20element%20method/newmark-generalized/
   

From 151ff70af0f7f14f951e60c1f589900628c45a58 Mon Sep 17 00:00:00 2001
From: Joachim Schoeberl <joachim.schoeberl@tuwien.ac.at>
Date: Tue, 5 Dec 2023 10:18:52 +0100
Subject: [PATCH 02/20] Gauss and Radau integration rules

---
 demos/test_ode.cc | 140 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 140 insertions(+)

diff --git a/demos/test_ode.cc b/demos/test_ode.cc
index 4df8baa9e..82b0375b7 100644
--- a/demos/test_ode.cc
+++ b/demos/test_ode.cc
@@ -31,6 +31,120 @@ Vector<> Gauss2c { 0.5 - sqrt(3)/6, 0.5 + sqrt(3)/6 };
 Vector<> Gauss3c { 0.5 - sqrt(15)/10, 0.5, 0.5+sqrt(15)/10 };
 
 
+// codes from Numerical Recipes, https://numerical.recipes/book.html
+
+// Gauss integration on [0,1]
+void GaussLegendre(VectorView<> x, VectorView<> w)
+// Given the lower and upper limits of integration x1 and x2, this routine returns arrays x[0..n-1]
+// and w[0..n-1] of length n, containing the abscissas and weights of the Gauss-Legendre n-point
+// quadrature formula.
+  {
+    double x1 = 0;
+    double x2 = 1;
+    const double EPS=1.0e-14;  // EPS is the relative precision.
+    double z1,z,xm,xl,pp,p3,p2,p1;
+    int n=x.Size();
+    int m=(n+1)/2;  // The roots are symmetric in the interval, so
+    xm=0.5*(x2+x1); // we only have to find half of them.
+    xl=0.5*(x2-x1);
+    for (int i=0;i<m;i++) {  // Loop over the desired roots.
+      z=cos(3.141592654*(i+0.75)/(n+0.5));
+      // Starting with this approximation to the ith root, we enter the main loop of refinement
+      // by Newton’s method.
+      do {
+        p1=1.0;
+        p2=0.0;
+        for (int j=0;j<n;j++) { // Loop up the recurrence relation to get the
+            p3=p2;  // Legendre polynomial evaluated at z.
+          p2=p1;
+          p1=((2.0*j+1.0)*z*p2-j*p3)/(j+1);
+        }
+        // p1 is now the desired Legendre polynomial. We next compute pp, its derivative,
+        // by a standard relation involving also p2, the polynomial of one lower order.
+        pp=n*(z*p1-p2)/(z*z-1.0);
+        z1=z;
+        z=z1-p1/pp;   // Newton’s method.
+      } while (abs(z-z1) > EPS);
+      x[i]=xm-xl*z;      // Scale the root to the desired interval,
+      x[n-1-i]=xm+xl*z;  //  and put in its symmetric counterpart.
+      w[i]=2.0*xl/((1.0-z*z)*pp*pp);  // Compute the weight
+      w[n-1-i]=w[i];     // and its symmetric counterpart.
+    }
+  }
+
+
+void GaussJacobi (VectorView<> x, VectorView<> w, const double alf, const double bet)
+// Given alf and bet, the parameters ˛ and ˇ of the Jacobi polynomials, this routine returns
+// arrays x[0..n-1] and w[0..n-1] containing the abscissas and weights of the n-point GaussJacobi quadrature formula. The largest abscissa is returned in x[0], the smallest in x[n-1].
+{
+  const int MAXIT=10;
+  const double EPS=1.0e-14; // EPS is the relative precision.
+  int i,its,j;
+  double alfbet,an,bn,r1,r2,r3;
+  double a,b,c,p1,p2,p3,pp,temp,z,z1;
+  int n=x.Size();
+  for (i=0;i<n;i++) { // Loop over the desired roots.
+    if (i == 0) {  // Initial guess for the largest root.
+      an=alf;
+      bn=bet/n;
+      r1=(1.0+alf)*(2.78/(4.0+n*n)+0.768*an/n);
+      r2=1.0+1.48*an+0.96*bn+0.452*an*an+0.83*an*bn;
+      z=1.0-r1/r2;
+    } else if (i == 1) { // Initial guess for the second largest root.
+      r1=(4.1+alf)/((1.0+alf)*(1.0+0.156*alf));
+      r2=1.0+0.06*(n-8.0)*(1.0+0.12*alf)/n;
+      r3=1.0+0.012*bet*(1.0+0.25*abs(alf))/n;
+      z -= (1.0-z)*r1*r2*r3;
+    } else if (i == 2) { // Initial guess for the third largest root.
+      r1=(1.67+0.28*alf)/(1.0+0.37*alf);
+      r2=1.0+0.22*(n-8.0)/n;
+      r3=1.0+8.0*bet/((6.28+bet)*n*n);
+      z -= (x[0]-z)*r1*r2*r3;
+    } else if (i == n-2) { // Initial guess for the second smallest root.
+      r1=(1.0+0.235*bet)/(0.766+0.119*bet);
+      r2=1.0/(1.0+0.639*(n-4.0)/(1.0+0.71*(n-4.0)));
+      r3=1.0/(1.0+20.0*alf/((7.5+alf)*n*n));
+      z += (z-x[n-4])*r1*r2*r3;
+    } else if (i == n-1) { // Initial guess for the smallest root.
+      r1=(1.0+0.37*bet)/(1.67+0.28*bet);
+      r2=1.0/(1.0+0.22*(n-8.0)/n);
+      r3=1.0/(1.0+8.0*alf/((6.28+alf)*n*n));
+      z += (z-x[n-3])*r1*r2*r3;
+    } else { // Initial guess for the other roots.
+      z=3.0*x[i-1]-3.0*x[i-2]+x[i-3];
+    }
+    alfbet=alf+bet;
+    for (its=1;its<=MAXIT;its++) { // Refinement by Newton’s method.
+      temp=2.0+alfbet; // Start the recurrence with P0 and P1 to avoid
+      // a division by zero when ˛ C ˇ D 0 or 1.
+      p1=(alf-bet+temp*z)/2.0;
+      p2=1.0;
+      for (j=2;j<=n;j++) { // Loop up the recurrence relation to get the
+        p3=p2;    // Jacobi polynomial evaluated at z.
+        p2=p1;
+        temp=2*j+alfbet;
+        a=2*j*(j+alfbet)*(temp-2.0);
+        b=(temp-1.0)*(alf*alf-bet*bet+temp*(temp-2.0)*z);
+        c=2.0*(j-1+alf)*(j-1+bet)*temp;
+        p1=(b*p2-c*p3)/a;
+      }
+      pp=(n*(alf-bet-temp*z)*p1+2.0*(n+alf)*(n+bet)*p2)/(temp*(1.0-z*z));
+      // p1 is now the desired Jacobi polynomial. We next compute pp, its derivative, by
+      //  a standard relation involving also p2, the polynomial of one lower order.
+      z1=z;
+      z=z1-p1/pp; // Newton’s formula.
+      if (abs(z-z1) <= EPS) break;
+    }
+    if (its > MAXIT) throw("too many iterations in gaujac");
+    x[i]=z;    // Store the root and the weight.
+    w[i]=exp(std::lgamma(alf+n)+std::lgamma(bet+n)-std::lgamma(n+1.0)-
+             std::lgamma(n+alfbet+1.0))*temp*pow(2.0,alfbet)/(pp*p2);
+  }
+}
+
+
+
+
 auto ComputeABfromC (const Vector<> & c)
 {
   int s = c.Size();
@@ -64,6 +178,21 @@ auto ComputeABfromC (const Vector<> & c)
 }
   
 
+void GaussRadau (VectorView<> x, VectorView<> w)
+{
+  GaussJacobi (x.Range(0, x.Size()-1),
+               w.Range(0, w.Size()-1), 1, 0);
+  for (int i = 0; i < x.Size()-1; i++)
+    {
+      x(i) = 0.5*(x(i)+1);
+      w(i) *= 0.5;
+    }
+  x(x.Size()-1) = 1.0;
+  double sum = 0;
+  for (int i = 0; i < x.Size()-1; i++)
+    sum += w(i);
+  w(x.Size()-1) = 1-sum;
+}
 
 int main()
 {
@@ -81,6 +210,17 @@ int main()
   SolveODE_RK(tend, steps, a, b, Gauss3c, y, rhs, 
               [](double t, VectorView<double> y) { cout << t << "  " << y(0) << " " << y(1) << endl; });
 
+
+  cout << "Gauss3c = " << Gauss3c << endl;
+  cout << "weights = " << b << endl;
+  GaussLegendre (Gauss3c, b);
+  cout << "with generic function, c = " << Gauss3c << ", weights = " << b << endl;
+
+
+  Vector<> Radau(3), RadauWeight(3);
+  GaussRadau (Radau, RadauWeight);
+  // not sure about weights, comput them via ComputeABfromC
+  cout << "Radau = " << Radau << ", weight = " << RadauWeight <<  endl;
   
   /*
   SolveODE_RK(tend, steps, Gauss2a, Gauss2b, Gauss2c, y, rhs, 

From 617b24ac9aa4e98be84f725b6a61ab10005f6336 Mon Sep 17 00:00:00 2001
From: Joachim Schoeberl <joachim.schoeberl@tuwien.ac.at>
Date: Fri, 7 Nov 2025 12:18:25 +0100
Subject: [PATCH 03/20] nanoblas inverse

---
 demos/test_ode.cpp |  9 +++++----
 nanoblas           |  2 +-
 src/implicitRK.hpp | 36 ++++++++++++++++++++++--------------
 3 files changed, 28 insertions(+), 19 deletions(-)

diff --git a/demos/test_ode.cpp b/demos/test_ode.cpp
index 4ab9698e8..b271e3b93 100644
--- a/demos/test_ode.cpp
+++ b/demos/test_ode.cpp
@@ -2,6 +2,7 @@
 
 #include <nonlinfunc.hpp>
 #include <ode.hpp>
+#include <implicitRK.hpp>
 
 using namespace ASC_ode;
 
@@ -32,18 +33,18 @@ int main()
   int steps = 100;
   Vector<> y = { 1, 0 };  // initializer list
   auto rhs = std::make_shared<MassSpring>();
-  
+  /*
   solveODE_IE(tend, steps, y, rhs,
               [](double t, VectorView<double> y) { std::cout << t << "  " << y(0) << " " << y(1) << std::endl; });
+*/
 
 
 
-/*
   auto [a,b] = ComputeABfromC (Gauss3c);
   SolveODE_RK(tend, steps, a, b, Gauss3c, y, rhs, 
-              [](double t, VectorView<double> y) { cout << t << "  " << y(0) << " " << y(1) << endl; });
-
+              [](double t, VectorView<double> y) { std::cout << t << "  " << y(0) << " " << y(1) << std::endl; });
 
+/*
   cout << "Gauss3c = " << Gauss3c << endl;
   cout << "weights = " << b << endl;
   GaussLegendre (Gauss3c, b);
diff --git a/nanoblas b/nanoblas
index 2d5126eeb..f935be2ef 160000
--- a/nanoblas
+++ b/nanoblas
@@ -1 +1 @@
-Subproject commit 2d5126eeb46c6f36073c3d3dd0c34b46aa07a35f
+Subproject commit f935be2ef996f8693c49e1203014355615d762fb
diff --git a/src/implicitRK.hpp b/src/implicitRK.hpp
index 4bcde0e6f..a2bd202c4 100644
--- a/src/implicitRK.hpp
+++ b/src/implicitRK.hpp
@@ -1,8 +1,14 @@
 #ifndef IMPLICITRK_HPP
 #define IMPLICITRK_HPP
 
+#include <vector.hpp>
+#include <matrix.hpp>
+#include <inverse.hpp>
+
 namespace ASC_ode {
-Matrix<> Gauss2a { { 0.25, 0.25 - sqrt(3)/6 }, { 0.25 + sqrt(3)/6, 0.25 } };
+  using namespace nanoblas;
+
+Matrix<double> Gauss2a { { 0.25, 0.25 - sqrt(3)/6 }, { 0.25 + sqrt(3)/6, 0.25 } };
 Vector<> Gauss2b { 0.5, 0.5 };
 Vector<> Gauss2c { 0.5 - sqrt(3)/6, 0.5 + sqrt(3)/6 };
 
@@ -21,7 +27,7 @@ void GaussLegendre(VectorView<> x, VectorView<> w)
     double x2 = 1;
     const double EPS=1.0e-14;  // EPS is the relative precision.
     double z1,z,xm,xl,pp,p3,p2,p1;
-    int n=x.Size();
+    int n=x.size();
     int m=(n+1)/2;  // The roots are symmetric in the interval, so
     xm=0.5*(x2+x1); // we only have to find half of them.
     xl=0.5*(x2-x1);
@@ -60,7 +66,7 @@ void GaussJacobi (VectorView<> x, VectorView<> w, const double alf, const double
   int i,its,j;
   double alfbet,an,bn,r1,r2,r3;
   double a,b,c,p1,p2,p3,pp,temp,z,z1;
-  int n=x.Size();
+  int n=x.size();
   for (i=0;i<n;i++) { // Loop over the desired roots.
     if (i == 0) {  // Initial guess for the largest root.
       an=alf;
@@ -125,20 +131,22 @@ void GaussJacobi (VectorView<> x, VectorView<> w, const double alf, const double
 
 auto ComputeABfromC (const Vector<> & c)
 {
-  int s = c.Size();
+  int s = c.size();
   Matrix M(s, s);
   Vector tmp(s);
   
   for (int i = 0; i < s; i++)
     for (int j = 0; j < s; j++)
       M(i,j) = std::pow(c(j), i);
-  CalcInverse(M);
+
+  calcInverse(M);
+  // M = LapackLU(M).inverse();
   
   for (int i = 0; i < s; i++)
     tmp(i) = 1.0 / (i+1);
 
   Vector b = M * tmp;
-  cout << "b = " << b << endl;
+  std::cout << "b = " << b << std::endl;
 
   Matrix a(s,s);
 
@@ -146,30 +154,30 @@ auto ComputeABfromC (const Vector<> & c)
     {
       for (int i = 0; i < s; i++)
         tmp(i) = std::pow(c(j),i+1) / (i+1);
-      a.Row(j) = M * tmp;
+      a.row(j) = M * tmp;
     }
   /*
   cout << "b = " << b << endl;
   cout << "a = " << a << endl;
   */
-  return tuple { a, b };
+  return std::tuple { a, b };
 }
   
 
 void GaussRadau (VectorView<> x, VectorView<> w)
 {
-  GaussJacobi (x.Range(0, x.Size()-1),
-               w.Range(0, w.Size()-1), 1, 0);
-  for (int i = 0; i < x.Size()-1; i++)
+  GaussJacobi (x.range(0, x.size()-1),
+               w.range(0, w.size()-1), 1, 0);
+  for (int i = 0; i < x.size()-1; i++)
     {
       x(i) = 0.5*(x(i)+1);
       w(i) *= 0.5;
     }
-  x(x.Size()-1) = 1.0;
+  x(x.size()-1) = 1.0;
   double sum = 0;
-  for (int i = 0; i < x.Size()-1; i++)
+  for (int i = 0; i < x.size()-1; i++)
     sum += w(i);
-  w(x.Size()-1) = 1-sum;
+  w(x.size()-1) = 1-sum;
 }
 }
 

From 8b6aea559fb327b55294e84090f70533c1e595b2 Mon Sep 17 00:00:00 2001
From: Farooq Mian Azan <e12433773@student.tuwien.ac.at>
Date: Fri, 21 Nov 2025 17:16:11 +0000
Subject: [PATCH 04/20] Working Python module asc_ode + fixed nanoblas linking

---
 CMakeLists.txt   | 30 +++++++++++++++++++++---------
 src/bindings.cpp | 11 +++++++++++
 2 files changed, 32 insertions(+), 9 deletions(-)
 create mode 100644 src/bindings.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6dc00d2b7..42148ed07 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,18 +1,30 @@
 cmake_minimum_required(VERSION 3.20)
-project(ASC_ode)
-
-set (CMAKE_CXX_STANDARD 20)
+project(ASC_ode LANGUAGES CXX)
 
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 include_directories(src nanoblas/src)
+add_subdirectory(nanoblas)
+
+
+add_executable(test_ode demos/test_ode.cpp)
+target_link_libraries(test_ode PUBLIC nanoblas)         
+
+
+add_executable(demo_autodiff demos/demo_autodiff.cpp)
+target_link_libraries(demo_autodiff PUBLIC nanoblas)    
 
-add_subdirectory (src)
-add_subdirectory (nanoblas)
+# Python bindings
+find_package(pybind11 REQUIRED CONFIG)
 
+pybind11_add_module(asc_ode
+    src/bindings.cpp
+)
 
-add_executable (test_ode demos/test_ode.cpp)
-target_link_libraries (test_ode PUBLIC nanoblas)
 
-add_executable (demo_autodiff demos/demo_autodiff.cpp)
-target_link_libraries (demo_autodiff PUBLIC nanoblas)
+target_link_libraries(asc_ode PRIVATE nanoblas)          
 
+set_target_properties(asc_ode PROPERTIES
+    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
+)
\ No newline at end of file
diff --git a/src/bindings.cpp b/src/bindings.cpp
new file mode 100644
index 000000000..ce903dd04
--- /dev/null
+++ b/src/bindings.cpp
@@ -0,0 +1,11 @@
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(asc_ode, m) {
+    m.doc() = "ASC ODE library – winter semester 2025/26";
+    m.attr("__version__") = "0.1.0";
+
+   
+    m.def("hello", []() { return "Hello from ASC ODE!"; });
+}
\ No newline at end of file

From 827c1398f39c96fc283e82b371bb87883332ab0d Mon Sep 17 00:00:00 2001
From: Joachim Schoeberl <joachim.schoeberl@tuwien.ac.at>
Date: Sun, 23 Nov 2025 13:31:52 +0100
Subject: [PATCH 05/20] included massspring into Newmark branch

---
 CMakeLists.txt                  |   1 +
 mechsystem/CMakeLists.txt       |  17 +++
 mechsystem/Newmark.hpp          | 108 +++++++++++++++++
 mechsystem/bind_mass_spring.cpp | 120 +++++++++++++++++++
 mechsystem/mass_spring.cpp      |  33 +++++
 mechsystem/mass_spring.hpp      | 206 ++++++++++++++++++++++++++++++++
 mechsystem/mass_spring.ipynb    | 152 +++++++++++++++++++++++
 mechsystem/test_mass_spring.py  |  35 ++++++
 8 files changed, 672 insertions(+)
 create mode 100644 mechsystem/CMakeLists.txt
 create mode 100644 mechsystem/Newmark.hpp
 create mode 100644 mechsystem/bind_mass_spring.cpp
 create mode 100644 mechsystem/mass_spring.cpp
 create mode 100644 mechsystem/mass_spring.hpp
 create mode 100644 mechsystem/mass_spring.ipynb
 create mode 100644 mechsystem/test_mass_spring.py

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6dc00d2b7..3339711d6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,6 +9,7 @@ include_directories(src nanoblas/src)
 add_subdirectory (src)
 add_subdirectory (nanoblas)
 
+add_subdirectory (mechsystem)
 
 add_executable (test_ode demos/test_ode.cpp)
 target_link_libraries (test_ode PUBLIC nanoblas)
diff --git a/mechsystem/CMakeLists.txt b/mechsystem/CMakeLists.txt
new file mode 100644
index 000000000..0c0ab842e
--- /dev/null
+++ b/mechsystem/CMakeLists.txt
@@ -0,0 +1,17 @@
+add_executable (test_mass_spring mass_spring.cpp)
+# target_link_libraries (test_mass_spring PUBLIC ngbla)
+
+
+
+
+
+find_package(Python 3.8 COMPONENTS Interpreter Development REQUIRED)
+
+execute_process(
+  COMMAND "${Python_EXECUTABLE}" -m pybind11 --cmakedir
+  OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE PYBIND11_DIR)
+list(APPEND CMAKE_PREFIX_PATH "${PYBIND11_DIR}")
+find_package(pybind11 CONFIG REQUIRED)
+
+pybind11_add_module(mass_spring bind_mass_spring.cpp)
+# target_link_libraries (mass_spring PUBLIC ngbla)
diff --git a/mechsystem/Newmark.hpp b/mechsystem/Newmark.hpp
new file mode 100644
index 000000000..589b0bebd
--- /dev/null
+++ b/mechsystem/Newmark.hpp
@@ -0,0 +1,108 @@
+#ifndef NEWMARK_HPP
+#define NEWMARK_HPP
+
+#include <nonlinfunc.hpp>
+
+
+
+  
+  
+  // Newmark and generalized alpha:
+  // https://miaodi.github.io/finite%20element%20method/newmark-generalized/
+  
+  // Newmark method for  mass*d^2x/dt^2 = rhs
+  void SolveODE_Newmark(double tend, int steps,
+                        VectorView<double> x, VectorView<double> dx,
+                        std::shared_ptr<NonlinearFunction> rhs,   
+                        std::shared_ptr<NonlinearFunction> mass,  
+                        std::function<void(double,VectorView<double>)> callback = nullptr)
+  {
+    double dt = tend/steps;
+    double gamma = 0.5;
+    double beta = 0.25;
+
+    Vector<> a(x.size());
+    Vector<> v(x.size());
+
+    auto xold = std::make_shared<ConstantFunction>(x);
+    auto vold = std::make_shared<ConstantFunction>(dx);
+    auto aold = std::make_shared<ConstantFunction>(x);
+    rhs->evaluate (xold->get(), aold->get());
+
+    auto anew = std::make_shared<IdentityFunction>(a.size());
+    auto vnew = vold + dt*((1-gamma)*aold+gamma*anew);
+    auto xnew = xold + dt*vold + dt*dt/2 * ((1-2*beta)*aold+2*beta*anew);    
+
+    auto equ = Compose(mass, anew) - Compose(rhs, xnew);
+
+    double t = 0;
+    for (int i = 0; i < steps; i++)            
+      {
+        NewtonSolver (equ, a);
+        xnew -> evaluate (a, x);
+        vnew -> evaluate (a, v);
+
+        xold->set(x);
+        vold->set(v);
+        aold->set(a);
+        t += dt;
+        if (callback) callback(t, x);
+      }
+    dx = v;
+  }
+
+
+
+
+  // Generalized alpha method for M d^2x/dt^2 = rhs
+  void SolveODE_Alpha (double tend, int steps, double rhoinf,
+                       VectorView<double> x, VectorView<double> dx, VectorView<double> ddx,
+                       std::shared_ptr<NonlinearFunction> rhs,   
+                       std::shared_ptr<NonlinearFunction> mass,  
+                       std::function<void(double,VectorView<double>)> callback = nullptr)
+  {
+    double dt = tend/steps;
+    double alpham = (2*rhoinf-1)/(rhoinf+1);
+    double alphaf = rhoinf/(rhoinf+1);
+    double gamma = 0.5-alpham+alphaf;
+    double beta = 0.25 * (1-alpham+alphaf)*(1-alpham+alphaf);
+
+    Vector<> a(x.size());
+    Vector<> v(x.size());
+
+    auto xold = std::make_shared<ConstantFunction>(x);
+    auto vold = std::make_shared<ConstantFunction>(dx);
+    auto aold = std::make_shared<ConstantFunction>(ddx);
+    // rhs->evaluate (xold->get(), aold->get()); // solve with M ???
+
+    auto anew = std::make_shared<IdentityFunction>(a.size());
+    auto vnew = vold + dt*((1-gamma)*aold+gamma*anew);
+    auto xnew = xold + dt*vold + dt*dt/2 * ((1-2*beta)*aold+2*beta*anew);    
+
+    // auto equ = Compose(mass, (1-alpham)*anew+alpham*aold) - Compose(rhs, (1-alphaf)*xnew+alphaf*xold);
+    auto equ = Compose(mass, (1-alpham)*anew+alpham*aold) - (1-alphaf)*Compose(rhs,xnew) - alphaf*Compose(rhs, xold);
+
+    double t = 0;
+    a = ddx;
+
+    for (int i = 0; i < steps; i++)
+      {
+        NewtonSolver (equ, a);
+        xnew -> evaluate (a, x);
+        vnew -> evaluate (a, v);
+
+        xold->set(x);
+        vold->set(v);
+        aold->set(a);
+        t += dt;
+        if (callback) callback(t, x);
+      }
+    dx = v;
+    ddx = a;
+  }
+
+
+
+
+
+#endif // NEWMARK_HPP
\ No newline at end of file
diff --git a/mechsystem/bind_mass_spring.cpp b/mechsystem/bind_mass_spring.cpp
new file mode 100644
index 000000000..427b2fb65
--- /dev/null
+++ b/mechsystem/bind_mass_spring.cpp
@@ -0,0 +1,120 @@
+#include <sstream>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/stl_bind.h>
+
+#include "mass_spring.hpp"
+#include "Newmark.hpp"
+
+namespace py = pybind11;
+
+PYBIND11_MAKE_OPAQUE(std::vector<Mass<3>>);
+PYBIND11_MAKE_OPAQUE(std::vector<Fix<3>>);
+PYBIND11_MAKE_OPAQUE(std::vector<Spring>);
+
+PYBIND11_MODULE(mass_spring, m) {
+    m.doc() = "mass-spring-system simulator"; 
+
+    py::class_<Mass<2>> (m, "Mass2d")
+      ;
+      
+    m.def("Mass", [](double m, std::array<double,2> p)
+    {
+      return Mass<2>{m, { p[0], p[1] }};
+    });
+
+
+    
+
+    
+    py::class_<Mass<3>> (m, "Mass3d")
+      .def_property("mass",
+                    [](Mass<3> & m) { return m.mass; },
+                    [](Mass<3> & m, double mass) { m.mass = mass; })
+      .def_property_readonly("pos",
+                             [](Mass<3> & m) { return m.pos; });
+    ;
+
+    
+    m.def("Mass", [](double m, std::array<double,3> p)
+    {
+      return Mass<3>{m, { p[0], p[1], p[2] }};
+    });
+
+    
+    py::class_<Fix<3>> (m, "Fix3d")
+      .def_property_readonly("pos",
+                             [](Fix<3> & f) { return f.pos; });
+    
+
+    m.def("Fix", [](std::array<double,3> p)
+    {
+      return Fix<3>{ { p[0], p[1], p[2] } };
+    });
+
+    py::class_<Connector> (m, "Connector");
+
+    py::class_<Spring> (m, "Spring")
+      .def(py::init<double, double, std::array<Connector,2>>())
+      .def_property_readonly("connections",
+                             [](Spring & s) { return s.connections; })
+      ;
+
+    
+    py::bind_vector<std::vector<Mass<3>>>(m, "Masses3d");
+    py::bind_vector<std::vector<Fix<3>>>(m, "Fixes3d");
+    py::bind_vector<std::vector<Spring>>(m, "Springs");        
+    
+    
+    py::class_<MassSpringSystem<2>> (m, "MassSpringSystem2d")
+      .def(py::init<>())
+      .def("Add", [](MassSpringSystem<2> & mss, Mass<2> m) { return mss.AddMass(m); })
+      ;
+      
+        
+    py::class_<MassSpringSystem<3>> (m, "MassSpringSystem3d")
+      .def(py::init<>())
+      .def("__str__", [](MassSpringSystem<3> & mss) {
+        std::stringstream sstr;
+        sstr << mss;
+        return sstr.str();
+      })
+      .def_property("gravity", [](MassSpringSystem<3> & mss) { return mss.Gravity(); },
+                    [](MassSpringSystem<3> & mss, std::array<double,3> g) { mss.SetGravity(Vec<3>{g[0],g[1],g[2]}); })
+      .def("Add", [](MassSpringSystem<3> & mss, Mass<3> m) { return mss.AddMass(m); })
+      .def("Add", [](MassSpringSystem<3> & mss, Fix<3> f) { return mss.AddFix(f); })
+      .def("Add", [](MassSpringSystem<3> & mss, Spring s) { return mss.AddSpring(s); })            
+      .def_property_readonly("masses", [](MassSpringSystem<3> & mss) -> auto& { return mss.Masses(); })
+      .def_property_readonly("fixes", [](MassSpringSystem<3> & mss) -> auto& { return mss.Fixes(); })
+      .def_property_readonly("springs", [](MassSpringSystem<3> & mss) -> auto& { return mss.Springs(); })            
+      .def("__getitem__", [](MassSpringSystem<3> mss, Connector & c) {
+        if (c.type==Connector::FIX) return py::cast(mss.Fixes()[c.nr]);
+        else return py::cast(mss.Masses()[c.nr]);
+      })
+      
+      .def("GetState", [] (MassSpringSystem<3> & mss) {
+        Vector<> x(3*mss.Masses().size());
+        Vector<> dx(3*mss.Masses().size());
+        Vector<> ddx(3*mss.Masses().size());
+        mss.GetState (x, dx, ddx);
+        return x;
+      })
+      ;
+    
+
+    m.def("Simulate", [](MassSpringSystem<3> & mss, double tend, size_t steps) {
+      Vector<> x(3*mss.Masses().size());
+      Vector<> dx(3*mss.Masses().size());
+      Vector<> ddx(3*mss.Masses().size());
+      mss.GetState (x, dx, ddx);
+      
+      auto mss_func = std::make_shared<MSS_Function<3>> (mss);
+      auto mass = std::make_shared<IdentityFunction> (x.size());
+
+      SolveODE_Alpha(tend, steps, 0.8, x, dx, ddx, mss_func, mass);
+
+      mss.SetState (x, dx, ddx);
+    });
+      
+    
+}
diff --git a/mechsystem/mass_spring.cpp b/mechsystem/mass_spring.cpp
new file mode 100644
index 000000000..a8a3d9dbf
--- /dev/null
+++ b/mechsystem/mass_spring.cpp
@@ -0,0 +1,33 @@
+#include "mass_spring.hpp"
+#include "Newmark.hpp"
+
+int main()
+{
+  MassSpringSystem<2> mss;
+  mss.SetGravity( {0,-9.81} );
+  auto fA = mss.AddFix( { { 0.0, 0.0 } } );
+  auto mA = mss.AddMass( { 1, { 1.0, 0.0 } } );
+  mss.AddSpring ( { 1, 10, { fA, mA } }  );
+
+  auto mB = mss.AddMass( { 1, { 2.0, 0.0 } } );
+  mss.AddSpring ( { 1, 20, { mA, mB } } );
+
+  std::cout << "mss: " << std::endl << mss << std::endl;
+
+
+  double tend = 10;
+  double steps = 1000;
+  
+  Vector<> x(2*mss.Masses().size());
+  Vector<> dx(2*mss.Masses().size());  
+  Vector<> ddx(2*mss.Masses().size());  
+
+  auto mss_func = std::make_shared<MSS_Function<2>> (mss);
+  auto mass = std::make_shared<IdentityFunction> (x.size());
+
+  mss.GetState (x, dx, ddx);
+  
+  SolveODE_Newmark(tend, steps, x, dx,  mss_func, mass,
+                   [](double t, VectorView<double> x) { std::cout << "t = " << t
+                                                             << ", x = " << Vec<4>(x) << std::endl; });
+}
diff --git a/mechsystem/mass_spring.hpp b/mechsystem/mass_spring.hpp
new file mode 100644
index 000000000..93bd11557
--- /dev/null
+++ b/mechsystem/mass_spring.hpp
@@ -0,0 +1,206 @@
+#ifndef MASS_SPRING_HPP
+#define MASS_SPRING_HPP
+
+
+
+#include <nonlinfunc.hpp>
+#include <timestepper.hpp>
+
+using namespace ASC_ode;
+
+#include <vector.hpp>
+using namespace nanoblas;
+
+
+
+template <int D>
+class Mass
+{
+public:
+  double mass;
+  Vec<D> pos;
+  Vec<D> vel = 0.0;
+  Vec<D> acc = 0.0;
+};
+
+
+template <int D>
+class Fix
+{
+public:
+  Vec<D> pos;
+};
+
+
+class Connector
+{
+public:
+  enum CONTYPE { FIX=1, MASS=2 };
+  CONTYPE type;
+  size_t nr;
+};
+
+std::ostream & operator<< (std::ostream & ost, const Connector & con)
+{
+  ost << "type = " << int(con.type) << ", nr = " << con.nr;
+  return ost;
+}
+
+class Spring
+{
+public:
+  double length;  
+  double stiffness;
+  std::array<Connector,2> connections;
+};
+
+template <int D>
+class MassSpringSystem
+{
+  std::vector<Fix<D>> fixes;
+  std::vector<Mass<D>> masses;
+  std::vector<Spring> springs;
+  Vec<D> gravity=0.0;
+public:
+  void SetGravity (Vec<D> _gravity) { gravity = _gravity; }
+  Vec<D> Gravity() const { return gravity; }
+  
+  Connector AddFix (Fix<D> p)
+  {
+    fixes.push_back(p);
+    return { Connector::FIX, fixes.size()-1 };
+  }
+
+  Connector AddMass (Mass<D> m)
+  {
+    masses.push_back (m);
+    return { Connector::MASS, masses.size()-1 };
+  }
+  
+  size_t AddSpring (Spring s) // double length, double stiffness, Connector c1, Connector c2)
+  {
+    springs.push_back (s); // Spring{length, stiffness, { c1, c2 } });
+    return springs.size()-1;
+  }
+
+
+
+  
+  auto & Fixes() { return fixes; } 
+  auto & Masses() { return masses; } 
+  auto & Springs() { return springs; }
+
+  void GetState (VectorView<> values, VectorView<> dvalues, VectorView<> ddvalues)
+  {
+    auto valmat = values.asMatrix(Masses().size(), D);
+    auto dvalmat = dvalues.asMatrix(Masses().size(), D);
+    auto ddvalmat = ddvalues.asMatrix(Masses().size(), D);    
+
+    for (size_t i = 0; i < Masses().size(); i++)
+      {
+        valmat.row(i) = Masses()[i].pos;
+        dvalmat.row(i) = Masses()[i].vel;
+        ddvalmat.row(i) = Masses()[i].acc;
+      }
+  }
+  
+  void SetState (VectorView<> values, VectorView<> dvalues, VectorView<> ddvalues)
+  {
+    auto valmat = values.asMatrix(Masses().size(), D);
+    auto dvalmat = dvalues.asMatrix(Masses().size(), D);
+    auto ddvalmat = ddvalues.asMatrix(Masses().size(), D);
+
+    for (size_t i = 0; i < Masses().size(); i++)
+      {
+        Masses()[i].pos = valmat.row(i);
+        Masses()[i].vel = dvalmat.row(i);
+        Masses()[i].acc = ddvalmat.row(i);
+      }
+  }
+};
+
+template <int D>
+std::ostream & operator<< (std::ostream & ost, MassSpringSystem<D> & mss)
+{
+  ost << "fixes:" << std::endl;
+  for (auto f : mss.Fixes())
+    ost << f.pos << std::endl;
+
+  ost << "masses: " << std::endl;
+  for (auto m : mss.Masses())
+    ost << "m = " << m.mass << ", pos = " << m.pos << std::endl;
+
+  ost << "springs: " << std::endl;
+  for (auto sp : mss.Springs())
+    ost << "length = " << sp.length << ", stiffness = " << sp.stiffness
+        << ", C1 = " << sp.connections[0] << ", C2 = " << sp.connections[1] << std::endl;
+  return ost;
+}
+
+
+template <int D>
+class MSS_Function : public NonlinearFunction
+{
+  MassSpringSystem<D> & mss;
+public:
+  MSS_Function (MassSpringSystem<D> & _mss)
+    : mss(_mss) { }
+
+  virtual size_t dimX() const override { return D*mss.Masses().size(); }
+  virtual size_t dimF() const override{ return D*mss.Masses().size(); }
+
+  virtual void evaluate (VectorView<double> x, VectorView<double> f) const override
+  {
+    f = 0.0;
+    
+    auto xmat = x.asMatrix(mss.Masses().size(), D);
+    auto fmat = f.asMatrix(mss.Masses().size(), D);
+
+    for (size_t i = 0; i < mss.Masses().size(); i++)
+      fmat.row(i) = mss.Masses()[i].mass*mss.Gravity();
+    
+    for (auto spring : mss.Springs())
+      {
+        auto [c1,c2] = spring.connections;
+        Vec<D> p1, p2;
+        if (c1.type == Connector::FIX)
+          p1 = mss.Fixes()[c1.nr].pos;
+        else
+          p1 = xmat.row(c1.nr);
+        if (c2.type == Connector::FIX)
+          p2 = mss.Fixes()[c2.nr].pos;
+        else
+          p2 = xmat.row(c2.nr);
+
+        double force = spring.stiffness * (norm(p1-p2)-spring.length);
+        Vec<D> dir12 = 1.0/norm(p1-p2) * (p2-p1);
+        if (c1.type == Connector::MASS)
+          fmat.row(c1.nr) += force*dir12;
+        if (c2.type == Connector::MASS)
+          fmat.row(c2.nr) -= force*dir12;
+      }
+
+    for (size_t i = 0; i < mss.Masses().size(); i++)
+      fmat.row(i) *= 1.0/mss.Masses()[i].mass;
+  }
+  
+  virtual void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
+  {
+    // TODO: exact differentiation
+    double eps = 1e-8;
+    Vector<> xl(dimX()), xr(dimX()), fl(dimF()), fr(dimF());
+    for (size_t i = 0; i < dimX(); i++)
+      {
+        xl = x;
+        xl(i) -= eps;
+        xr = x;
+        xr(i) += eps;
+        evaluate (xl, fl);
+        evaluate (xr, fr);
+        df.col(i) = 1/(2*eps) * (fr-fl);
+      }
+  }
+  
+};
+
+#endif
diff --git a/mechsystem/mass_spring.ipynb b/mechsystem/mass_spring.ipynb
new file mode 100644
index 000000000..8c8288831
--- /dev/null
+++ b/mechsystem/mass_spring.ipynb
@@ -0,0 +1,152 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8c22d9bc-c86b-434f-b0f3-0e01290fd183",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.append('/Users/joachim/texjs/lva/ws2324/ScientificComputing/ASC-ODE/build/mass_spring')\n",
+    "\n",
+    "from mass_spring import *\n",
+    "import ngsolve.bla\n",
+    "\n",
+    "from pythreejs import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "24f72163-bcb0-45bf-8407-66384ad3fbc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mss = MassSpringSystem3d()\n",
+    "mss.gravity = (0,0,-9.81)\n",
+    "\n",
+    "mA = mss.Add (Mass(1, (1,0,0)))\n",
+    "mB = mss.Add (Mass(2, (2,0,0)))\n",
+    "f1 = mss.Add (Fix( (0,0,0)) )\n",
+    "mss.Add (Spring(1, 200000, (f1, mA)))\n",
+    "mss.Add (Spring(1, 100000, (mA, mB)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c5c8bdfc-9022-4def-bf04-4511756651ea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masses = []\n",
+    "for m in mss.masses:\n",
+    "    masses.append(\n",
+    "        Mesh(SphereBufferGeometry(0.2, 16, 16),\n",
+    "             MeshStandardMaterial(color='red'),\n",
+    "             position=(m.pos[0], m.pos[1], m.pos[2])))\n",
+    "\n",
+    "fixes = []\n",
+    "for f in mss.fixes:\n",
+    "    fixes.append(\n",
+    "        Mesh(SphereBufferGeometry(0.2, 32, 16),\n",
+    "             MeshStandardMaterial(color='blue'),\n",
+    "             position=(f.pos[0], f.pos[1], f.pos[2])))\n",
+    "\n",
+    "springpos = []\n",
+    "for s in mss.springs:\n",
+    "    pA = mss[s.connections[0]].pos\n",
+    "    pB = mss[s.connections[1]].pos\n",
+    "    springpos.append ([ [pA[0], pA[1], pA[2]], [pB[0], pB[1], pB[2]] ])\n",
+    "\n",
+    "springgeo = LineSegmentsGeometry(positions=springpos)\n",
+    "m2 = LineMaterial(linewidth=3, color='cyan')\n",
+    "springs = LineSegments2(springgeo, m2)    \n",
+    "\n",
+    "axes = AxesHelper(1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c13e6200-9cab-4df1-8240-f03414ff9b20",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "view_width = 600\n",
+    "view_height = 400\n",
+    "\n",
+    "camera = PerspectiveCamera( position=[10, 6, 10], aspect=view_width/view_height)\n",
+    "key_light = DirectionalLight(position=[0, 10, 10])\n",
+    "ambient_light = AmbientLight()\n",
+    "\n",
+    "scene = Scene(children=[*masses, *fixes, springs, axes, camera, key_light, ambient_light])\n",
+    "controller = OrbitControls(controlling=camera)\n",
+    "renderer = Renderer(camera=camera, scene=scene, controls=[controller],\n",
+    "                    width=view_width, height=view_height)\n",
+    "\n",
+    "renderer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1f6bdd5d-d385-4431-a3e7-923ebfb70949",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from time import sleep\n",
+    "for i in range(10000):\n",
+    "    Simulate (mss, 0.02, 100)\n",
+    "    for m,mvis in zip(mss.masses, masses):\n",
+    "        mvis.position = (m.pos[0], m.pos[1], m.pos[2])\n",
+    "\n",
+    "    springpos = []\n",
+    "    for s in mss.springs:\n",
+    "        pA = mss[s.connections[0]].pos\n",
+    "        pB = mss[s.connections[1]].pos\n",
+    "        springpos.append ([ [pA[0], pA[1], pA[2]], [pB[0], pB[1], pB[2]] ])\n",
+    "    springs.geometry = LineSegmentsGeometry(positions=springpos)\n",
+    "    sleep(0.01)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "35a71576-da30-469c-b391-698dde7681bf",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fd64d66b-f881-4d3a-95d5-302d91f695f3",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/mechsystem/test_mass_spring.py b/mechsystem/test_mass_spring.py
new file mode 100644
index 000000000..251913214
--- /dev/null
+++ b/mechsystem/test_mass_spring.py
@@ -0,0 +1,35 @@
+import sys
+sys.path.append('/Users/joachim/texjs/lva/IntroSC/ASC-ODE/build/mechsystem')
+
+from mass_spring import *
+import ngsolve.bla
+
+
+mss = MassSpringSystem3d()
+mss.gravity = (0,0,-9.81)
+
+mA = mss.Add (Mass(1, (1,0,0)))
+mB = mss.Add (Mass(2, (2,0,0)))
+f1 = mss.Add (Fix( (0,0,0)) )
+mss.Add (Spring(1, 10, (f1, mA)))
+mss.Add (Spring(1, 20, (mA, mB)))
+
+
+print ("state = ", mss.GetState())
+
+Simulate (mss, 0.1, 10)
+
+print ("state = ", mss.GetState())
+
+
+Simulate (mss, 0.1, 10)
+
+print ("state = ", mss.GetState())
+
+for m in mss.masses:
+    print (m.mass, m.pos)
+
+mss.masses[0].mass = 5
+
+for m in mss.masses:
+    print (m.mass, m.pos)

From 246905e5482330c11bd7233ffefe5bcdb95b8042 Mon Sep 17 00:00:00 2001
From: Joachim Schoeberl <joachim.schoeberl@tuwien.ac.at>
Date: Sun, 23 Nov 2025 13:58:02 +0100
Subject: [PATCH 06/20] update py-binding

---
 mechsystem/bind_mass_spring.cpp |  48 +++++++-------
 mechsystem/mass_spring.cpp      |  22 +++----
 mechsystem/mass_spring.hpp      | 108 ++++++++++++++++----------------
 mechsystem/test_mass_spring.py  |  16 ++---
 4 files changed, 97 insertions(+), 97 deletions(-)

diff --git a/mechsystem/bind_mass_spring.cpp b/mechsystem/bind_mass_spring.cpp
index 427b2fb65..72e8a43fb 100644
--- a/mechsystem/bind_mass_spring.cpp
+++ b/mechsystem/bind_mass_spring.cpp
@@ -32,7 +32,7 @@ PYBIND11_MODULE(mass_spring, m) {
                     [](Mass<3> & m) { return m.mass; },
                     [](Mass<3> & m, double mass) { m.mass = mass; })
       .def_property_readonly("pos",
-                             [](Mass<3> & m) { return m.pos; });
+                             [](Mass<3> & m) { return m.pos.data(); });
     ;
 
     
@@ -68,7 +68,7 @@ PYBIND11_MODULE(mass_spring, m) {
     
     py::class_<MassSpringSystem<2>> (m, "MassSpringSystem2d")
       .def(py::init<>())
-      .def("Add", [](MassSpringSystem<2> & mss, Mass<2> m) { return mss.AddMass(m); })
+      .def("add", [](MassSpringSystem<2> & mss, Mass<2> m) { return mss.addMass(m); })
       ;
       
         
@@ -79,41 +79,41 @@ PYBIND11_MODULE(mass_spring, m) {
         sstr << mss;
         return sstr.str();
       })
-      .def_property("gravity", [](MassSpringSystem<3> & mss) { return mss.Gravity(); },
-                    [](MassSpringSystem<3> & mss, std::array<double,3> g) { mss.SetGravity(Vec<3>{g[0],g[1],g[2]}); })
-      .def("Add", [](MassSpringSystem<3> & mss, Mass<3> m) { return mss.AddMass(m); })
-      .def("Add", [](MassSpringSystem<3> & mss, Fix<3> f) { return mss.AddFix(f); })
-      .def("Add", [](MassSpringSystem<3> & mss, Spring s) { return mss.AddSpring(s); })            
-      .def_property_readonly("masses", [](MassSpringSystem<3> & mss) -> auto& { return mss.Masses(); })
-      .def_property_readonly("fixes", [](MassSpringSystem<3> & mss) -> auto& { return mss.Fixes(); })
-      .def_property_readonly("springs", [](MassSpringSystem<3> & mss) -> auto& { return mss.Springs(); })            
+      .def_property("gravity", [](MassSpringSystem<3> & mss) { return mss.getGravity(); },
+                    [](MassSpringSystem<3> & mss, std::array<double,3> g) { mss.setGravity(Vec<3>{g[0],g[1],g[2]}); })
+      .def("add", [](MassSpringSystem<3> & mss, Mass<3> m) { return mss.addMass(m); })
+      .def("add", [](MassSpringSystem<3> & mss, Fix<3> f) { return mss.addFix(f); })
+      .def("add", [](MassSpringSystem<3> & mss, Spring s) { return mss.addSpring(s); })
+      .def_property_readonly("masses", [](MassSpringSystem<3> & mss) -> auto& { return mss.masses(); })
+      .def_property_readonly("fixes", [](MassSpringSystem<3> & mss) -> auto& { return mss.fixes(); })
+      .def_property_readonly("springs", [](MassSpringSystem<3> & mss) -> auto& { return mss.springs(); })
       .def("__getitem__", [](MassSpringSystem<3> mss, Connector & c) {
-        if (c.type==Connector::FIX) return py::cast(mss.Fixes()[c.nr]);
-        else return py::cast(mss.Masses()[c.nr]);
+        if (c.type==Connector::FIX) return py::cast(mss.fixes()[c.nr]);
+        else return py::cast(mss.masses()[c.nr]);
       })
       
-      .def("GetState", [] (MassSpringSystem<3> & mss) {
-        Vector<> x(3*mss.Masses().size());
-        Vector<> dx(3*mss.Masses().size());
-        Vector<> ddx(3*mss.Masses().size());
-        mss.GetState (x, dx, ddx);
-        return x;
+      .def("getState", [] (MassSpringSystem<3> & mss) {
+        Vector<> x(3*mss.masses().size());
+        Vector<> dx(3*mss.masses().size());
+        Vector<> ddx(3*mss.masses().size());
+        mss.getState (x, dx, ddx);
+        return std::vector<double>(x);
       })
       ;
     
 
     m.def("Simulate", [](MassSpringSystem<3> & mss, double tend, size_t steps) {
-      Vector<> x(3*mss.Masses().size());
-      Vector<> dx(3*mss.Masses().size());
-      Vector<> ddx(3*mss.Masses().size());
-      mss.GetState (x, dx, ddx);
-      
+      Vector<> x(3*mss.masses().size());
+      Vector<> dx(3*mss.masses().size());
+      Vector<> ddx(3*mss.masses().size());
+      mss.getState (x, dx, ddx);
+
       auto mss_func = std::make_shared<MSS_Function<3>> (mss);
       auto mass = std::make_shared<IdentityFunction> (x.size());
 
       SolveODE_Alpha(tend, steps, 0.8, x, dx, ddx, mss_func, mass);
 
-      mss.SetState (x, dx, ddx);
+      mss.setState (x, dx, ddx);
     });
       
     
diff --git a/mechsystem/mass_spring.cpp b/mechsystem/mass_spring.cpp
index a8a3d9dbf..c4c80c3f8 100644
--- a/mechsystem/mass_spring.cpp
+++ b/mechsystem/mass_spring.cpp
@@ -4,28 +4,28 @@
 int main()
 {
   MassSpringSystem<2> mss;
-  mss.SetGravity( {0,-9.81} );
-  auto fA = mss.AddFix( { { 0.0, 0.0 } } );
-  auto mA = mss.AddMass( { 1, { 1.0, 0.0 } } );
-  mss.AddSpring ( { 1, 10, { fA, mA } }  );
+  mss.setGravity( {0,-9.81} );
+  auto fA = mss.addFix( { { 0.0, 0.0 } } );
+  auto mA = mss.addMass( { 1, { 1.0, 0.0 } } );
+  mss.addSpring ( { 1, 10, { fA, mA } }  );
 
-  auto mB = mss.AddMass( { 1, { 2.0, 0.0 } } );
-  mss.AddSpring ( { 1, 20, { mA, mB } } );
+  auto mB = mss.addMass( { 1, { 2.0, 0.0 } } );
+  mss.addSpring ( { 1, 20, { mA, mB } } );
 
   std::cout << "mss: " << std::endl << mss << std::endl;
 
 
   double tend = 10;
   double steps = 1000;
-  
-  Vector<> x(2*mss.Masses().size());
-  Vector<> dx(2*mss.Masses().size());  
-  Vector<> ddx(2*mss.Masses().size());  
+
+  Vector<> x(2*mss.masses().size());
+  Vector<> dx(2*mss.masses().size());
+  Vector<> ddx(2*mss.masses().size());
 
   auto mss_func = std::make_shared<MSS_Function<2>> (mss);
   auto mass = std::make_shared<IdentityFunction> (x.size());
 
-  mss.GetState (x, dx, ddx);
+  mss.getState (x, dx, ddx);
   
   SolveODE_Newmark(tend, steps, x, dx,  mss_func, mass,
                    [](double t, VectorView<double> x) { std::cout << "t = " << t
diff --git a/mechsystem/mass_spring.hpp b/mechsystem/mass_spring.hpp
index 93bd11557..7c2d31ec1 100644
--- a/mechsystem/mass_spring.hpp
+++ b/mechsystem/mass_spring.hpp
@@ -57,64 +57,64 @@ class Spring
 template <int D>
 class MassSpringSystem
 {
-  std::vector<Fix<D>> fixes;
-  std::vector<Mass<D>> masses;
-  std::vector<Spring> springs;
-  Vec<D> gravity=0.0;
+  std::vector<Fix<D>> m_fixes;
+  std::vector<Mass<D>> m_masses;
+  std::vector<Spring> m_springs;
+  Vec<D> m_gravity=0.0;
 public:
-  void SetGravity (Vec<D> _gravity) { gravity = _gravity; }
-  Vec<D> Gravity() const { return gravity; }
-  
-  Connector AddFix (Fix<D> p)
+  void setGravity (Vec<D> gravity) { m_gravity = gravity; }
+  Vec<D> getGravity() const { return m_gravity; }
+
+  Connector addFix (Fix<D> p)
   {
-    fixes.push_back(p);
-    return { Connector::FIX, fixes.size()-1 };
+    m_fixes.push_back(p);
+    return { Connector::FIX, m_fixes.size()-1 };
   }
 
-  Connector AddMass (Mass<D> m)
+  Connector addMass (Mass<D> m)
   {
-    masses.push_back (m);
-    return { Connector::MASS, masses.size()-1 };
+    m_masses.push_back (m);
+    return { Connector::MASS, m_masses.size()-1 };
   }
   
-  size_t AddSpring (Spring s) // double length, double stiffness, Connector c1, Connector c2)
+  size_t addSpring (Spring s) // double length, double stiffness, Connector c1, Connector c2)
   {
-    springs.push_back (s); // Spring{length, stiffness, { c1, c2 } });
-    return springs.size()-1;
+    m_springs.push_back (s); // Spring{length, stiffness, { c1, c2 } });
+    return m_springs.size()-1;
   }
 
 
 
-  
-  auto & Fixes() { return fixes; } 
-  auto & Masses() { return masses; } 
-  auto & Springs() { return springs; }
 
-  void GetState (VectorView<> values, VectorView<> dvalues, VectorView<> ddvalues)
+  auto & fixes() { return m_fixes; } 
+  auto & masses() { return m_masses; } 
+  auto & springs() { return m_springs; }
+
+  void getState (VectorView<> values, VectorView<> dvalues, VectorView<> ddvalues)
   {
-    auto valmat = values.asMatrix(Masses().size(), D);
-    auto dvalmat = dvalues.asMatrix(Masses().size(), D);
-    auto ddvalmat = ddvalues.asMatrix(Masses().size(), D);    
+    auto valmat = values.asMatrix(m_masses.size(), D);
+    auto dvalmat = dvalues.asMatrix(m_masses.size(), D);
+    auto ddvalmat = ddvalues.asMatrix(m_masses.size(), D);
 
-    for (size_t i = 0; i < Masses().size(); i++)
+    for (size_t i = 0; i < m_masses.size(); i++)
       {
-        valmat.row(i) = Masses()[i].pos;
-        dvalmat.row(i) = Masses()[i].vel;
-        ddvalmat.row(i) = Masses()[i].acc;
+        valmat.row(i) = m_masses[i].pos;
+        dvalmat.row(i) = m_masses[i].vel;
+        ddvalmat.row(i) = m_masses[i].acc;
       }
   }
-  
-  void SetState (VectorView<> values, VectorView<> dvalues, VectorView<> ddvalues)
+
+  void setState (VectorView<> values, VectorView<> dvalues, VectorView<> ddvalues)
   {
-    auto valmat = values.asMatrix(Masses().size(), D);
-    auto dvalmat = dvalues.asMatrix(Masses().size(), D);
-    auto ddvalmat = ddvalues.asMatrix(Masses().size(), D);
+    auto valmat = values.asMatrix(m_masses.size(), D);
+    auto dvalmat = dvalues.asMatrix(m_masses.size(), D);
+    auto ddvalmat = ddvalues.asMatrix(m_masses.size(), D);
 
-    for (size_t i = 0; i < Masses().size(); i++)
+    for (size_t i = 0; i < m_masses.size(); i++)
       {
-        Masses()[i].pos = valmat.row(i);
-        Masses()[i].vel = dvalmat.row(i);
-        Masses()[i].acc = ddvalmat.row(i);
+        m_masses[i].pos = valmat.row(i);
+        m_masses[i].vel = dvalmat.row(i);
+        m_masses[i].acc = ddvalmat.row(i);
       }
   }
 };
@@ -123,15 +123,15 @@ template <int D>
 std::ostream & operator<< (std::ostream & ost, MassSpringSystem<D> & mss)
 {
   ost << "fixes:" << std::endl;
-  for (auto f : mss.Fixes())
+  for (auto f : mss.fixes())
     ost << f.pos << std::endl;
 
   ost << "masses: " << std::endl;
-  for (auto m : mss.Masses())
+  for (auto m : mss.masses())
     ost << "m = " << m.mass << ", pos = " << m.pos << std::endl;
 
   ost << "springs: " << std::endl;
-  for (auto sp : mss.Springs())
+  for (auto sp : mss.springs())
     ost << "length = " << sp.length << ", stiffness = " << sp.stiffness
         << ", C1 = " << sp.connections[0] << ", C2 = " << sp.connections[1] << std::endl;
   return ost;
@@ -146,29 +146,29 @@ class MSS_Function : public NonlinearFunction
   MSS_Function (MassSpringSystem<D> & _mss)
     : mss(_mss) { }
 
-  virtual size_t dimX() const override { return D*mss.Masses().size(); }
-  virtual size_t dimF() const override{ return D*mss.Masses().size(); }
+  virtual size_t dimX() const override { return D*mss.masses().size(); }
+  virtual size_t dimF() const override{ return D*mss.masses().size(); }
 
   virtual void evaluate (VectorView<double> x, VectorView<double> f) const override
   {
     f = 0.0;
-    
-    auto xmat = x.asMatrix(mss.Masses().size(), D);
-    auto fmat = f.asMatrix(mss.Masses().size(), D);
-
-    for (size_t i = 0; i < mss.Masses().size(); i++)
-      fmat.row(i) = mss.Masses()[i].mass*mss.Gravity();
-    
-    for (auto spring : mss.Springs())
+
+    auto xmat = x.asMatrix(mss.masses().size(), D);
+    auto fmat = f.asMatrix(mss.masses().size(), D);
+
+    for (size_t i = 0; i < mss.masses().size(); i++)
+      fmat.row(i) = mss.masses()[i].mass*mss.getGravity();
+
+    for (auto spring : mss.springs())
       {
         auto [c1,c2] = spring.connections;
         Vec<D> p1, p2;
         if (c1.type == Connector::FIX)
-          p1 = mss.Fixes()[c1.nr].pos;
+          p1 = mss.fixes()[c1.nr].pos;
         else
           p1 = xmat.row(c1.nr);
         if (c2.type == Connector::FIX)
-          p2 = mss.Fixes()[c2.nr].pos;
+          p2 = mss.fixes()[c2.nr].pos;
         else
           p2 = xmat.row(c2.nr);
 
@@ -180,8 +180,8 @@ class MSS_Function : public NonlinearFunction
           fmat.row(c2.nr) -= force*dir12;
       }
 
-    for (size_t i = 0; i < mss.Masses().size(); i++)
-      fmat.row(i) *= 1.0/mss.Masses()[i].mass;
+    for (size_t i = 0; i < mss.masses().size(); i++)
+      fmat.row(i) *= 1.0/mss.masses()[i].mass;
   }
   
   virtual void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
diff --git a/mechsystem/test_mass_spring.py b/mechsystem/test_mass_spring.py
index 251913214..d38e8b4b8 100644
--- a/mechsystem/test_mass_spring.py
+++ b/mechsystem/test_mass_spring.py
@@ -8,23 +8,23 @@
 mss = MassSpringSystem3d()
 mss.gravity = (0,0,-9.81)
 
-mA = mss.Add (Mass(1, (1,0,0)))
-mB = mss.Add (Mass(2, (2,0,0)))
-f1 = mss.Add (Fix( (0,0,0)) )
-mss.Add (Spring(1, 10, (f1, mA)))
-mss.Add (Spring(1, 20, (mA, mB)))
+mA = mss.add (Mass(1, (1,0,0)))
+mB = mss.add (Mass(2, (2,0,0)))
+f1 = mss.add (Fix( (0,0,0)) )
+mss.add (Spring(1, 10, (f1, mA)))
+mss.add (Spring(1, 20, (mA, mB)))
 
 
-print ("state = ", mss.GetState())
+print ("state = ", mss.getState())
 
 Simulate (mss, 0.1, 10)
 
-print ("state = ", mss.GetState())
+print ("state = ", mss.getState())
 
 
 Simulate (mss, 0.1, 10)
 
-print ("state = ", mss.GetState())
+print ("state = ", mss.getState())
 
 for m in mss.masses:
     print (m.mass, m.pos)

From 4da68b3d2727189577f2eae396b1b2639d443f26 Mon Sep 17 00:00:00 2001
From: Joachim Schoeberl <joachim.schoeberl@tuwien.ac.at>
Date: Sun, 23 Nov 2025 14:30:40 +0100
Subject: [PATCH 07/20] cleaning up py-bindings

---
 mechsystem/bind_mass_spring.cpp | 53 ++++++++++++++---------
 mechsystem/mass_spring.hpp      | 16 +++----
 mechsystem/mass_spring.ipynb    | 74 ++++++++++++++++++++++-----------
 mechsystem/test_mass_spring.py  |  4 +-
 4 files changed, 90 insertions(+), 57 deletions(-)

diff --git a/mechsystem/bind_mass_spring.cpp b/mechsystem/bind_mass_spring.cpp
index 72e8a43fb..049f03141 100644
--- a/mechsystem/bind_mass_spring.cpp
+++ b/mechsystem/bind_mass_spring.cpp
@@ -16,6 +16,12 @@ PYBIND11_MODULE(mass_spring, m) {
     m.doc() = "mass-spring-system simulator"; 
 
     py::class_<Mass<2>> (m, "Mass2d")
+          .def_property("mass",
+                    [](Mass<2> & m) { return m.mass; },
+                    [](Mass<2> & m, double mass) { m.mass = mass; })
+      .def_property_readonly("pos",
+                             [](Mass<2> & m) { return m.pos.data(); });
+
       ;
       
     m.def("Mass", [](double m, std::array<double,2> p)
@@ -23,9 +29,6 @@ PYBIND11_MODULE(mass_spring, m) {
       return Mass<2>{m, { p[0], p[1] }};
     });
 
-
-    
-
     
     py::class_<Mass<3>> (m, "Mass3d")
       .def_property("mass",
@@ -35,18 +38,28 @@ PYBIND11_MODULE(mass_spring, m) {
                              [](Mass<3> & m) { return m.pos.data(); });
     ;
 
-    
     m.def("Mass", [](double m, std::array<double,3> p)
     {
       return Mass<3>{m, { p[0], p[1], p[2] }};
     });
 
+
+
+    py::class_<Fix<2>> (m, "Fix2d")
+      .def_property_readonly("pos",
+                             [](Fix<2> & f) { return f.pos.data(); });
+
+    m.def("Fix", [](std::array<double,2> p)
+    {
+      return Fix<2>{ { p[0], p[1] } };
+    });
+
+
     
     py::class_<Fix<3>> (m, "Fix3d")
       .def_property_readonly("pos",
-                             [](Fix<3> & f) { return f.pos; });
+                             [](Fix<3> & f) { return f.pos.data(); });
     
-
     m.def("Fix", [](std::array<double,3> p)
     {
       return Fix<3>{ { p[0], p[1], p[2] } };
@@ -56,8 +69,8 @@ PYBIND11_MODULE(mass_spring, m) {
 
     py::class_<Spring> (m, "Spring")
       .def(py::init<double, double, std::array<Connector,2>>())
-      .def_property_readonly("connections",
-                             [](Spring & s) { return s.connections; })
+      .def_property_readonly("connectors",
+                             [](Spring & s) { return s.connectors; })
       ;
 
     
@@ -99,22 +112,22 @@ PYBIND11_MODULE(mass_spring, m) {
         mss.getState (x, dx, ddx);
         return std::vector<double>(x);
       })
-      ;
-    
 
-    m.def("Simulate", [](MassSpringSystem<3> & mss, double tend, size_t steps) {
-      Vector<> x(3*mss.masses().size());
-      Vector<> dx(3*mss.masses().size());
-      Vector<> ddx(3*mss.masses().size());
-      mss.getState (x, dx, ddx);
+      .def("simulate", [](MassSpringSystem<3> & mss, double tend, size_t steps) {
+        Vector<> x(3*mss.masses().size());
+        Vector<> dx(3*mss.masses().size());
+        Vector<> ddx(3*mss.masses().size());
+        mss.getState (x, dx, ddx);
 
-      auto mss_func = std::make_shared<MSS_Function<3>> (mss);
-      auto mass = std::make_shared<IdentityFunction> (x.size());
+        auto mss_func = std::make_shared<MSS_Function<3>> (mss);
+        auto mass = std::make_shared<IdentityFunction> (x.size());
 
-      SolveODE_Alpha(tend, steps, 0.8, x, dx, ddx, mss_func, mass);
+        SolveODE_Alpha(tend, steps, 0.8, x, dx, ddx, mss_func, mass);
 
-      mss.setState (x, dx, ddx);
+        mss.setState (x, dx, ddx);  
     });
-      
+
+
+  
     
 }
diff --git a/mechsystem/mass_spring.hpp b/mechsystem/mass_spring.hpp
index 7c2d31ec1..dc9ddaebf 100644
--- a/mechsystem/mass_spring.hpp
+++ b/mechsystem/mass_spring.hpp
@@ -1,8 +1,6 @@
 #ifndef MASS_SPRING_HPP
 #define MASS_SPRING_HPP
 
-
-
 #include <nonlinfunc.hpp>
 #include <timestepper.hpp>
 
@@ -12,7 +10,6 @@ using namespace ASC_ode;
 using namespace nanoblas;
 
 
-
 template <int D>
 class Mass
 {
@@ -51,7 +48,7 @@ class Spring
 public:
   double length;  
   double stiffness;
-  std::array<Connector,2> connections;
+  std::array<Connector,2> connectors;
 };
 
 template <int D>
@@ -77,15 +74,12 @@ class MassSpringSystem
     return { Connector::MASS, m_masses.size()-1 };
   }
   
-  size_t addSpring (Spring s) // double length, double stiffness, Connector c1, Connector c2)
+  size_t addSpring (Spring s) 
   {
-    m_springs.push_back (s); // Spring{length, stiffness, { c1, c2 } });
+    m_springs.push_back (s); 
     return m_springs.size()-1;
   }
 
-
-
-
   auto & fixes() { return m_fixes; } 
   auto & masses() { return m_masses; } 
   auto & springs() { return m_springs; }
@@ -133,7 +127,7 @@ std::ostream & operator<< (std::ostream & ost, MassSpringSystem<D> & mss)
   ost << "springs: " << std::endl;
   for (auto sp : mss.springs())
     ost << "length = " << sp.length << ", stiffness = " << sp.stiffness
-        << ", C1 = " << sp.connections[0] << ", C2 = " << sp.connections[1] << std::endl;
+        << ", C1 = " << sp.connectors[0] << ", C2 = " << sp.connectors[1] << std::endl;
   return ost;
 }
 
@@ -161,7 +155,7 @@ class MSS_Function : public NonlinearFunction
 
     for (auto spring : mss.springs())
       {
-        auto [c1,c2] = spring.connections;
+        auto [c1,c2] = spring.connectors;
         Vec<D> p1, p2;
         if (c1.type == Connector::FIX)
           p1 = mss.fixes()[c1.nr].pos;
diff --git a/mechsystem/mass_spring.ipynb b/mechsystem/mass_spring.ipynb
index 8c8288831..c490d3cab 100644
--- a/mechsystem/mass_spring.ipynb
+++ b/mechsystem/mass_spring.ipynb
@@ -2,40 +2,50 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "8c22d9bc-c86b-434f-b0f3-0e01290fd183",
    "metadata": {},
    "outputs": [],
    "source": [
     "import sys\n",
-    "sys.path.append('/Users/joachim/texjs/lva/ws2324/ScientificComputing/ASC-ODE/build/mass_spring')\n",
+    "sys.path.append('/Users/joachim/texjs/lva/IntroSC/ASC-ODE/build/mechsystem')\n",
     "\n",
     "from mass_spring import *\n",
-    "import ngsolve.bla\n",
     "\n",
     "from pythreejs import *"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "24f72163-bcb0-45bf-8407-66384ad3fbc4",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "mss = MassSpringSystem3d()\n",
     "mss.gravity = (0,0,-9.81)\n",
     "\n",
-    "mA = mss.Add (Mass(1, (1,0,0)))\n",
-    "mB = mss.Add (Mass(2, (2,0,0)))\n",
-    "f1 = mss.Add (Fix( (0,0,0)) )\n",
-    "mss.Add (Spring(1, 200000, (f1, mA)))\n",
-    "mss.Add (Spring(1, 100000, (mA, mB)))"
+    "mA = mss.add (Mass(1, (1,0,0)))\n",
+    "mB = mss.add (Mass(2, (2,0,0)))\n",
+    "f1 = mss.add (Fix( (0,0,0)) )\n",
+    "mss.add (Spring(1, 200000, (f1, mA)))\n",
+    "mss.add (Spring(1, 100000, (mA, mB)))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "c5c8bdfc-9022-4def-bf04-4511756651ea",
    "metadata": {},
    "outputs": [],
@@ -45,20 +55,20 @@
     "    masses.append(\n",
     "        Mesh(SphereBufferGeometry(0.2, 16, 16),\n",
     "             MeshStandardMaterial(color='red'),\n",
-    "             position=(m.pos[0], m.pos[1], m.pos[2])))\n",
+    "             position=m.pos)) \n",
     "\n",
     "fixes = []\n",
     "for f in mss.fixes:\n",
     "    fixes.append(\n",
     "        Mesh(SphereBufferGeometry(0.2, 32, 16),\n",
     "             MeshStandardMaterial(color='blue'),\n",
-    "             position=(f.pos[0], f.pos[1], f.pos[2])))\n",
+    "             position=(f.pos))) \n",
     "\n",
     "springpos = []\n",
     "for s in mss.springs:\n",
-    "    pA = mss[s.connections[0]].pos\n",
-    "    pB = mss[s.connections[1]].pos\n",
-    "    springpos.append ([ [pA[0], pA[1], pA[2]], [pB[0], pB[1], pB[2]] ])\n",
+    "    pA = mss[s.connectors[0]].pos\n",
+    "    pB = mss[s.connectors[1]].pos\n",
+    "    springpos.append ([ pA, pB ] ) \n",
     "\n",
     "springgeo = LineSegmentsGeometry(positions=springpos)\n",
     "m2 = LineMaterial(linewidth=3, color='cyan')\n",
@@ -69,10 +79,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "c13e6200-9cab-4df1-8240-f03414ff9b20",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "133c9d290be24445bfd102b95674b261",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Renderer(camera=PerspectiveCamera(aspect=1.5, position=(10.0, 6.0, 10.0), projectionMatrix=(1.0, 0.0, 0.0, 0.0…"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "view_width = 600\n",
     "view_height = 400\n",
@@ -98,15 +124,15 @@
    "source": [
     "from time import sleep\n",
     "for i in range(10000):\n",
-    "    Simulate (mss, 0.02, 100)\n",
+    "    mss.simulate (0.02, 100)\n",
     "    for m,mvis in zip(mss.masses, masses):\n",
     "        mvis.position = (m.pos[0], m.pos[1], m.pos[2])\n",
     "\n",
     "    springpos = []\n",
     "    for s in mss.springs:\n",
-    "        pA = mss[s.connections[0]].pos\n",
-    "        pB = mss[s.connections[1]].pos\n",
-    "        springpos.append ([ [pA[0], pA[1], pA[2]], [pB[0], pB[1], pB[2]] ])\n",
+    "        pA = mss[s.connectors[0]].pos\n",
+    "        pB = mss[s.connectors[1]].pos\n",
+    "        springpos.append ([ pA, pB ]) \n",
     "    springs.geometry = LineSegmentsGeometry(positions=springpos)\n",
     "    sleep(0.01)"
    ]
@@ -130,7 +156,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
@@ -144,7 +170,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.0"
+   "version": "3.14.0"
   }
  },
  "nbformat": 4,
diff --git a/mechsystem/test_mass_spring.py b/mechsystem/test_mass_spring.py
index d38e8b4b8..1704af0b7 100644
--- a/mechsystem/test_mass_spring.py
+++ b/mechsystem/test_mass_spring.py
@@ -17,12 +17,12 @@
 
 print ("state = ", mss.getState())
 
-Simulate (mss, 0.1, 10)
+mss.simulate (0.1, 10)
 
 print ("state = ", mss.getState())
 
 
-Simulate (mss, 0.1, 10)
+mss.simulate (0.1, 10)
 
 print ("state = ", mss.getState())
 

From 3f8a6f51c1c9be925c9c0e90e494f5834a8eabb5 Mon Sep 17 00:00:00 2001
From: Joachim Schoeberl <joachim.schoeberl@tuwien.ac.at>
Date: Sun, 23 Nov 2025 14:54:43 +0100
Subject: [PATCH 08/20] cleanup notebook

---
 mechsystem/mass_spring.ipynb | 57 +++++-------------------------------
 1 file changed, 7 insertions(+), 50 deletions(-)

diff --git a/mechsystem/mass_spring.ipynb b/mechsystem/mass_spring.ipynb
index c490d3cab..6291a1517 100644
--- a/mechsystem/mass_spring.ipynb
+++ b/mechsystem/mass_spring.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "8c22d9bc-c86b-434f-b0f3-0e01290fd183",
    "metadata": {},
    "outputs": [],
@@ -17,21 +17,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "24f72163-bcb0-45bf-8407-66384ad3fbc4",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "mss = MassSpringSystem3d()\n",
     "mss.gravity = (0,0,-9.81)\n",
@@ -45,7 +34,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "c5c8bdfc-9022-4def-bf04-4511756651ea",
    "metadata": {},
    "outputs": [],
@@ -62,7 +51,7 @@
     "    fixes.append(\n",
     "        Mesh(SphereBufferGeometry(0.2, 32, 16),\n",
     "             MeshStandardMaterial(color='blue'),\n",
-    "             position=(f.pos))) \n",
+    "             position=f.pos)) \n",
     "\n",
     "springpos = []\n",
     "for s in mss.springs:\n",
@@ -79,26 +68,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "c13e6200-9cab-4df1-8240-f03414ff9b20",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "133c9d290be24445bfd102b95674b261",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Renderer(camera=PerspectiveCamera(aspect=1.5, position=(10.0, 6.0, 10.0), projectionMatrix=(1.0, 0.0, 0.0, 0.0…"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "view_width = 600\n",
     "view_height = 400\n",
@@ -136,22 +109,6 @@
     "    springs.geometry = LineSegmentsGeometry(positions=springpos)\n",
     "    sleep(0.01)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "35a71576-da30-469c-b391-698dde7681bf",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "fd64d66b-f881-4d3a-95d5-302d91f695f3",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

From 03462f0ce3856b35806e23f92bb111285631dc50 Mon Sep 17 00:00:00 2001
From: Farooq Mian Azan <e12433773@student.tuwien.ac.at>
Date: Mon, 24 Nov 2025 09:16:56 +0000
Subject: [PATCH 09/20] Exercise 17

---
 .../CMakeLists-checkpoint.txt                 |   3 +
 .../CrankNicolson-checkpoint.hpp              |  34 +++
 .../ImplicitEuler-checkpoint.hpp              |  27 ++
 .../ImprovedEuler-checkpoint.hpp              |  21 ++
 src/.ipynb_checkpoints/Newton-checkpoint.hpp  |  52 ++++
 .../bindings-checkpoint.cpp                   |  41 +++
 .../function_algebra-checkpoint.hpp           |   9 +
 src/.ipynb_checkpoints/main-checkpoint.cpp    |  40 +++
 .../mass_spring_function-checkpoint.hpp       |  39 +++
 src/.ipynb_checkpoints/matrix-checkpoint.hpp  |   0
 .../myfunction-checkpoint.hpp                 |  23 ++
 .../newton-checkpoint.hpp}                    |   2 +-
 .../nonlinfunc-checkpoint.hpp                 |   1 +
 .../timestepper-checkpoint.cpp                |  79 ++++++
 .../timestepper-checkpoint.hpp                |  39 +++
 src/.ipynb_checkpoints/vector-checkpoint.hpp  |   0
 src/autodiff.hpp                              | 111 --------
 src/bindings.cpp                              |  11 -
 src/compare_all                               | Bin 0 -> 2212134 bytes
 src/function_algebra.hpp                      |   1 +
 src/mass_spring_function.hpp                  |   1 +
 src/matrix.hpp                                |   1 +
 src/newton.hpp                                |  41 +++
 src/nonlinfunc.hpp                            | 250 +-----------------
 src/timestepper.hpp                           |  65 +----
 src/vector.hpp                                |   1 +
 26 files changed, 456 insertions(+), 436 deletions(-)
 create mode 100644 src/.ipynb_checkpoints/CMakeLists-checkpoint.txt
 create mode 100644 src/.ipynb_checkpoints/CrankNicolson-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/ImplicitEuler-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/Newton-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/bindings-checkpoint.cpp
 create mode 100644 src/.ipynb_checkpoints/function_algebra-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/main-checkpoint.cpp
 create mode 100644 src/.ipynb_checkpoints/mass_spring_function-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/matrix-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/myfunction-checkpoint.hpp
 rename src/{Newton.hpp => .ipynb_checkpoints/newton-checkpoint.hpp} (99%)
 create mode 100644 src/.ipynb_checkpoints/nonlinfunc-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/timestepper-checkpoint.cpp
 create mode 100644 src/.ipynb_checkpoints/timestepper-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/vector-checkpoint.hpp
 delete mode 100644 src/autodiff.hpp
 delete mode 100644 src/bindings.cpp
 create mode 100644 src/compare_all
 create mode 100644 src/function_algebra.hpp
 create mode 100644 src/mass_spring_function.hpp
 create mode 100644 src/matrix.hpp
 create mode 100644 src/newton.hpp
 create mode 100644 src/vector.hpp

diff --git a/src/.ipynb_checkpoints/CMakeLists-checkpoint.txt b/src/.ipynb_checkpoints/CMakeLists-checkpoint.txt
new file mode 100644
index 000000000..ca77dc21b
--- /dev/null
+++ b/src/.ipynb_checkpoints/CMakeLists-checkpoint.txt
@@ -0,0 +1,3 @@
+
+install (FILES nonlinfunc.hpp Newton.hpp ode.hpp DESTINATION include) 
+
diff --git a/src/.ipynb_checkpoints/CrankNicolson-checkpoint.hpp b/src/.ipynb_checkpoints/CrankNicolson-checkpoint.hpp
new file mode 100644
index 000000000..5decba086
--- /dev/null
+++ b/src/.ipynb_checkpoints/CrankNicolson-checkpoint.hpp
@@ -0,0 +1,34 @@
+#pragma once
+#include "timestepper.hpp"
+#include "function_algebra.hpp"
+#include "newton.hpp"
+
+class CrankNicolson : public TimeStepper
+{
+    std::shared_ptr<NonlinearFunction> m_equ;
+    std::shared_ptr<Parameter>        m_tau;
+    std::shared_ptr<ConstantFunction> m_yold;
+    std::shared_ptr<ConstantFunction> m_fold;   // f(y_n)
+    Vector<> m_temp;
+
+public:
+    CrankNicolson(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs), m_tau(std::make_shared<Parameter>(0.0)),
+          m_temp(rhs->dimF())
+    {
+        m_yold = std::make_shared<ConstantFunction>(rhs->dimX());
+        m_fold = std::make_shared<ConstantFunction>(rhs->dimF());
+        auto id = std::make_shared<IdentityFunction>(rhs->dimX());
+
+        m_equ = id - m_yold - 0.5 * m_tau * (m_fold + rhs);
+    }
+
+    void doStep(double tau, VectorView<double> y) override
+    {
+        m_rhs->evaluate(y, m_temp);    // compute f(y_n)
+        m_fold->set(m_temp);           // store it
+        m_yold->set(y);
+        m_tau->set(tau);
+        NewtonSolver(m_equ, y);
+    }
+};
\ No newline at end of file
diff --git a/src/.ipynb_checkpoints/ImplicitEuler-checkpoint.hpp b/src/.ipynb_checkpoints/ImplicitEuler-checkpoint.hpp
new file mode 100644
index 000000000..c80973828
--- /dev/null
+++ b/src/.ipynb_checkpoints/ImplicitEuler-checkpoint.hpp
@@ -0,0 +1,27 @@
+#pragma once
+#include "timestepper.hpp"
+#include "function_algebra.hpp"
+#include "newton.hpp"
+
+class ImplicitEuler : public TimeStepper
+{
+    std::shared_ptr<NonlinearFunction> m_equ;
+    std::shared_ptr<Parameter>        m_tau;
+    std::shared_ptr<ConstantFunction> m_yold;
+
+public:
+    ImplicitEuler(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs), m_tau(std::make_shared<Parameter>(0.0))
+    {
+        m_yold = std::make_shared<ConstantFunction>(rhs->dimX());
+        auto ynew = std::make_shared<IdentityFunction>(rhs->dimX());
+        m_equ = ynew - m_yold - m_tau * rhs;          // y - yold - tau*f(y) = 0
+    }
+
+    void doStep(double tau, VectorView<double> y) override
+    {
+        m_yold->set(y);
+        m_tau->set(tau);
+        NewtonSolver(m_equ, y);
+    }
+};
\ No newline at end of file
diff --git a/src/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp b/src/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp
new file mode 100644
index 000000000..7699f2129
--- /dev/null
+++ b/src/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp
@@ -0,0 +1,21 @@
+#pragma once
+#include "timestepper.hpp"
+
+class ImprovedEuler : public TimeStepper
+{
+    Vector<> m_k1, m_k2, m_temp;
+
+public:
+    ImprovedEuler(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs),
+          m_k1(rhs->dimF()), m_k2(rhs->dimF()), m_temp(rhs->dimF())
+    {}
+
+    void doStep(double tau, VectorView<double> y) override
+    {
+        m_rhs->evaluate(y, m_k1);                 // k1 = f(y_n)
+        m_temp = y + tau * m_k1;                  // predictor
+        m_rhs->evaluate(m_temp, m_k2);            // k2 = f(y_n + tau k1)
+        y += tau * (0.5 * m_k1 + 0.5 * m_k2);      // corrector
+    }
+};
\ No newline at end of file
diff --git a/src/.ipynb_checkpoints/Newton-checkpoint.hpp b/src/.ipynb_checkpoints/Newton-checkpoint.hpp
new file mode 100644
index 000000000..6021fd2b0
--- /dev/null
+++ b/src/.ipynb_checkpoints/Newton-checkpoint.hpp
@@ -0,0 +1,52 @@
+#ifndef NEWTON_HPP
+#define NEWTON_HPP
+
+#include <iostream>
+#include <vector>
+#include <cmath>
+#include <stdexcept>
+#include "nonlinfunc.hpp"
+
+class NewtonSolver {
+public:
+    double tol = 1e-8;
+    int maxIter = 50;
+
+    void solve(NonlinearFunction& func, std::vector<double>& x) {
+        size_t n = x.size();
+        std::vector<double> F(n);
+        std::vector<std::vector<double>> J(n, std::vector<double>(n));
+
+        for(int iter=0; iter<maxIter; ++iter) {
+            func.evaluate(x, F);
+            func.evaluateDeriv(x, J);
+
+            // Solve J*dx = -F using simple 2x2 solver
+            std::vector<double> dx = linearSolve(J, F);
+
+            for(size_t i=0; i<n; ++i) x[i] -= dx[i];
+
+            double norm = 0.0;
+            for(double v : dx) norm += v*v;
+            norm = std::sqrt(norm);
+
+            if(norm < tol) {
+                std::cout << "Converged in " << iter+1 << " iterations.\n";
+                return;
+            }
+        }
+        throw std::runtime_error("Newton did not converge");
+    }
+
+private:
+    std::vector<double> linearSolve(const std::vector<std::vector<double>>& J, const std::vector<double>& F) {
+        // Only works for 2x2 systems
+        double a = J[0][0], b = J[0][1];
+        double c = J[1][0], d = J[1][1];
+        double det = a*d - b*c;
+        if(std::abs(det) < 1e-12) throw std::runtime_error("Singular Jacobian");
+        return { (d*F[0]-b*F[1])/det, (-c*F[0]+a*F[1])/det };
+    }
+};
+
+#endif
diff --git a/src/.ipynb_checkpoints/bindings-checkpoint.cpp b/src/.ipynb_checkpoints/bindings-checkpoint.cpp
new file mode 100644
index 000000000..00af57ac4
--- /dev/null
+++ b/src/.ipynb_checkpoints/bindings-checkpoint.cpp
@@ -0,0 +1,41 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include "nonlinfunc.hpp"
+#include "Newton.hpp"
+#include <vector.hpp>
+#include <matrix.hpp>
+
+namespace py = pybind11;
+using namespace ASC_ode;
+using namespace nanoblas;
+
+PYBIND11_MODULE(asc_ode, m) {
+    m.doc() = "ASC ODE solver";
+
+    // Vector
+    py::class_<Vector<double>>(m, "Vector")
+        .def(py::init<size_t>())
+        .def(py::init<std::vector<double>>())
+        .def("__len__", [](const Vector<double>& v) { return v.size(); })
+        .def("__getitem__", [](Vector<double>& v, size_t i) -> double& { return v(i); })
+        .def("__setitem__", [](Vector<double>& v, size_t i, double val) { v(i) = val; })
+        .def("__repr__", [](const Vector<double>& v) {
+            std::stringstream ss; ss << "[";
+            for(size_t i=0; i<v.size(); i++) { ss << v(i); if(i+1<v.size()) ss << ", "; }
+            ss << "]"; return ss.str();
+        });
+
+    // NonlinearFunction base + Python subclass
+    py::class_<NonlinearFunction, PyNonlinearFunction, std::shared_ptr<NonlinearFunction>>(m, "NonlinearFunction", py::dynamic_attr(), py::module_local())
+        .def(py::init<>())
+        .def("dimX", &NonlinearFunction::dimX)
+        .def("dimF", &NonlinearFunction::dimF)
+        .def("evaluate", [](NonlinearFunction& self, Vector<double>& x, Vector<double>& f) { self.evaluate(x,f); })
+        .def("evaluateDeriv", [](NonlinearFunction& self, Vector<double>& x, Matrix<double>& df) { self.evaluateDeriv(x,df); });
+
+    // NewtonSolver
+    m.def("NewtonSolver", [](std::shared_ptr<NonlinearFunction> func, Vector<double>& x,
+                             double tol = 1e-12, int maxit = 50, bool linesearch = true) {
+        return NewtonSolver(func, x, tol, maxit, linesearch);
+    });
+}
diff --git a/src/.ipynb_checkpoints/function_algebra-checkpoint.hpp b/src/.ipynb_checkpoints/function_algebra-checkpoint.hpp
new file mode 100644
index 000000000..387a9858a
--- /dev/null
+++ b/src/.ipynb_checkpoints/function_algebra-checkpoint.hpp
@@ -0,0 +1,9 @@
+#pragma once
+
+// Include the individual linear algebra components
+// Assuming these files are found via your -Isrc path
+#include "vector.hpp"
+#include "matrix.hpp"
+
+// We should also include the core function type used by the steppers
+#include "function_algebra.hpp"
\ No newline at end of file
diff --git a/src/.ipynb_checkpoints/main-checkpoint.cpp b/src/.ipynb_checkpoints/main-checkpoint.cpp
new file mode 100644
index 000000000..3e50ef87f
--- /dev/null
+++ b/src/.ipynb_checkpoints/main-checkpoint.cpp
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <fstream>  // For file output
+#include <vector>
+#include <cmath>    // For math functions like sqrt, fabs, etc.
+
+// Your existing includes
+#include "nonlinfunc.hpp"
+#include "mass_spring_function.hpp"
+#include "newton.hpp"
+
+int main() {
+    // Define the system and initial conditions (this might already be in your code)
+    std::vector<double> x = {1.0, 0.0};  // Example initial conditions
+    double dt = 0.01;  // Time step
+    double t_max = 10.0;  // Max time
+    int steps = static_cast<int>(t_max / dt);
+
+    // Create a file to output data
+    std::ofstream output_file("simulation_data.csv");
+    output_file << "Time, x1, x2\n";  // Header for CSV
+
+    // Run the simulation (just an example loop)
+    for (int step = 0; step < steps; ++step) {
+        // Call the appropriate time-stepping method here (e.g., ExpEuler, ImpEuler)
+        // Example of using a simple explicit Euler method:
+        std::vector<double> f_val = {1.0, 0.0};  // This should be computed by your model
+
+        for (int i = 0; i < x.size(); ++i) {
+            x[i] += dt * f_val[i];  // Update state using Euler method
+        }
+
+        // Save the current time and state to the CSV file
+        double time = step * dt;
+        output_file << time << ", " << x[0] << ", " << x[1] << "\n";
+    }
+
+    output_file.close();  // Close the file after writing
+
+    return 0;
+}
diff --git a/src/.ipynb_checkpoints/mass_spring_function-checkpoint.hpp b/src/.ipynb_checkpoints/mass_spring_function-checkpoint.hpp
new file mode 100644
index 000000000..b5fe525c3
--- /dev/null
+++ b/src/.ipynb_checkpoints/mass_spring_function-checkpoint.hpp
@@ -0,0 +1,39 @@
+#ifndef MASS_SPRING_FUNCTION_HPP
+#define MASS_SPRING_FUNCTION_HPP
+
+#include "nonlinfunc.hpp"
+#include <vector>
+#include <cmath> // For mathematical functions like sin, cos, etc.
+
+class MassSpringFunction : public NonlinearFunction {
+public:
+    MassSpringFunction(double mass, double spring_constant)
+        : m_mass(mass), m_k(spring_constant) {}
+
+    // Evaluate the right-hand side of the ODE system
+    std::vector<double> eval(const std::vector<double>& x) const override {
+        // x[0] = position (x), x[1] = velocity (v)
+        double dx1_dt = x[1];  // dx/dt = v (velocity)
+        double dx2_dt = -m_k / m_mass * x[0];  // dv/dt = -k/m * x (acceleration)
+        
+        return {dx1_dt, dx2_dt};
+    }
+
+    // Evaluate the Jacobian matrix of the system
+    std::vector<std::vector<double>> jacobian(const std::vector<double>& x) const override {
+        // The Jacobian matrix is:
+        // [ 0,  1 ]
+        // [-k/m, 0]
+        
+        return {
+            {0, 1},
+            {-m_k / m_mass, 0}
+        };
+    }
+
+private:
+    double m_mass;  // Mass of the object
+    double m_k;     // Spring constant
+};
+
+#endif // MASS_SPRING_FUNCTION_HPP
diff --git a/src/.ipynb_checkpoints/matrix-checkpoint.hpp b/src/.ipynb_checkpoints/matrix-checkpoint.hpp
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/.ipynb_checkpoints/myfunction-checkpoint.hpp b/src/.ipynb_checkpoints/myfunction-checkpoint.hpp
new file mode 100644
index 000000000..6c971a5b7
--- /dev/null
+++ b/src/.ipynb_checkpoints/myfunction-checkpoint.hpp
@@ -0,0 +1,23 @@
+#ifndef MYFUNCTION_HPP
+#define MYFUNCTION_HPP
+
+#include <vector>
+#include "nonlinfunc.hpp"
+
+class MyFunction : public NonlinearFunction {
+public:
+    double x, y;
+
+    MyFunction(double x0 = 1.0, double y0 = 1.0) : x(x0), y(y0) {}
+
+    // Match the NonlinearFunction interface exactly
+    std::vector<double> eval() const {
+        return { x*x + y*y - 4, x - y };
+    }
+
+    std::vector<std::vector<double>> jacobian() const {
+        return {{2*x, 2*y}, {1, -1}};
+    }
+};
+
+#endif
diff --git a/src/Newton.hpp b/src/.ipynb_checkpoints/newton-checkpoint.hpp
similarity index 99%
rename from src/Newton.hpp
rename to src/.ipynb_checkpoints/newton-checkpoint.hpp
index d346f9f91..57d4ebd05 100644
--- a/src/Newton.hpp
+++ b/src/.ipynb_checkpoints/newton-checkpoint.hpp
@@ -38,4 +38,4 @@ namespace ASC_ode
 
 }
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/.ipynb_checkpoints/nonlinfunc-checkpoint.hpp b/src/.ipynb_checkpoints/nonlinfunc-checkpoint.hpp
new file mode 100644
index 000000000..1becba2bb
--- /dev/null
+++ b/src/.ipynb_checkpoints/nonlinfunc-checkpoint.hpp
@@ -0,0 +1 @@
+404: Not Found
\ No newline at end of file
diff --git a/src/.ipynb_checkpoints/timestepper-checkpoint.cpp b/src/.ipynb_checkpoints/timestepper-checkpoint.cpp
new file mode 100644
index 000000000..3fd6ca339
--- /dev/null
+++ b/src/.ipynb_checkpoints/timestepper-checkpoint.cpp
@@ -0,0 +1,79 @@
+#include "timestepper.hpp"
+#include "newton.hpp"
+
+std::vector<double> ExpEuler(const NonlinearFunc& f,
+                              const std::vector<double>& x0,
+                              double dt) {
+    // Explicit Euler method implementation
+    std::vector<double> x = x0;
+    std::vector<double> fx = f.eval(x);
+    for (size_t i = 0; i < x.size(); ++i) {
+        x[i] += dt * fx[i];
+    }
+    return x;
+}
+
+std::vector<double> ImpEuler(const NonlinearFunc& f,
+                              const std::vector<double>& x0,
+                              double dt) {
+    // Implicit Euler method implementation
+    std::vector<double> x = x0;
+    
+    // Define the system for Newton's method
+    auto g = [&](const std::vector<double>& y) -> std::vector<double> {
+        std::vector<double> fy = f.eval(y);
+        std::vector<double> res(fy.size());
+        for (size_t i = 0; i < fy.size(); ++i) {
+            res[i] = y[i] - x[i] - dt * fy[i];
+        }
+        return res;
+    };
+    
+    // Solve using Newton's method
+    return NewtonSolver(g, x);
+}
+
+std::vector<double> ImprovedEuler(const NonlinearFunc& f,
+                                   const std::vector<double>& x0,
+                                   double dt) {
+    // Improved Euler method implementation
+    std::vector<double> x = x0;
+    std::vector<double> fx = f.eval(x);
+    
+    // Take a step with the explicit Euler method
+    std::vector<double> x_temp = x;
+    for (size_t i = 0; i < x.size(); ++i) {
+        x_temp[i] += dt * fx[i];
+    }
+    
+    // Evaluate at the new point
+    std::vector<double> fx_temp = f.eval(x_temp);
+    
+    // Combine the two steps for the improved Euler method
+    for (size_t i = 0; i < x.size(); ++i) {
+        x[i] += dt * 0.5 * (fx[i] + fx_temp[i]);
+    }
+    
+    return x;
+}
+
+std::vector<double> CrankNicolson(const NonlinearFunc& f,
+                                   const std::vector<double>& x0,
+                                   double dt) {
+    // Crank-Nicolson method implementation (implicit method)
+    std::vector<double> x = x0;
+    
+    // Define the system for Newton's method
+    auto g = [&](const std::vector<double>& y) -> std::vector<double> {
+        std::vector<double> fy = f.eval(y);
+        std::vector<double> fx = f.eval(x);
+        std::vector<double> res(fx.size());
+        for (size_t i = 0; i < fx.size(); ++i) {
+            res[i] = y[i] - x[i] - 0.5 * dt * (fx[i] + fy[i]);
+        }
+        return res;
+    };
+    
+    // Solve using Newton's method
+    return NewtonSolver(g, x);
+}
diff --git a/src/.ipynb_checkpoints/timestepper-checkpoint.hpp b/src/.ipynb_checkpoints/timestepper-checkpoint.hpp
new file mode 100644
index 000000000..9212f156d
--- /dev/null
+++ b/src/.ipynb_checkpoints/timestepper-checkpoint.hpp
@@ -0,0 +1,39 @@
+#ifndef TIMESTEPPER_HPP
+#define TIMESTEPPER_HPP
+
+#include "nonlinfunc.hpp"
+#include <vector>
+
+std::vector<double> ExpEuler(NonlinearFunction& f, std::vector<double>& x, double dt) {
+    std::vector<double> f_val = f.eval(x);
+    for (size_t i = 0; i < x.size(); ++i) {
+        x[i] += dt * f_val[i];  // Update the values using the explicit Euler method
+    }
+    return x;
+}
+
+std::vector<double> ImpEuler(NonlinearFunction& f, std::vector<double>& x, double dt) {
+    std::vector<double> f_val = f.eval(x);
+    for (size_t i = 0; i < x.size(); ++i) {
+        x[i] += dt * f_val[i];  // Update values (simplified, for demonstration)
+    }
+    return x;
+}
+
+std::vector<double> ImprovedEuler(NonlinearFunction& f, std::vector<double>& x, double dt) {
+    std::vector<double> f_val = f.eval(x);
+    for (size_t i = 0; i < x.size(); ++i) {
+        x[i] += dt * f_val[i];  // Final step
+    }
+    return x;
+}
+
+std::vector<double> CrankNicolson(NonlinearFunction& f, std::vector<double>& x, double dt) {
+    std::vector<double> f_val = f.eval(x);
+    for (size_t i = 0; i < x.size(); ++i) {
+        x[i] += dt * f_val[i];  // Update final step
+    }
+    return x;
+}
+
+#endif
diff --git a/src/.ipynb_checkpoints/vector-checkpoint.hpp b/src/.ipynb_checkpoints/vector-checkpoint.hpp
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/autodiff.hpp b/src/autodiff.hpp
deleted file mode 100644
index 40a46e7e5..000000000
--- a/src/autodiff.hpp
+++ /dev/null
@@ -1,111 +0,0 @@
-#ifndef AUTODIFF_HPP
-#define AUTODIFF_HPP
-
-#include <cstddef> 
-#include <ostream> 
-#include <cmath>   
-#include <array>  
-
-
-namespace ASC_ode
-{
-
-  template <size_t N, typename T = double>
-  class Variable 
-  {
-    private:
-      T m_val;
-    public:
-      Variable (T v) : m_val(v) {}
-      T value() const { return m_val; }
-  };
-
-  template <typename T = double>
-  auto derivative (T v, size_t /*index*/) { return T(0); } 
-
-
-  template <size_t N, typename T = double>
-  class AutoDiff
-  {
-  private:
-    T m_val;
-    std::array<T, N> m_deriv;
-  public: 
-    AutoDiff () : m_val(0), m_deriv{} {}
-    AutoDiff (T v) : m_val(v), m_deriv{} 
-    {
-      for (size_t i = 0; i < N; i++)
-        m_deriv[i] = derivative(v, i);
-    }
-    
-    template <size_t I>
-    AutoDiff (Variable<I, T> var) : m_val(var.value()), m_deriv{} 
-    {
-      m_deriv[I] = 1.0;
-    }
-
-    T value() const { return m_val; }
-    std::array<T, N>& deriv() { return m_deriv; }
-    const std::array<T, N>& deriv() const { return m_deriv; }
-  };
-
-
-  template <size_t N, typename T = double>
-  auto derivative (AutoDiff<N, T> v, size_t index) 
-  {
-    return v.deriv()[index];
-  }
-
-
-
-  template <size_t N, typename T>
-  std::ostream & operator<< (std::ostream& os, const AutoDiff<N, T>& ad)
-  {
-    os << "Value: " << ad.value() << ", Deriv: [";
-    for (size_t i = 0; i < N; i++)
-    {
-      os << ad.deriv()[i];
-      if (i < N - 1) os << ", ";
-    }
-    os << "]";
-    return os;
-  }
-
-  template <size_t N, typename T = double>
-  AutoDiff<N, T> operator+ (const AutoDiff<N, T>& a, const AutoDiff<N, T>& b)
-  {
-     AutoDiff<N, T> result(a.value() + b.value());
-     for (size_t i = 0; i < N; i++)
-        result.deriv()[i] = a.deriv()[i] + b.deriv()[i];
-       return result;
-   }
-
-   template <size_t N, typename T = double>
-   auto operator+ (T a, const AutoDiff<N, T>& b) { return AutoDiff<N, T>(a) + b; }
-
-
-   template <size_t N, typename T = double>
-   AutoDiff<N, T> operator* (const AutoDiff<N, T>& a, const AutoDiff<N, T>& b)
-   {
-       AutoDiff<N, T> result(a.value() * b.value());
-       for (size_t i = 0; i < N; i++)
-          result.deriv()[i] = a.deriv()[i] * b.value() + a.value() * b.deriv()[i];
-       return result;
-   }
-
-   using std::sin;
-   using std::cos;
-
-   template <size_t N, typename T = double>
-   AutoDiff<N, T> sin(const AutoDiff<N, T> &a)
-   {
-       AutoDiff<N, T> result(sin(a.value()));
-       for (size_t i = 0; i < N; i++)
-           result.deriv()[i] = cos(a.value()) * a.deriv()[i];
-       return result;
-   }
-
-
-} // namespace ASC_ode
-
-#endif
diff --git a/src/bindings.cpp b/src/bindings.cpp
deleted file mode 100644
index ce903dd04..000000000
--- a/src/bindings.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <pybind11/pybind11.h>
-
-namespace py = pybind11;
-
-PYBIND11_MODULE(asc_ode, m) {
-    m.doc() = "ASC ODE library – winter semester 2025/26";
-    m.attr("__version__") = "0.1.0";
-
-   
-    m.def("hello", []() { return "Hello from ASC ODE!"; });
-}
\ No newline at end of file
diff --git a/src/compare_all b/src/compare_all
new file mode 100644
index 0000000000000000000000000000000000000000..0e677d6dad730231aa545e0ce161eb9496b5e4e5
GIT binary patch
literal 2212134
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%0AI9y?
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%0DX<_+)>`SixlKVfe
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
T{P!OI^-p}~Uww|%SLy!;*Tqt{

literal 0
HcmV?d00001

diff --git a/src/function_algebra.hpp b/src/function_algebra.hpp
new file mode 100644
index 000000000..1becba2bb
--- /dev/null
+++ b/src/function_algebra.hpp
@@ -0,0 +1 @@
+404: Not Found
\ No newline at end of file
diff --git a/src/mass_spring_function.hpp b/src/mass_spring_function.hpp
new file mode 100644
index 000000000..1becba2bb
--- /dev/null
+++ b/src/mass_spring_function.hpp
@@ -0,0 +1 @@
+404: Not Found
\ No newline at end of file
diff --git a/src/matrix.hpp b/src/matrix.hpp
new file mode 100644
index 000000000..1becba2bb
--- /dev/null
+++ b/src/matrix.hpp
@@ -0,0 +1 @@
+404: Not Found
\ No newline at end of file
diff --git a/src/newton.hpp b/src/newton.hpp
new file mode 100644
index 000000000..57d4ebd05
--- /dev/null
+++ b/src/newton.hpp
@@ -0,0 +1,41 @@
+#ifndef Newton_h
+#define Newton_h
+
+#include "nonlinfunc.hpp"
+#include <inverse.hpp>
+#include <lapack_interface.hpp>
+
+namespace ASC_ode
+{  
+  void NewtonSolver (std::shared_ptr<NonlinearFunction> func, VectorView<double> x,
+                     double tol = 1e-10, int maxsteps = 10,
+                     std::function<void(int,double,VectorView<double>)> callback = nullptr)
+  {
+    Vector<double> res(func->dimF());
+    Matrix<double> fprime(func->dimF(), func->dimX());
+
+    for (int i = 0; i < maxsteps; i++)
+      {
+        func->evaluate(x, res);
+        double err= norm(res);
+        if (err < tol) return;
+
+        func->evaluateDeriv(x, fprime);
+
+        calcInverse(fprime);
+        x -= fprime*res;
+
+        // LapackLU LU(fprime);
+        // LU.solve(res);
+        // x -= res;
+ 
+        if (callback)
+          callback(i, err, x);
+      }
+
+    throw std::domain_error("Newton did not converge");
+  }
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/nonlinfunc.hpp b/src/nonlinfunc.hpp
index 76a19957c..1becba2bb 100644
--- a/src/nonlinfunc.hpp
+++ b/src/nonlinfunc.hpp
@@ -1,249 +1 @@
-#ifndef NONLINFUNC_H
-#define NONLINFUNC_H
-
-#include <cstddef>
-#include <memory>
-
-#include <vector.hpp>
-#include <matrix.hpp>
-
-namespace ASC_ode
-{
-  using namespace nanoblas;
-
-  class NonlinearFunction
-  {
-  public:
-    virtual ~NonlinearFunction() = default;
-    virtual size_t dimX() const = 0;
-    virtual size_t dimF() const = 0;
-    virtual void evaluate (VectorView<double> x, VectorView<double> f) const = 0;
-    virtual void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const = 0;
-  };
-
-
-  class IdentityFunction : public NonlinearFunction
-  {
-    size_t m_n;
-  public:
-    IdentityFunction (size_t n) : m_n(n) { } 
-    size_t dimX() const override { return m_n; }
-    size_t dimF() const override { return m_n; }
-    void evaluate (VectorView<double> x, VectorView<double> f) const override
-    {
-      f = x;
-    }
-
-    void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
-    {
-      df = 0.0;
-      df.diag() = 1.0;
-    }
-  };
-
-
-
-  class ConstantFunction : public NonlinearFunction
-  {
-    Vector<> m_val;
-  public:
-    ConstantFunction(size_t n) : m_val(n) { }
-    ConstantFunction(VectorView<double> val) : m_val(val) { }
-    void set(VectorView<double> val) { m_val = val; }
-    VectorView<double> get() const { return m_val; }
-    size_t dimX() const override { return m_val.size(); }
-    size_t dimF() const override { return m_val.size(); }
-    void evaluate (VectorView<double> x, VectorView<double> f) const override
-    {
-      f = m_val;
-    }
-    void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
-    {
-      df = 0.0;
-    }
-  };
-
-  
-  
-  class SumFunction : public NonlinearFunction
-  {
-    std::shared_ptr<NonlinearFunction> m_fa, m_fb;
-    double m_faca, m_facb;
-  public:
-    SumFunction (std::shared_ptr<NonlinearFunction> fa,
-                 std::shared_ptr<NonlinearFunction> fb,
-                 double faca, double facb)
-      : m_fa(fa), m_fb(fb), m_faca(faca), m_facb(facb) { }
-
-    size_t dimX() const override { return m_fa->dimX(); }
-    size_t dimF() const override { return m_fa->dimF(); }
-    void evaluate (VectorView<double> x, VectorView<double> f) const override
-    {
-      m_fa->evaluate(x, f);
-      f *= m_faca;
-      Vector<> tmp(dimF());
-      m_fb->evaluate(x, tmp);
-      f += m_facb*tmp;
-    }
-    void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
-    {
-      m_fa->evaluateDeriv(x, df);
-      df *= m_faca;
-      Matrix<double> tmp(dimF(), dimX());
-      m_fb->evaluateDeriv(x, tmp);
-      df += m_facb*tmp;
-    }
-  };
-
-
-  inline auto operator- (std::shared_ptr<NonlinearFunction> fa, std::shared_ptr<NonlinearFunction> fb)
-  {
-    return std::make_shared<SumFunction>(fa, fb, 1, -1);
-  }
-
-  inline auto operator+ (std::shared_ptr<NonlinearFunction> fa, std::shared_ptr<NonlinearFunction> fb)
-  {
-    return std::make_shared<SumFunction>(fa, fb, 1, 1);
-  }
-
-  class Parameter 
-  {
-    double m_value;
-  public:
-    Parameter(double value) : m_value(value) {}
-    double get() const { return m_value; }
-    void set(double value) { m_value = value; }
-  };
-
-  class ScaleFunction : public NonlinearFunction
-  {
-    std::shared_ptr<NonlinearFunction> m_fa;
-    std::shared_ptr<Parameter> m_fac;
-  public:
-    ScaleFunction (std::shared_ptr<NonlinearFunction> fa,
-                   std::shared_ptr<Parameter> fac)
-      : m_fa(fa), m_fac(fac) { }
-
-    size_t dimX() const override { return m_fa->dimX(); }
-    size_t dimF() const override { return m_fa->dimF(); }
-    void evaluate (VectorView<double> x, VectorView<double> f) const override
-    {
-      m_fa->evaluate(x, f);
-      f *= m_fac->get();
-   }
-
-    void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
-    {
-      m_fa->evaluateDeriv(x, df);
-      df *= m_fac->get();
-    }
-  };
-
-  inline auto operator* (std::shared_ptr<Parameter> parama, 
-                         std::shared_ptr<NonlinearFunction> f)
-  {
-    return std::make_shared<ScaleFunction>(f, parama);
-  }
-
-  inline auto operator* (double a, std::shared_ptr<NonlinearFunction> f)
-  {
-    return std::make_shared<Parameter>(a) * f;
-  } 
-
-
-
-
-  // fa(fb)
-  class ComposeFunction : public NonlinearFunction
-  {
-    std::shared_ptr<NonlinearFunction> m_fa, m_fb;
-  public:
-    ComposeFunction (std::shared_ptr<NonlinearFunction> fa,
-                     std::shared_ptr<NonlinearFunction> fb)
-      : m_fa(fa), m_fb(fb) { }
-
-    size_t dimX() const override { return m_fb->dimX(); }
-    size_t dimF() const override { return m_fa->dimF(); }
-    void evaluate (VectorView<double> x, VectorView<double> f) const override
-    {
-      Vector<> tmp(m_fb->dimF());
-      m_fb->evaluate (x, tmp);
-      m_fa->evaluate (tmp, f);
-    }
-    void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
-    {
-      Vector<> tmp(m_fb->dimF());
-      m_fb->evaluate (x, tmp);
-
-      Matrix<double> jaca(m_fa->dimF(), m_fa->dimX());
-      Matrix<double> jacb(m_fb->dimF(), m_fb->dimX());
-
-      m_fb->evaluateDeriv(x, jacb);
-      m_fa->evaluateDeriv(tmp, jaca);
-
-      df = jaca*jacb;
-    }
-  };
-  
-  
-  inline auto Compose (std::shared_ptr<NonlinearFunction> fa, std::shared_ptr<NonlinearFunction> fb)
-  {
-    return make_shared<ComposeFunction> (fa, fb);
-  }
-  
-  class EmbedFunction : public NonlinearFunction
-  {
-    std::shared_ptr<NonlinearFunction> m_fa;
-    size_t m_firstx, m_dimx, m_firstf, m_dimf;
-    size_t m_nextx, m_nextf;
-  public:
-    EmbedFunction (std::shared_ptr<NonlinearFunction> fa,
-                   size_t firstx, size_t dimx,
-                   size_t firstf, size_t dimf)
-      : m_fa(fa),
-        m_firstx(firstx), m_dimx(dimx), m_firstf(firstf), m_dimf(dimf),
-        m_nextx(m_firstx+m_fa->dimX()), m_nextf(m_firstf+m_fa->dimF())
-    { }
-
-    size_t dimX() const override { return m_dimx; }
-    size_t dimF() const override { return m_dimf; }
-    void evaluate (VectorView<double> x, VectorView<double> f) const override
-    {
-      f = 0.0;
-      m_fa->evaluate(x.range(m_firstx, m_nextx), f.range(m_firstf, m_nextf));
-    }
-    void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
-    {
-      df = 0;
-      m_fa->evaluateDeriv(x.range(m_firstx, m_nextx),
-                        df.rows(m_firstf, m_nextf).cols(m_firstx, m_nextx));
-    }
-  };
-
-  
-  class Projector : public NonlinearFunction
-  {
-    size_t m_size, m_first, m_next;
-  public:
-    Projector (size_t size, 
-               size_t first, size_t next)
-      : m_size(size), m_first(first), m_next(next) { }
-
-    size_t dimX() const override { return m_size; }
-    size_t dimF() const override { return m_size; }
-    void evaluate (VectorView<double> x, VectorView<double> f) const override
-    {
-      f = 0.0;
-      f.range(m_first, m_next) = x.range(m_first, m_next);
-    }
-    void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
-    {
-      df = 0.0;
-      df.diag().range(m_first, m_next) = 1;
-    }
-  };
-
-  
-}
-
-#endif
+404: Not Found
\ No newline at end of file
diff --git a/src/timestepper.hpp b/src/timestepper.hpp
index c7802243b..1becba2bb 100644
--- a/src/timestepper.hpp
+++ b/src/timestepper.hpp
@@ -1,64 +1 @@
-#ifndef TIMERSTEPPER_HPP
-#define TIMERSTEPPER_HPP
-
-#include <functional>
-#include <exception>
-
-#include "Newton.hpp"
-
-
-namespace ASC_ode
-{
-  
-  class TimeStepper
-  { 
-  protected:
-    std::shared_ptr<NonlinearFunction> m_rhs;
-  public:
-    TimeStepper(std::shared_ptr<NonlinearFunction> rhs) : m_rhs(rhs) {}
-    virtual ~TimeStepper() = default;
-    virtual void DoStep(double tau, VectorView<double> y) = 0;
-  };
-
-  class ExplicitEuler : public TimeStepper
-  {
-    Vector<> m_vecf;
-  public:
-    ExplicitEuler(std::shared_ptr<NonlinearFunction> rhs) 
-    : TimeStepper(rhs), m_vecf(rhs->dimF()) {}
-    void DoStep(double tau, VectorView<double> y) override
-    {
-      this->m_rhs->evaluate(y, m_vecf);
-      y += tau * m_vecf;
-    }
-  };
-
-  class ImplicitEuler : public TimeStepper
-  {
-    std::shared_ptr<NonlinearFunction> m_equ;
-    std::shared_ptr<Parameter> m_tau;
-    std::shared_ptr<ConstantFunction> m_yold;
-  public:
-    ImplicitEuler(std::shared_ptr<NonlinearFunction> rhs) 
-    : TimeStepper(rhs), m_tau(std::make_shared<Parameter>(0.0)) 
-    {
-      m_yold = std::make_shared<ConstantFunction>(rhs->dimX());
-      auto ynew = std::make_shared<IdentityFunction>(rhs->dimX());
-      m_equ = ynew - m_yold - m_tau * m_rhs;
-    }
-
-    void DoStep(double tau, VectorView<double> y) override
-    {
-      m_yold->set(y);
-      m_tau->set(tau);
-      NewtonSolver(m_equ, y);
-    }
-  };
-
-
-  
-
-}
-
-
-#endif
+404: Not Found
\ No newline at end of file
diff --git a/src/vector.hpp b/src/vector.hpp
new file mode 100644
index 000000000..1becba2bb
--- /dev/null
+++ b/src/vector.hpp
@@ -0,0 +1 @@
+404: Not Found
\ No newline at end of file

From 1277df03b01a7bec9a5a090312bb0b101a0d7e6d Mon Sep 17 00:00:00 2001
From: Farooq Mian Azan <e12433773@student.tuwien.ac.at>
Date: Mon, 24 Nov 2025 09:25:50 +0000
Subject: [PATCH 10/20] Add the missing folder

---
 .../ExplicitEuler-checkpoint.hpp              |  16 +++
 .../ImprovedEuler-checkpoint.hpp              |  14 ++
 .../mass_spring-checkpoint.hpp                |  29 ++++
 .../plot_mass_spring-checkpoint.py            |  47 +++++++
 .../timestepper-checkpoint.hpp                | 132 ++++++++++++++++++
 include/CrankNicolson.hpp                     |  23 +++
 include/ExplicitEuler.hpp                     |  16 +++
 include/ImplicitEuler.hpp                     |  19 +++
 include/ImprovedEuler.hpp                     |  14 ++
 include/mass_spring.hpp                       |  29 ++++
 include/plot_mass_spring.py                   |  47 +++++++
 include/timestepper.hpp                       | 132 ++++++++++++++++++
 12 files changed, 518 insertions(+)
 create mode 100644 include/.ipynb_checkpoints/ExplicitEuler-checkpoint.hpp
 create mode 100644 include/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp
 create mode 100644 include/.ipynb_checkpoints/mass_spring-checkpoint.hpp
 create mode 100644 include/.ipynb_checkpoints/plot_mass_spring-checkpoint.py
 create mode 100644 include/.ipynb_checkpoints/timestepper-checkpoint.hpp
 create mode 100644 include/CrankNicolson.hpp
 create mode 100644 include/ExplicitEuler.hpp
 create mode 100644 include/ImplicitEuler.hpp
 create mode 100644 include/ImprovedEuler.hpp
 create mode 100644 include/mass_spring.hpp
 create mode 100644 include/plot_mass_spring.py
 create mode 100644 include/timestepper.hpp

diff --git a/include/.ipynb_checkpoints/ExplicitEuler-checkpoint.hpp b/include/.ipynb_checkpoints/ExplicitEuler-checkpoint.hpp
new file mode 100644
index 000000000..326c3a2da
--- /dev/null
+++ b/include/.ipynb_checkpoints/ExplicitEuler-checkpoint.hpp
@@ -0,0 +1,16 @@
+#pragma once
+#include "timestepper.hpp"
+#include <memory>
+
+// This class implements the standard y_new = y + tau * f(y)
+class ExplicitEuler : public TimeStepper {
+public:
+    ExplicitEuler(std::shared_ptr<NonlinearFunction> rhs) 
+        : TimeStepper(rhs) {}
+
+    void doStep(double tau, VectorView<double> y) override {
+        Vector<> k1; 
+        m_rhs->evaluate(y, k1); // Evaluate f(y)
+        y += tau * k1;          // Update y
+    }
+};
\ No newline at end of file
diff --git a/include/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp b/include/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp
new file mode 100644
index 000000000..50e3c2633
--- /dev/null
+++ b/include/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp
@@ -0,0 +1,14 @@
+#pragma once
+#include "timestepper.hpp"
+class ImprovedEuler : public TimeStepper {
+    Vector<> k1, k2, tmp;
+public:
+    ImprovedEuler(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs), k1(rhs->dimF()), k2(rhs->dimF()), tmp(rhs->dimF()) {}
+    void doStep(double tau, VectorView<double> y) override {
+        m_rhs->evaluate(y, k1);
+        tmp = y + tau * k1;
+        m_rhs->evaluate(tmp, k2);
+        y += tau * (0.5 * k1 + 0.5 * k2);
+    }
+};
diff --git a/include/.ipynb_checkpoints/mass_spring-checkpoint.hpp b/include/.ipynb_checkpoints/mass_spring-checkpoint.hpp
new file mode 100644
index 000000000..86607b05d
--- /dev/null
+++ b/include/.ipynb_checkpoints/mass_spring-checkpoint.hpp
@@ -0,0 +1,29 @@
+// include/mass_spring.hpp
+#pragma once
+#include "nonlinear_function.hpp"  // repo's interface
+
+class MassSpring : public NonlinearFunction
+{
+  double m_mass;
+  double m_stiffness;
+
+public:
+  MassSpring (double m, double k)
+    : m_mass(m), m_stiffness(k) {}
+
+  size_t dimX() const override { return 2; }
+  size_t dimF() const override { return 2; }
+
+  void evaluate (VectorView<double> x, VectorView<double> f) const override
+  {
+    f(0) = x(1);
+    f(1) = -m_stiffness/m_mass * x(0);
+  }
+
+  void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
+  {
+    df = 0.0;
+    df(0,1) = 1;
+    df(1,0) = -m_stiffness/m_mass;
+  }
+};
diff --git a/include/.ipynb_checkpoints/plot_mass_spring-checkpoint.py b/include/.ipynb_checkpoints/plot_mass_spring-checkpoint.py
new file mode 100644
index 000000000..36b3a1518
--- /dev/null
+++ b/include/.ipynb_checkpoints/plot_mass_spring-checkpoint.py
@@ -0,0 +1,47 @@
+# python/plot_mass_spring.py
+import csv
+import matplotlib.pyplot as plt
+import numpy as np
+
+def read_csv(filename):
+    t, x, v = [], [], []
+    with open(filename) as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            t.append(float(row['t']))
+            x.append(float(row['x']))
+            v.append(float(row['v']))
+    return np.array(t), np.array(x), np.array(v)
+
+files = [
+    ("mass_explicit.csv", "Explicit Euler"),
+    ("mass_improved.csv", "Improved Euler"),
+    ("mass_crank.csv", "Crank-Nicolson (Picard)"),
+]
+
+plt.figure(figsize=(9,5))
+for fname, label in files:
+    t, x, v = read_csv(fname)
+    plt.plot(t, x, label=label)
+plt.xlabel("t")
+plt.ylabel("position x(t)")
+plt.legend()
+plt.title("Mass-Spring: position vs time")
+plt.grid(True)
+plt.tight_layout()
+plt.savefig("mass_position_compare.png")
+print("Wrote mass_position_compare.png")
+
+# phase plot
+plt.figure(figsize=(6,6))
+for fname, label in files:
+    t, x, v = read_csv(fname)
+    plt.plot(x, v, label=label)
+plt.xlabel("position x")
+plt.ylabel("velocity v")
+plt.legend()
+plt.title("Mass-Spring: phase plot")
+plt.grid(True)
+plt.tight_layout()
+plt.savefig("mass_phase_compare.png")
+print("Wrote mass_phase_compare.png")
diff --git a/include/.ipynb_checkpoints/timestepper-checkpoint.hpp b/include/.ipynb_checkpoints/timestepper-checkpoint.hpp
new file mode 100644
index 000000000..d67a282e3
--- /dev/null
+++ b/include/.ipynb_checkpoints/timestepper-checkpoint.hpp
@@ -0,0 +1,132 @@
+// include/timestepper.hpp
+#pragma once
+#include <memory>
+#include <vector>
+#include <iostream>
+#include <cmath>
+
+// forward declarations from repo's linear algebra
+// Replace these with the repo's real Vector / Matrix types.
+// Here I show pseudo-types to be adapted to the project's actual types.
+#include "nonlinear_function.hpp" // assume this exists in repo (NonlinearFunction)
+
+// The repo uses Vector<> and VectorView<> types; adapt includes if necessary.
+
+class TimeStepper
+{
+protected:
+  std::shared_ptr<NonlinearFunction> m_rhs;
+public:
+  TimeStepper(std::shared_ptr<NonlinearFunction> rhs) : m_rhs(rhs) {}
+  virtual ~TimeStepper() = default;
+  virtual void doStep(double tau, VectorView<double> y) = 0;
+};
+
+/// ExplicitEuler is likely already implemented in the repo; shown for reference
+class ExplicitEuler : public TimeStepper
+{
+  Vector<> m_vecf;
+public:
+  ExplicitEuler(std::shared_ptr<NonlinearFunction> rhs)
+    : TimeStepper(rhs), m_vecf(rhs->dimF()) {}
+
+  void doStep(double tau, VectorView<double> y) override
+  {
+    this->m_rhs->evaluate(y, m_vecf);
+    y += tau * m_vecf;
+  }
+};
+
+/// Improved Euler (Heun / explicit midpoint-like two-stage as defined in exercise)
+/// \tilde y = y_n + tau/2 * f(y_n)
+/// y_{n+1} = y_n + tau * f( \tilde y )
+class ImprovedEuler : public TimeStepper
+{
+  Vector<> m_vecf;     // f(y)
+  Vector<> m_vecft;    // f(tilde y)
+  Vector<> m_ytemp;    // temporary vector for tilde y
+public:
+  ImprovedEuler(std::shared_ptr<NonlinearFunction> rhs)
+    : TimeStepper(rhs),
+      m_vecf(rhs->dimF()),
+      m_vecft(rhs->dimF()),
+      m_ytemp(rhs->dimX()) {}
+
+  void doStep(double tau, VectorView<double> y) override
+  {
+    // evaluate f(y)
+    this->m_rhs->evaluate(y, m_vecf);
+
+    // tilde y = y + tau/2 * f(y)
+    m_ytemp = y;               // copy current y to temp
+    m_ytemp += (tau/2.0) * m_vecf;
+
+    // evaluate f(tilde y)
+    this->m_rhs->evaluate(m_ytemp, m_vecft);
+
+    // y_{n+1} = y_n + tau * f(tilde y)
+    y += tau * m_vecft;
+  }
+};
+
+/// CrankNicolson (semi-implicit): we implement a Picard (fixed-point) iteration:
+/// y^{k+1} = y_old + 0.5*tau*( f(y_old) + f(y^k) )
+/// start from predictor (Improved Euler or Explicit Euler)
+class CrankNicolson : public TimeStepper
+{
+  Vector<> m_fold;     // f(y_old)
+  Vector<> m_fk;       // f(y_k)
+  Vector<> m_yk;       // current iterate y^k
+  int m_max_iter;
+  double m_tol;
+public:
+  CrankNicolson(std::shared_ptr<NonlinearFunction> rhs,
+                int max_iter = 20, double tol = 1e-10)
+    : TimeStepper(rhs),
+      m_fold(rhs->dimF()),
+      m_fk(rhs->dimF()),
+      m_yk(rhs->dimX()),
+      m_max_iter(max_iter),
+      m_tol(tol) {}
+
+  void doStep(double tau, VectorView<double> y) override
+  {
+    // store old
+    Vector<> yold = y; // copy (Vector supports copy)
+
+    // evaluate f(yold)
+    this->m_rhs->evaluate(yold, m_fold);
+
+    // predictor: one ImprovedEuler step -> starting guess
+    // yk = yold + tau * f(yold)  (explicit Euler predictor)
+    m_yk = yold;
+    m_yk += tau * m_fold;
+
+    // Picard iteration (fixed-point)
+    for (int iter = 0; iter < m_max_iter; ++iter)
+    {
+      // evaluate f(y_k)
+      this->m_rhs->evaluate(m_yk, m_fk);
+
+      // compute new iterate
+      Vector<> ynew = yold;
+      ynew += 0.5 * tau * (m_fold + m_fk);
+
+      // check convergence (norm of difference)
+      double diffnorm = 0.0;
+      for (size_t i = 0; i < ynew.size(); ++i)
+      {
+        double d = ynew[i] - m_yk[i];
+        diffnorm += d*d;
+      }
+      diffnorm = std::sqrt(diffnorm);
+
+      m_yk = ynew;
+
+      if (diffnorm < m_tol) break;
+    }
+
+    // copy result back to y (view)
+    y = m_yk;
+  }
+};
diff --git a/include/CrankNicolson.hpp b/include/CrankNicolson.hpp
new file mode 100644
index 000000000..d9ac5c568
--- /dev/null
+++ b/include/CrankNicolson.hpp
@@ -0,0 +1,23 @@
+#pragma once
+#include "timestepper.hpp"
+#include "function_algebra.hpp"
+#include "newton.hpp"
+class CrankNicolson : public TimeStepper {
+    std::shared_ptr<NonlinearFunction> eq;
+    std::shared_ptr<Parameter> tau;
+    std::shared_ptr<ConstantFunction> yold, fold;
+    Vector<> ftmp;
+public:
+    CrankNicolson(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs), tau(std::make_shared<Parameter>(0.0)), ftmp(rhs->dimF()) {
+        yold = std::make_shared<ConstantFunction>(rhs->dimX());
+        fold = std::make_shared<ConstantFunction>(rhs->dimF());
+        auto id = std::make_shared<IdentityFunction>(rhs->dimX());
+        eq = id - yold - 0.5*tau*(fold + rhs);
+    }
+    void doStep(double tau, VectorView<double> y) override {
+        m_rhs->evaluate(y, ftmp); fold->set(ftmp);
+        yold->set(y); tau->set(tau);
+        NewtonSolver(eq, y);
+    }
+};
diff --git a/include/ExplicitEuler.hpp b/include/ExplicitEuler.hpp
new file mode 100644
index 000000000..326c3a2da
--- /dev/null
+++ b/include/ExplicitEuler.hpp
@@ -0,0 +1,16 @@
+#pragma once
+#include "timestepper.hpp"
+#include <memory>
+
+// This class implements the standard y_new = y + tau * f(y)
+class ExplicitEuler : public TimeStepper {
+public:
+    ExplicitEuler(std::shared_ptr<NonlinearFunction> rhs) 
+        : TimeStepper(rhs) {}
+
+    void doStep(double tau, VectorView<double> y) override {
+        Vector<> k1; 
+        m_rhs->evaluate(y, k1); // Evaluate f(y)
+        y += tau * k1;          // Update y
+    }
+};
\ No newline at end of file
diff --git a/include/ImplicitEuler.hpp b/include/ImplicitEuler.hpp
new file mode 100644
index 000000000..2619ba532
--- /dev/null
+++ b/include/ImplicitEuler.hpp
@@ -0,0 +1,19 @@
+#pragma once
+#include "timestepper.hpp"
+#include "function_algebra.hpp"
+#include "newton.hpp"
+class ImplicitEuler : public TimeStepper {
+    std::shared_ptr<NonlinearFunction> eq;
+    std::shared_ptr<Parameter> tau;
+    std::shared_ptr<ConstantFunction> yold;
+public:
+    ImplicitEuler(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs), tau(std::make_shared<Parameter>(0.0)) {
+        yold = std::make_shared<ConstantFunction>(rhs->dimX());
+        auto id = std::make_shared<IdentityFunction>(rhs->dimX());
+        eq = id - yold - tau * rhs;
+    }
+    void doStep(double tau, VectorView<double> y) override {
+        yold->set(y); tau->set(tau); NewtonSolver(eq, y);
+    }
+};
diff --git a/include/ImprovedEuler.hpp b/include/ImprovedEuler.hpp
new file mode 100644
index 000000000..50e3c2633
--- /dev/null
+++ b/include/ImprovedEuler.hpp
@@ -0,0 +1,14 @@
+#pragma once
+#include "timestepper.hpp"
+class ImprovedEuler : public TimeStepper {
+    Vector<> k1, k2, tmp;
+public:
+    ImprovedEuler(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs), k1(rhs->dimF()), k2(rhs->dimF()), tmp(rhs->dimF()) {}
+    void doStep(double tau, VectorView<double> y) override {
+        m_rhs->evaluate(y, k1);
+        tmp = y + tau * k1;
+        m_rhs->evaluate(tmp, k2);
+        y += tau * (0.5 * k1 + 0.5 * k2);
+    }
+};
diff --git a/include/mass_spring.hpp b/include/mass_spring.hpp
new file mode 100644
index 000000000..86607b05d
--- /dev/null
+++ b/include/mass_spring.hpp
@@ -0,0 +1,29 @@
+// include/mass_spring.hpp
+#pragma once
+#include "nonlinear_function.hpp"  // repo's interface
+
+class MassSpring : public NonlinearFunction
+{
+  double m_mass;
+  double m_stiffness;
+
+public:
+  MassSpring (double m, double k)
+    : m_mass(m), m_stiffness(k) {}
+
+  size_t dimX() const override { return 2; }
+  size_t dimF() const override { return 2; }
+
+  void evaluate (VectorView<double> x, VectorView<double> f) const override
+  {
+    f(0) = x(1);
+    f(1) = -m_stiffness/m_mass * x(0);
+  }
+
+  void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
+  {
+    df = 0.0;
+    df(0,1) = 1;
+    df(1,0) = -m_stiffness/m_mass;
+  }
+};
diff --git a/include/plot_mass_spring.py b/include/plot_mass_spring.py
new file mode 100644
index 000000000..36b3a1518
--- /dev/null
+++ b/include/plot_mass_spring.py
@@ -0,0 +1,47 @@
+# python/plot_mass_spring.py
+import csv
+import matplotlib.pyplot as plt
+import numpy as np
+
+def read_csv(filename):
+    t, x, v = [], [], []
+    with open(filename) as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            t.append(float(row['t']))
+            x.append(float(row['x']))
+            v.append(float(row['v']))
+    return np.array(t), np.array(x), np.array(v)
+
+files = [
+    ("mass_explicit.csv", "Explicit Euler"),
+    ("mass_improved.csv", "Improved Euler"),
+    ("mass_crank.csv", "Crank-Nicolson (Picard)"),
+]
+
+plt.figure(figsize=(9,5))
+for fname, label in files:
+    t, x, v = read_csv(fname)
+    plt.plot(t, x, label=label)
+plt.xlabel("t")
+plt.ylabel("position x(t)")
+plt.legend()
+plt.title("Mass-Spring: position vs time")
+plt.grid(True)
+plt.tight_layout()
+plt.savefig("mass_position_compare.png")
+print("Wrote mass_position_compare.png")
+
+# phase plot
+plt.figure(figsize=(6,6))
+for fname, label in files:
+    t, x, v = read_csv(fname)
+    plt.plot(x, v, label=label)
+plt.xlabel("position x")
+plt.ylabel("velocity v")
+plt.legend()
+plt.title("Mass-Spring: phase plot")
+plt.grid(True)
+plt.tight_layout()
+plt.savefig("mass_phase_compare.png")
+print("Wrote mass_phase_compare.png")
diff --git a/include/timestepper.hpp b/include/timestepper.hpp
new file mode 100644
index 000000000..d67a282e3
--- /dev/null
+++ b/include/timestepper.hpp
@@ -0,0 +1,132 @@
+// include/timestepper.hpp
+#pragma once
+#include <memory>
+#include <vector>
+#include <iostream>
+#include <cmath>
+
+// forward declarations from repo's linear algebra
+// Replace these with the repo's real Vector / Matrix types.
+// Here I show pseudo-types to be adapted to the project's actual types.
+#include "nonlinear_function.hpp" // assume this exists in repo (NonlinearFunction)
+
+// The repo uses Vector<> and VectorView<> types; adapt includes if necessary.
+
+class TimeStepper
+{
+protected:
+  std::shared_ptr<NonlinearFunction> m_rhs;
+public:
+  TimeStepper(std::shared_ptr<NonlinearFunction> rhs) : m_rhs(rhs) {}
+  virtual ~TimeStepper() = default;
+  virtual void doStep(double tau, VectorView<double> y) = 0;
+};
+
+/// ExplicitEuler is likely already implemented in the repo; shown for reference
+class ExplicitEuler : public TimeStepper
+{
+  Vector<> m_vecf;
+public:
+  ExplicitEuler(std::shared_ptr<NonlinearFunction> rhs)
+    : TimeStepper(rhs), m_vecf(rhs->dimF()) {}
+
+  void doStep(double tau, VectorView<double> y) override
+  {
+    this->m_rhs->evaluate(y, m_vecf);
+    y += tau * m_vecf;
+  }
+};
+
+/// Improved Euler (Heun / explicit midpoint-like two-stage as defined in exercise)
+/// \tilde y = y_n + tau/2 * f(y_n)
+/// y_{n+1} = y_n + tau * f( \tilde y )
+class ImprovedEuler : public TimeStepper
+{
+  Vector<> m_vecf;     // f(y)
+  Vector<> m_vecft;    // f(tilde y)
+  Vector<> m_ytemp;    // temporary vector for tilde y
+public:
+  ImprovedEuler(std::shared_ptr<NonlinearFunction> rhs)
+    : TimeStepper(rhs),
+      m_vecf(rhs->dimF()),
+      m_vecft(rhs->dimF()),
+      m_ytemp(rhs->dimX()) {}
+
+  void doStep(double tau, VectorView<double> y) override
+  {
+    // evaluate f(y)
+    this->m_rhs->evaluate(y, m_vecf);
+
+    // tilde y = y + tau/2 * f(y)
+    m_ytemp = y;               // copy current y to temp
+    m_ytemp += (tau/2.0) * m_vecf;
+
+    // evaluate f(tilde y)
+    this->m_rhs->evaluate(m_ytemp, m_vecft);
+
+    // y_{n+1} = y_n + tau * f(tilde y)
+    y += tau * m_vecft;
+  }
+};
+
+/// CrankNicolson (semi-implicit): we implement a Picard (fixed-point) iteration:
+/// y^{k+1} = y_old + 0.5*tau*( f(y_old) + f(y^k) )
+/// start from predictor (Improved Euler or Explicit Euler)
+class CrankNicolson : public TimeStepper
+{
+  Vector<> m_fold;     // f(y_old)
+  Vector<> m_fk;       // f(y_k)
+  Vector<> m_yk;       // current iterate y^k
+  int m_max_iter;
+  double m_tol;
+public:
+  CrankNicolson(std::shared_ptr<NonlinearFunction> rhs,
+                int max_iter = 20, double tol = 1e-10)
+    : TimeStepper(rhs),
+      m_fold(rhs->dimF()),
+      m_fk(rhs->dimF()),
+      m_yk(rhs->dimX()),
+      m_max_iter(max_iter),
+      m_tol(tol) {}
+
+  void doStep(double tau, VectorView<double> y) override
+  {
+    // store old
+    Vector<> yold = y; // copy (Vector supports copy)
+
+    // evaluate f(yold)
+    this->m_rhs->evaluate(yold, m_fold);
+
+    // predictor: one ImprovedEuler step -> starting guess
+    // yk = yold + tau * f(yold)  (explicit Euler predictor)
+    m_yk = yold;
+    m_yk += tau * m_fold;
+
+    // Picard iteration (fixed-point)
+    for (int iter = 0; iter < m_max_iter; ++iter)
+    {
+      // evaluate f(y_k)
+      this->m_rhs->evaluate(m_yk, m_fk);
+
+      // compute new iterate
+      Vector<> ynew = yold;
+      ynew += 0.5 * tau * (m_fold + m_fk);
+
+      // check convergence (norm of difference)
+      double diffnorm = 0.0;
+      for (size_t i = 0; i < ynew.size(); ++i)
+      {
+        double d = ynew[i] - m_yk[i];
+        diffnorm += d*d;
+      }
+      diffnorm = std::sqrt(diffnorm);
+
+      m_yk = ynew;
+
+      if (diffnorm < m_tol) break;
+    }
+
+    // copy result back to y (view)
+    y = m_yk;
+  }
+};

From 18d7b0e877aadec624940888c8fbb3a53a28bf8e Mon Sep 17 00:00:00 2001
From: Joachim Schoeberl <joachim.schoeberl@tuwien.ac.at>
Date: Thu, 27 Nov 2025 13:01:37 +0100
Subject: [PATCH 11/20] little polish

---
 mechsystem/CMakeLists.txt    | 6 +-----
 mechsystem/mass_spring.ipynb | 8 ++++++++
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/mechsystem/CMakeLists.txt b/mechsystem/CMakeLists.txt
index 0c0ab842e..8d184b026 100644
--- a/mechsystem/CMakeLists.txt
+++ b/mechsystem/CMakeLists.txt
@@ -1,8 +1,4 @@
 add_executable (test_mass_spring mass_spring.cpp)
-# target_link_libraries (test_mass_spring PUBLIC ngbla)
-
-
-
 
 
 find_package(Python 3.8 COMPONENTS Interpreter Development REQUIRED)
@@ -14,4 +10,4 @@ list(APPEND CMAKE_PREFIX_PATH "${PYBIND11_DIR}")
 find_package(pybind11 CONFIG REQUIRED)
 
 pybind11_add_module(mass_spring bind_mass_spring.cpp)
-# target_link_libraries (mass_spring PUBLIC ngbla)
+
diff --git a/mechsystem/mass_spring.ipynb b/mechsystem/mass_spring.ipynb
index 6291a1517..3f73d877a 100644
--- a/mechsystem/mass_spring.ipynb
+++ b/mechsystem/mass_spring.ipynb
@@ -109,6 +109,14 @@
     "    springs.geometry = LineSegmentsGeometry(positions=springpos)\n",
     "    sleep(0.01)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cb795937",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {

From 6a33c4ba13c391dc544229e6936548555b0de5ce Mon Sep 17 00:00:00 2001
From: Joachim Schoeberl <joachim.schoeberl@tuwien.ac.at>
Date: Thu, 27 Nov 2025 13:42:10 +0100
Subject: [PATCH 12/20] remove include ngs

---
 mechsystem/test_mass_spring.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/mechsystem/test_mass_spring.py b/mechsystem/test_mass_spring.py
index 1704af0b7..c15b67c0a 100644
--- a/mechsystem/test_mass_spring.py
+++ b/mechsystem/test_mass_spring.py
@@ -2,7 +2,6 @@
 sys.path.append('/Users/joachim/texjs/lva/IntroSC/ASC-ODE/build/mechsystem')
 
 from mass_spring import *
-import ngsolve.bla
 
 
 mss = MassSpringSystem3d()

From 17cb2d366a7b3ec284351dbbe4a1660fe4bfdf30 Mon Sep 17 00:00:00 2001
From: Joachim Schoeberl <joachim.schoeberl@tuwien.ac.at>
Date: Thu, 27 Nov 2025 13:48:20 +0100
Subject: [PATCH 13/20] add pypath

---
 mechsystem/mass_spring.ipynb   | 1 +
 mechsystem/test_mass_spring.py | 1 +
 2 files changed, 2 insertions(+)

diff --git a/mechsystem/mass_spring.ipynb b/mechsystem/mass_spring.ipynb
index 3f73d877a..eb9035b13 100644
--- a/mechsystem/mass_spring.ipynb
+++ b/mechsystem/mass_spring.ipynb
@@ -9,6 +9,7 @@
    "source": [
     "import sys\n",
     "sys.path.append('/Users/joachim/texjs/lva/IntroSC/ASC-ODE/build/mechsystem')\n",
+    "sys.path.append('../build/mechsystem')\n",
     "\n",
     "from mass_spring import *\n",
     "\n",
diff --git a/mechsystem/test_mass_spring.py b/mechsystem/test_mass_spring.py
index c15b67c0a..c29720c9d 100644
--- a/mechsystem/test_mass_spring.py
+++ b/mechsystem/test_mass_spring.py
@@ -1,5 +1,6 @@
 import sys
 sys.path.append('/Users/joachim/texjs/lva/IntroSC/ASC-ODE/build/mechsystem')
+sys.path.append('../build/mechsystem')
 
 from mass_spring import *
 

From 5a73c3ee5d1214a79b7c79ade27fd745c719232e Mon Sep 17 00:00:00 2001
From: Farooq Mian Azan <e12433773@student.tuwien.ac.at>
Date: Sat, 29 Nov 2025 11:13:14 +0000
Subject: [PATCH 14/20] Add explicit RK implementation + RK demo and plotting
 scripts for chapter 19

---
 demos/demo_rk.cpp                 | 135 ++++++++++++++++++++++++++++++
 include/plot_autodiff_legendre.py |  14 ++++
 include/plot_rk_results.py        |  21 +++++
 src/explicit_rk.hpp               |  50 +++++++++++
 4 files changed, 220 insertions(+)
 create mode 100644 demos/demo_rk.cpp
 create mode 100644 include/plot_autodiff_legendre.py
 create mode 100644 include/plot_rk_results.py
 create mode 100644 src/explicit_rk.hpp

diff --git a/demos/demo_rk.cpp b/demos/demo_rk.cpp
new file mode 100644
index 000000000..1e52ecc8b
--- /dev/null
+++ b/demos/demo_rk.cpp
@@ -0,0 +1,135 @@
+// demos/demo_rk.cpp
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <cmath>
+#include <functional>
+#include "src/explicit_rk.hpp"
+
+ExplicitRungeKutta make_explicit_euler() {
+    std::vector<std::vector<double>> a = {{0.0}};
+    std::vector<double> b = {1.0};
+    std::vector<double> c = {0.0};
+    return ExplicitRungeKutta(a,b,c);
+}
+ExplicitRungeKutta make_rk2_midpoint() {
+    std::vector<std::vector<double>> a = {{0.0, 0.0},
+                                          {0.5, 0.0}};
+    std::vector<double> b = {0.0, 1.0};
+    std::vector<double> c = {0.0, 0.5};
+    return ExplicitRungeKutta(a,b,c);
+}
+ExplicitRungeKutta make_rk4_classic() {
+    std::vector<std::vector<double>> a = {
+        {0.0,0.0,0.0,0.0},
+        {0.5,0.0,0.0,0.0},
+        {0.0,0.5,0.0,0.0},
+        {0.0,0.0,1.0,0.0}
+    };
+    std::vector<double> b = {1.0/6.0, 1.0/3.0, 1.0/3.0, 1.0/6.0};
+    std::vector<double> c = {0.0, 0.5, 0.5, 1.0};
+    return ExplicitRungeKutta(a,b,c);
+}
+
+void pendulum_rhs(double /*t*/, const std::vector<double>& y, std::vector<double>& out) {
+    const double g = 9.81, L = 1.0;
+    out[0] = y[1];
+    out[1] = -(g/L) * std::sin(y[0]);
+}
+
+int main() {
+    // pendulum compare
+    {
+        auto euler = make_explicit_euler();
+        auto rk2 = make_rk2_midpoint();
+        auto rk4 = make_rk4_classic();
+
+        double tend = 10.0;
+        int steps = 2000;
+        double tau = tend / double(steps);
+
+        std::vector<double> y0 = {0.5, 0.0};
+
+        std::ofstream fe("pendulum_euler.csv");
+        std::ofstream f2("pendulum_rk2.csv");
+        std::ofstream f4("pendulum_rk4.csv");
+        fe << "t,alpha,alpha_dot\n";
+        f2 << "t,alpha,alpha_dot\n";
+        f4 << "t,alpha,alpha_dot\n";
+
+        std::vector<double> ye = y0, y2 = y0, y4 = y0, ytmp(2);
+
+        for (int i=0;i<=steps;++i) {
+            double t = i * tau;
+            fe << t << "," << ye[0] << "," << ye[1] << "\n";
+            f2 << t << "," << y2[0] << "," << y2[1] << "\n";
+            f4 << t << "," << y4[0] << "," << y4[1] << "\n";
+
+            if (i==steps) break;
+
+            euler.step(pendulum_rhs, t, tau, ye, ytmp); ye.swap(ytmp);
+            rk2.step(pendulum_rhs, t, tau, y2, ytmp); y2.swap(ytmp);
+            rk4.step(pendulum_rhs, t, tau, y4, ytmp); y4.swap(ytmp);
+        }
+        fe.close(); f2.close(); f4.close();
+        std::cout << "Wrote pendulum_{euler,rk2,rk4}.csv\n";
+    }
+
+    // linear test for error vs tau
+    {
+        double lambda = -50.0;
+        auto euler = make_explicit_euler();
+        auto rk2 = make_rk2_midpoint();
+        auto rk4 = make_rk4_classic();
+
+        std::vector<double> taus = {0.02, 0.01, 0.005, 0.0025, 0.00125};
+        std::ofstream f("linear_error_vs_tau.csv");
+        f << "tau,err_euler,err_rk2,err_rk4\n";
+
+        double tend = 1.0;
+        for (double tau : taus) {
+            int steps = int(std::ceil(tend / tau));
+            double real_tau = tend / double(steps);
+            auto exact = [&](double t, double y0){ return y0 * std::exp(lambda * t); };
+
+            double y0 = 1.0;
+            std::vector<double> y(1), ytmp(1);
+
+            // Euler
+            y = {y0};
+            for (int i=0;i<steps;++i) {
+                euler.step([&](double t,const std::vector<double>& yy,std::vector<double>& out){
+                    out[0] = lambda * yy[0];
+                }, i*real_tau, real_tau, y, ytmp);
+                y.swap(ytmp);
+            }
+            double err_euler = std::abs(y[0] - exact(tend,y0));
+
+            // RK2
+            y = {y0};
+            for (int i=0;i<steps;++i) {
+                rk2.step([&](double t,const std::vector<double>& yy,std::vector<double>& out){
+                    out[0] = lambda * yy[0];
+                }, i*real_tau, real_tau, y, ytmp);
+                y.swap(ytmp);
+            }
+            double err_rk2 = std::abs(y[0] - exact(tend,y0));
+
+            // RK4
+            y = {y0};
+            for (int i=0;i<steps;++i) {
+                rk4.step([&](double t,const std::vector<double>& yy,std::vector<double>& out){
+                    out[0] = lambda * yy[0];
+                }, i*real_tau, real_tau, y, ytmp);
+                y.swap(ytmp);
+            }
+            double err_rk4 = std::abs(y[0] - exact(tend,y0));
+
+            f << real_tau << "," << err_euler << "," << err_rk2 << "," << err_rk4 << "\n";
+        }
+        f.close();
+        std::cout << "Wrote linear_error_vs_tau.csv\n";
+    }
+
+    return 0;
+}
diff --git a/include/plot_autodiff_legendre.py b/include/plot_autodiff_legendre.py
new file mode 100644
index 000000000..2f0db5a6a
--- /dev/null
+++ b/include/plot_autodiff_legendre.py
@@ -0,0 +1,14 @@
+# include/plot_autodiff_legendre.py
+import numpy as np
+import matplotlib.pyplot as plt
+data = np.genfromtxt("legendre.csv", delimiter=',', names=True)
+x = data['x']
+plt.figure(figsize=(9,6))
+for k in range(6):
+    plt.plot(x, data[f'P{k}'], label=f'P{k}')
+plt.legend(); plt.xlabel('x'); plt.title('P0..P5'); plt.grid(True); plt.savefig('legendre_Ps.png')
+plt.figure(figsize=(9,6))
+for k in range(6):
+    plt.plot(x, data[f'dP{k}'], label=f'dP{k}')
+plt.legend(); plt.xlabel('x'); plt.title('dP0..dP5'); plt.grid(True); plt.savefig('legendre_dPs.png')
+print("Wrote legendre_Ps.png and legendre_dPs.png")
diff --git a/include/plot_rk_results.py b/include/plot_rk_results.py
new file mode 100644
index 000000000..0df494825
--- /dev/null
+++ b/include/plot_rk_results.py
@@ -0,0 +1,21 @@
+# include/plot_rk_results.py
+import numpy as np
+import matplotlib.pyplot as plt
+def read(fname): return np.genfromtxt(fname, delimiter=',', names=True)
+fe = read("pendulum_euler.csv")
+f2 = read("pendulum_rk2.csv")
+f4 = read("pendulum_rk4.csv")
+plt.figure(figsize=(10,5))
+plt.plot(fe['t'], fe['alpha'], label='Euler')
+plt.plot(f2['t'], f2['alpha'], label='RK2')
+plt.plot(f4['t'], f4['alpha'], label='RK4')
+plt.legend(); plt.xlabel('t'); plt.title('Pendulum alpha(t)'); plt.grid(True); plt.savefig('pendulum_alpha_compare.png')
+plt.figure(figsize=(6,6))
+plt.plot(fe['alpha'], fe['alpha_dot'], label='Euler')
+plt.plot(f2['alpha'], f2['alpha_dot'], label='RK2')
+plt.plot(f4['alpha'], f4['alpha_dot'], label='RK4')
+plt.legend(); plt.xlabel('alpha'); plt.ylabel('alpha_dot'); plt.title('Pendulum phase'); plt.grid(True); plt.savefig('pendulum_phase_compare.png')
+print("Wrote pendulum plots")
+# error vs tau
+le = read("linear_error_vs_tau.csv")
+taus = le['tau']; plt.figure(); plt.loglog(taus, le['err_euler'], 'o-', label='Euler'); plt.loglog(taus, le['err_rk2'], 's-', label='RK2'); plt.loglog(taus, le['err_rk4'], '^-', label='RK4'); plt.legend(); plt.xlabel('tau'); plt.ylabel('error'); plt.grid(True); plt.savefig('linear_error_vs_tau.png'); print("Wrote linear_error_vs_tau.png")
diff --git a/src/explicit_rk.hpp b/src/explicit_rk.hpp
new file mode 100644
index 000000000..4ff25ede7
--- /dev/null
+++ b/src/explicit_rk.hpp
@@ -0,0 +1,50 @@
+// src/explicit_rk.hpp
+#pragma once
+#include <vector>
+#include <functional>
+#include <cassert>
+#include <cmath>
+
+// An explicit Runge-Kutta integrator for autonomous ODE y' = f(t,y) or f(y).
+// f: (double t, const std::vector<double>& y, std::vector<double>& out)
+class ExplicitRungeKutta {
+public:
+    ExplicitRungeKutta(const std::vector<std::vector<double>>& a_,
+                       const std::vector<double>& b_,
+                       const std::vector<double>& c_)
+      : a(a_), b(b_), c(c_), s((int)b_.size()) {
+        assert((int)c_.size() == s);
+        assert((int)a.size() == s);
+    }
+
+    void step(const std::function<void(double,const std::vector<double>&,std::vector<double>&)>& f,
+              double t, double tau,
+              const std::vector<double>& y, std::vector<double>& out) const
+    {
+        int n = (int)y.size();
+        out.assign(n, 0.0);
+        std::vector<std::vector<double>> k(s, std::vector<double>(n, 0.0));
+        std::vector<double> ytemp(n,0.0);
+        for (int j=0;j<s;++j) {
+            for (int i=0;i<n;++i) {
+                double sum = 0.0;
+                for (int l=0;l<j;++l) sum += a[j][l] * k[l][i];
+                ytemp[i] = y[i] + tau * sum;
+            }
+            f(t + c[j]*tau, ytemp, k[j]);
+        }
+        for (int i=0;i<n;++i) {
+            double sum = 0.0;
+            for (int j=0;j<s;++j) sum += b[j] * k[j][i];
+            out[i] = y[i] + tau * sum;
+        }
+    }
+
+    int stages() const { return s; }
+
+private:
+    std::vector<std::vector<double>> a;
+    std::vector<double> b;
+    std::vector<double> c;
+    int s;
+};

From 68b66b252e47e9b4634d347ddeb3bf1e0e25365a Mon Sep 17 00:00:00 2001
From: Farooq Mian Azan <e12433773@student.tuwien.ac.at>
Date: Sat, 29 Nov 2025 11:13:14 +0000
Subject: [PATCH 15/20] Add explicit RK implementation + RK demo and plotting
 scripts for chapter 19

---
 demos/demo_rk.cpp                 | 135 ++++++++++++++++++++++++++++++
 include/plot_autodiff_legendre.py |  14 ++++
 include/plot_rk_results.py        |  21 +++++
 src/explicit_rk.hpp               |  50 +++++++++++
 4 files changed, 220 insertions(+)
 create mode 100644 demos/demo_rk.cpp
 create mode 100644 include/plot_autodiff_legendre.py
 create mode 100644 include/plot_rk_results.py
 create mode 100644 src/explicit_rk.hpp

diff --git a/demos/demo_rk.cpp b/demos/demo_rk.cpp
new file mode 100644
index 000000000..1e52ecc8b
--- /dev/null
+++ b/demos/demo_rk.cpp
@@ -0,0 +1,135 @@
+// demos/demo_rk.cpp
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <cmath>
+#include <functional>
+#include "src/explicit_rk.hpp"
+
+ExplicitRungeKutta make_explicit_euler() {
+    std::vector<std::vector<double>> a = {{0.0}};
+    std::vector<double> b = {1.0};
+    std::vector<double> c = {0.0};
+    return ExplicitRungeKutta(a,b,c);
+}
+ExplicitRungeKutta make_rk2_midpoint() {
+    std::vector<std::vector<double>> a = {{0.0, 0.0},
+                                          {0.5, 0.0}};
+    std::vector<double> b = {0.0, 1.0};
+    std::vector<double> c = {0.0, 0.5};
+    return ExplicitRungeKutta(a,b,c);
+}
+ExplicitRungeKutta make_rk4_classic() {
+    std::vector<std::vector<double>> a = {
+        {0.0,0.0,0.0,0.0},
+        {0.5,0.0,0.0,0.0},
+        {0.0,0.5,0.0,0.0},
+        {0.0,0.0,1.0,0.0}
+    };
+    std::vector<double> b = {1.0/6.0, 1.0/3.0, 1.0/3.0, 1.0/6.0};
+    std::vector<double> c = {0.0, 0.5, 0.5, 1.0};
+    return ExplicitRungeKutta(a,b,c);
+}
+
+void pendulum_rhs(double /*t*/, const std::vector<double>& y, std::vector<double>& out) {
+    const double g = 9.81, L = 1.0;
+    out[0] = y[1];
+    out[1] = -(g/L) * std::sin(y[0]);
+}
+
+int main() {
+    // pendulum compare
+    {
+        auto euler = make_explicit_euler();
+        auto rk2 = make_rk2_midpoint();
+        auto rk4 = make_rk4_classic();
+
+        double tend = 10.0;
+        int steps = 2000;
+        double tau = tend / double(steps);
+
+        std::vector<double> y0 = {0.5, 0.0};
+
+        std::ofstream fe("pendulum_euler.csv");
+        std::ofstream f2("pendulum_rk2.csv");
+        std::ofstream f4("pendulum_rk4.csv");
+        fe << "t,alpha,alpha_dot\n";
+        f2 << "t,alpha,alpha_dot\n";
+        f4 << "t,alpha,alpha_dot\n";
+
+        std::vector<double> ye = y0, y2 = y0, y4 = y0, ytmp(2);
+
+        for (int i=0;i<=steps;++i) {
+            double t = i * tau;
+            fe << t << "," << ye[0] << "," << ye[1] << "\n";
+            f2 << t << "," << y2[0] << "," << y2[1] << "\n";
+            f4 << t << "," << y4[0] << "," << y4[1] << "\n";
+
+            if (i==steps) break;
+
+            euler.step(pendulum_rhs, t, tau, ye, ytmp); ye.swap(ytmp);
+            rk2.step(pendulum_rhs, t, tau, y2, ytmp); y2.swap(ytmp);
+            rk4.step(pendulum_rhs, t, tau, y4, ytmp); y4.swap(ytmp);
+        }
+        fe.close(); f2.close(); f4.close();
+        std::cout << "Wrote pendulum_{euler,rk2,rk4}.csv\n";
+    }
+
+    // linear test for error vs tau
+    {
+        double lambda = -50.0;
+        auto euler = make_explicit_euler();
+        auto rk2 = make_rk2_midpoint();
+        auto rk4 = make_rk4_classic();
+
+        std::vector<double> taus = {0.02, 0.01, 0.005, 0.0025, 0.00125};
+        std::ofstream f("linear_error_vs_tau.csv");
+        f << "tau,err_euler,err_rk2,err_rk4\n";
+
+        double tend = 1.0;
+        for (double tau : taus) {
+            int steps = int(std::ceil(tend / tau));
+            double real_tau = tend / double(steps);
+            auto exact = [&](double t, double y0){ return y0 * std::exp(lambda * t); };
+
+            double y0 = 1.0;
+            std::vector<double> y(1), ytmp(1);
+
+            // Euler
+            y = {y0};
+            for (int i=0;i<steps;++i) {
+                euler.step([&](double t,const std::vector<double>& yy,std::vector<double>& out){
+                    out[0] = lambda * yy[0];
+                }, i*real_tau, real_tau, y, ytmp);
+                y.swap(ytmp);
+            }
+            double err_euler = std::abs(y[0] - exact(tend,y0));
+
+            // RK2
+            y = {y0};
+            for (int i=0;i<steps;++i) {
+                rk2.step([&](double t,const std::vector<double>& yy,std::vector<double>& out){
+                    out[0] = lambda * yy[0];
+                }, i*real_tau, real_tau, y, ytmp);
+                y.swap(ytmp);
+            }
+            double err_rk2 = std::abs(y[0] - exact(tend,y0));
+
+            // RK4
+            y = {y0};
+            for (int i=0;i<steps;++i) {
+                rk4.step([&](double t,const std::vector<double>& yy,std::vector<double>& out){
+                    out[0] = lambda * yy[0];
+                }, i*real_tau, real_tau, y, ytmp);
+                y.swap(ytmp);
+            }
+            double err_rk4 = std::abs(y[0] - exact(tend,y0));
+
+            f << real_tau << "," << err_euler << "," << err_rk2 << "," << err_rk4 << "\n";
+        }
+        f.close();
+        std::cout << "Wrote linear_error_vs_tau.csv\n";
+    }
+
+    return 0;
+}
diff --git a/include/plot_autodiff_legendre.py b/include/plot_autodiff_legendre.py
new file mode 100644
index 000000000..2f0db5a6a
--- /dev/null
+++ b/include/plot_autodiff_legendre.py
@@ -0,0 +1,14 @@
+# include/plot_autodiff_legendre.py
+import numpy as np
+import matplotlib.pyplot as plt
+data = np.genfromtxt("legendre.csv", delimiter=',', names=True)
+x = data['x']
+plt.figure(figsize=(9,6))
+for k in range(6):
+    plt.plot(x, data[f'P{k}'], label=f'P{k}')
+plt.legend(); plt.xlabel('x'); plt.title('P0..P5'); plt.grid(True); plt.savefig('legendre_Ps.png')
+plt.figure(figsize=(9,6))
+for k in range(6):
+    plt.plot(x, data[f'dP{k}'], label=f'dP{k}')
+plt.legend(); plt.xlabel('x'); plt.title('dP0..dP5'); plt.grid(True); plt.savefig('legendre_dPs.png')
+print("Wrote legendre_Ps.png and legendre_dPs.png")
diff --git a/include/plot_rk_results.py b/include/plot_rk_results.py
new file mode 100644
index 000000000..0df494825
--- /dev/null
+++ b/include/plot_rk_results.py
@@ -0,0 +1,21 @@
+# include/plot_rk_results.py
+import numpy as np
+import matplotlib.pyplot as plt
+def read(fname): return np.genfromtxt(fname, delimiter=',', names=True)
+fe = read("pendulum_euler.csv")
+f2 = read("pendulum_rk2.csv")
+f4 = read("pendulum_rk4.csv")
+plt.figure(figsize=(10,5))
+plt.plot(fe['t'], fe['alpha'], label='Euler')
+plt.plot(f2['t'], f2['alpha'], label='RK2')
+plt.plot(f4['t'], f4['alpha'], label='RK4')
+plt.legend(); plt.xlabel('t'); plt.title('Pendulum alpha(t)'); plt.grid(True); plt.savefig('pendulum_alpha_compare.png')
+plt.figure(figsize=(6,6))
+plt.plot(fe['alpha'], fe['alpha_dot'], label='Euler')
+plt.plot(f2['alpha'], f2['alpha_dot'], label='RK2')
+plt.plot(f4['alpha'], f4['alpha_dot'], label='RK4')
+plt.legend(); plt.xlabel('alpha'); plt.ylabel('alpha_dot'); plt.title('Pendulum phase'); plt.grid(True); plt.savefig('pendulum_phase_compare.png')
+print("Wrote pendulum plots")
+# error vs tau
+le = read("linear_error_vs_tau.csv")
+taus = le['tau']; plt.figure(); plt.loglog(taus, le['err_euler'], 'o-', label='Euler'); plt.loglog(taus, le['err_rk2'], 's-', label='RK2'); plt.loglog(taus, le['err_rk4'], '^-', label='RK4'); plt.legend(); plt.xlabel('tau'); plt.ylabel('error'); plt.grid(True); plt.savefig('linear_error_vs_tau.png'); print("Wrote linear_error_vs_tau.png")
diff --git a/src/explicit_rk.hpp b/src/explicit_rk.hpp
new file mode 100644
index 000000000..4ff25ede7
--- /dev/null
+++ b/src/explicit_rk.hpp
@@ -0,0 +1,50 @@
+// src/explicit_rk.hpp
+#pragma once
+#include <vector>
+#include <functional>
+#include <cassert>
+#include <cmath>
+
+// An explicit Runge-Kutta integrator for autonomous ODE y' = f(t,y) or f(y).
+// f: (double t, const std::vector<double>& y, std::vector<double>& out)
+class ExplicitRungeKutta {
+public:
+    ExplicitRungeKutta(const std::vector<std::vector<double>>& a_,
+                       const std::vector<double>& b_,
+                       const std::vector<double>& c_)
+      : a(a_), b(b_), c(c_), s((int)b_.size()) {
+        assert((int)c_.size() == s);
+        assert((int)a.size() == s);
+    }
+
+    void step(const std::function<void(double,const std::vector<double>&,std::vector<double>&)>& f,
+              double t, double tau,
+              const std::vector<double>& y, std::vector<double>& out) const
+    {
+        int n = (int)y.size();
+        out.assign(n, 0.0);
+        std::vector<std::vector<double>> k(s, std::vector<double>(n, 0.0));
+        std::vector<double> ytemp(n,0.0);
+        for (int j=0;j<s;++j) {
+            for (int i=0;i<n;++i) {
+                double sum = 0.0;
+                for (int l=0;l<j;++l) sum += a[j][l] * k[l][i];
+                ytemp[i] = y[i] + tau * sum;
+            }
+            f(t + c[j]*tau, ytemp, k[j]);
+        }
+        for (int i=0;i<n;++i) {
+            double sum = 0.0;
+            for (int j=0;j<s;++j) sum += b[j] * k[j][i];
+            out[i] = y[i] + tau * sum;
+        }
+    }
+
+    int stages() const { return s; }
+
+private:
+    std::vector<std::vector<double>> a;
+    std::vector<double> b;
+    std::vector<double> c;
+    int s;
+};

From 7b5f7c8b325e3ba3dee7eb810568c3c6335d996f Mon Sep 17 00:00:00 2001
From: Farooq Mian Azan <e12433773@student.tuwien.ac.at>
Date: Sat, 29 Nov 2025 16:20:34 +0000
Subject: [PATCH 16/20] Final local edits before merging submission-18-19

---
 .ipynb_checkpoints/legendre_Ps-checkpoint.png |  Bin 0 -> 89912 bytes
 .../legendre_dPs-checkpoint.png               |  Bin 0 -> 55962 bytes
 .../linear_error_vs_tau-checkpoint.png        |  Bin 0 -> 25035 bytes
 .../pendulum_phase_compare-checkpoint.png     |  Bin 0 -> 94841 bytes
 .../demo_autodiff-checkpoint.cpp              |   85 +
 .../.ipynb_checkpoints/demo_rk-checkpoint.cpp |  135 +
 .../test_ode-checkpoint.cpp                   |   60 +
 demos/demo_autodiff.cpp                       |  105 +-
 demos/demo_autodiff.cpp.backup                |   91 +
 .../RCNetwork-checkpoint.hpp                  |   53 +
 .../plot_autodiff_legendre-checkpoint.py      |   14 +
 .../.ipynb_checkpoints/plot_rc-checkpoint.py  |   30 +
 .../plot_rk_results-checkpoint.py             |   21 +
 include/RCNetwork.hpp                         |   53 +
 include/plot_rc.py                            |   30 +
 legendre.csv                                  |  202 +
 legendre_Ps.png                               |  Bin 0 -> 90127 bytes
 legendre_dPs.png                              |  Bin 0 -> 56085 bytes
 linear_error_vs_tau.csv                       |    6 +
 linear_error_vs_tau.png                       |  Bin 0 -> 25035 bytes
 local_pybind11/bin/pybind11-config            |    7 +
 .../pybind11-3.0.1.dist-info/INSTALLER        |    1 +
 .../pybind11-3.0.1.dist-info/METADATA         |  252 ++
 .../pybind11-3.0.1.dist-info/RECORD           |   84 +
 .../pybind11-3.0.1.dist-info/REQUESTED        |    0
 local_pybind11/pybind11-3.0.1.dist-info/WHEEL |    5 +
 .../pybind11-3.0.1.dist-info/entry_points.txt |    9 +
 .../pybind11-3.0.1.dist-info/licenses/LICENSE |   29 +
 local_pybind11/pybind11/__init__.py           |   19 +
 local_pybind11/pybind11/__main__.py           |   97 +
 .../__pycache__/__init__.cpython-313.pyc      |  Bin 0 -> 643 bytes
 .../__pycache__/__main__.cpython-313.pyc      |  Bin 0 -> 3941 bytes
 .../__pycache__/_version.cpython-313.pyc      |  Bin 0 -> 779 bytes
 .../__pycache__/commands.cpython-313.pyc      |  Bin 0 -> 2200 bytes
 .../__pycache__/setup_helpers.cpython-313.pyc |  Bin 0 -> 21400 bytes
 local_pybind11/pybind11/_version.py           |   12 +
 local_pybind11/pybind11/commands.py           |   39 +
 .../pybind11/include/pybind11/attr.h          |  722 ++++
 .../pybind11/include/pybind11/buffer_info.h   |  208 +
 .../pybind11/include/pybind11/cast.h          | 2361 +++++++++++
 .../pybind11/include/pybind11/chrono.h        |  228 ++
 .../pybind11/include/pybind11/common.h        |    2 +
 .../pybind11/include/pybind11/complex.h       |   74 +
 .../include/pybind11/conduit/README.txt       |   15 +
 .../pybind11/conduit/pybind11_conduit_v1.h    |  116 +
 .../conduit/pybind11_platform_abi_id.h        |   87 +
 .../pybind11/conduit/wrap_include_python_h.h  |   72 +
 .../include/pybind11/critical_section.h       |   56 +
 .../pybind11/include/pybind11/detail/class.h  |  823 ++++
 .../pybind11/include/pybind11/detail/common.h | 1348 ++++++
 .../include/pybind11/detail/cpp_conduit.h     |   75 +
 .../pybind11/include/pybind11/detail/descr.h  |  226 +
 .../detail/dynamic_raw_ptr_cast_if_possible.h |   39 +
 .../pybind11/detail/exception_translation.h   |   71 +
 .../detail/function_record_pyobject.h         |  191 +
 .../pybind11/include/pybind11/detail/init.h   |  538 +++
 .../include/pybind11/detail/internals.h       |  799 ++++
 .../pybind11/detail/native_enum_data.h        |  209 +
 .../detail/pybind11_namespace_macros.h        |   82 +
 .../pybind11/detail/struct_smart_holder.h     |  378 ++
 .../pybind11/detail/type_caster_base.h        | 1591 +++++++
 .../pybind11/include/pybind11/detail/typeid.h |   65 +
 .../pybind11/detail/using_smart_holder.h      |   22 +
 .../pybind11/detail/value_and_holder.h        |   90 +
 .../pybind11/include/pybind11/eigen.h         |   12 +
 .../pybind11/include/pybind11/eigen/common.h  |    9 +
 .../pybind11/include/pybind11/eigen/matrix.h  |  723 ++++
 .../pybind11/include/pybind11/eigen/tensor.h  |  521 +++
 .../pybind11/include/pybind11/embed.h         |  320 ++
 .../pybind11/include/pybind11/eval.h          |  161 +
 .../pybind11/include/pybind11/functional.h    |  147 +
 .../pybind11/include/pybind11/gil.h           |  199 +
 .../include/pybind11/gil_safe_call_once.h     |  102 +
 .../pybind11/include/pybind11/gil_simple.h    |   37 +
 .../pybind11/include/pybind11/iostream.h      |  265 ++
 .../pybind11/include/pybind11/native_enum.h   |   67 +
 .../pybind11/include/pybind11/numpy.h         | 2312 +++++++++++
 .../pybind11/include/pybind11/operators.h     |  202 +
 .../pybind11/include/pybind11/options.h       |   92 +
 .../pybind11/include/pybind11/pybind11.h      | 3645 +++++++++++++++++
 .../pybind11/include/pybind11/pytypes.h       | 2680 ++++++++++++
 .../pybind11/include/pybind11/stl.h           |  666 +++
 .../include/pybind11/stl/filesystem.h         |  114 +
 .../pybind11/include/pybind11/stl_bind.h      |  858 ++++
 .../include/pybind11/subinterpreter.h         |  299 ++
 .../pybind11/trampoline_self_life_support.h   |   65 +
 .../pybind11/type_caster_pyobject_ptr.h       |   61 +
 .../pybind11/include/pybind11/typing.h        |  298 ++
 .../pybind11/include/pybind11/warnings.h      |   75 +
 local_pybind11/pybind11/py.typed              |    0
 local_pybind11/pybind11/setup_helpers.py      |  500 +++
 local_pybind11/pybind11/share/__init__.py     |    0
 .../__pycache__/__init__.cpython-313.pyc      |  Bin 0 -> 159 bytes
 .../cmake/pybind11/FindPythonLibsNew.cmake    |  320 ++
 .../share/cmake/pybind11/pybind11Common.cmake |  447 ++
 .../share/cmake/pybind11/pybind11Config.cmake |  264 ++
 .../pybind11/pybind11ConfigVersion.cmake      |   32 +
 .../pybind11GuessPythonExtSuffix.cmake        |   86 +
 .../cmake/pybind11/pybind11NewTools.cmake     |  353 ++
 .../cmake/pybind11/pybind11Targets.cmake      |  107 +
 .../share/cmake/pybind11/pybind11Tools.cmake  |  217 +
 .../pybind11/share/pkgconfig/__init__.py      |    0
 .../__pycache__/__init__.cpython-313.pyc      |  Bin 0 -> 169 bytes
 .../pybind11/share/pkgconfig/pybind11.pc      |    7 +
 pendulum_alpha_compare.png                    |  Bin 0 -> 71004 bytes
 pendulum_euler.csv                            | 2002 +++++++++
 pendulum_phase_compare.png                    |  Bin 0 -> 94671 bytes
 pendulum_rk2.csv                              | 2002 +++++++++
 pendulum_rk4.csv                              | 2002 +++++++++
 .../explicit_rk-checkpoint.hpp                |   50 +
 110 files changed, 34212 insertions(+), 34 deletions(-)
 create mode 100644 .ipynb_checkpoints/legendre_Ps-checkpoint.png
 create mode 100644 .ipynb_checkpoints/legendre_dPs-checkpoint.png
 create mode 100644 .ipynb_checkpoints/linear_error_vs_tau-checkpoint.png
 create mode 100644 .ipynb_checkpoints/pendulum_phase_compare-checkpoint.png
 create mode 100644 demos/.ipynb_checkpoints/demo_autodiff-checkpoint.cpp
 create mode 100644 demos/.ipynb_checkpoints/demo_rk-checkpoint.cpp
 create mode 100644 demos/.ipynb_checkpoints/test_ode-checkpoint.cpp
 create mode 100644 demos/demo_autodiff.cpp.backup
 create mode 100644 include/.ipynb_checkpoints/RCNetwork-checkpoint.hpp
 create mode 100644 include/.ipynb_checkpoints/plot_autodiff_legendre-checkpoint.py
 create mode 100644 include/.ipynb_checkpoints/plot_rc-checkpoint.py
 create mode 100644 include/.ipynb_checkpoints/plot_rk_results-checkpoint.py
 create mode 100644 include/RCNetwork.hpp
 create mode 100644 include/plot_rc.py
 create mode 100644 legendre.csv
 create mode 100644 legendre_Ps.png
 create mode 100644 legendre_dPs.png
 create mode 100644 linear_error_vs_tau.csv
 create mode 100644 linear_error_vs_tau.png
 create mode 100755 local_pybind11/bin/pybind11-config
 create mode 100644 local_pybind11/pybind11-3.0.1.dist-info/INSTALLER
 create mode 100644 local_pybind11/pybind11-3.0.1.dist-info/METADATA
 create mode 100644 local_pybind11/pybind11-3.0.1.dist-info/RECORD
 create mode 100644 local_pybind11/pybind11-3.0.1.dist-info/REQUESTED
 create mode 100644 local_pybind11/pybind11-3.0.1.dist-info/WHEEL
 create mode 100644 local_pybind11/pybind11-3.0.1.dist-info/entry_points.txt
 create mode 100644 local_pybind11/pybind11-3.0.1.dist-info/licenses/LICENSE
 create mode 100644 local_pybind11/pybind11/__init__.py
 create mode 100644 local_pybind11/pybind11/__main__.py
 create mode 100644 local_pybind11/pybind11/__pycache__/__init__.cpython-313.pyc
 create mode 100644 local_pybind11/pybind11/__pycache__/__main__.cpython-313.pyc
 create mode 100644 local_pybind11/pybind11/__pycache__/_version.cpython-313.pyc
 create mode 100644 local_pybind11/pybind11/__pycache__/commands.cpython-313.pyc
 create mode 100644 local_pybind11/pybind11/__pycache__/setup_helpers.cpython-313.pyc
 create mode 100644 local_pybind11/pybind11/_version.py
 create mode 100644 local_pybind11/pybind11/commands.py
 create mode 100644 local_pybind11/pybind11/include/pybind11/attr.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/buffer_info.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/cast.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/chrono.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/common.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/complex.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/conduit/README.txt
 create mode 100644 local_pybind11/pybind11/include/pybind11/conduit/pybind11_conduit_v1.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/conduit/pybind11_platform_abi_id.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/conduit/wrap_include_python_h.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/critical_section.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/class.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/common.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/cpp_conduit.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/descr.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/dynamic_raw_ptr_cast_if_possible.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/exception_translation.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/function_record_pyobject.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/init.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/internals.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/native_enum_data.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/pybind11_namespace_macros.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/struct_smart_holder.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/type_caster_base.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/typeid.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/using_smart_holder.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/detail/value_and_holder.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/eigen.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/eigen/common.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/eigen/matrix.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/eigen/tensor.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/embed.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/eval.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/functional.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/gil.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/gil_safe_call_once.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/gil_simple.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/iostream.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/native_enum.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/numpy.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/operators.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/options.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/pybind11.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/pytypes.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/stl.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/stl/filesystem.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/stl_bind.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/subinterpreter.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/trampoline_self_life_support.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/type_caster_pyobject_ptr.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/typing.h
 create mode 100644 local_pybind11/pybind11/include/pybind11/warnings.h
 create mode 100644 local_pybind11/pybind11/py.typed
 create mode 100644 local_pybind11/pybind11/setup_helpers.py
 create mode 100644 local_pybind11/pybind11/share/__init__.py
 create mode 100644 local_pybind11/pybind11/share/__pycache__/__init__.cpython-313.pyc
 create mode 100644 local_pybind11/pybind11/share/cmake/pybind11/FindPythonLibsNew.cmake
 create mode 100644 local_pybind11/pybind11/share/cmake/pybind11/pybind11Common.cmake
 create mode 100644 local_pybind11/pybind11/share/cmake/pybind11/pybind11Config.cmake
 create mode 100644 local_pybind11/pybind11/share/cmake/pybind11/pybind11ConfigVersion.cmake
 create mode 100644 local_pybind11/pybind11/share/cmake/pybind11/pybind11GuessPythonExtSuffix.cmake
 create mode 100644 local_pybind11/pybind11/share/cmake/pybind11/pybind11NewTools.cmake
 create mode 100644 local_pybind11/pybind11/share/cmake/pybind11/pybind11Targets.cmake
 create mode 100644 local_pybind11/pybind11/share/cmake/pybind11/pybind11Tools.cmake
 create mode 100644 local_pybind11/pybind11/share/pkgconfig/__init__.py
 create mode 100644 local_pybind11/pybind11/share/pkgconfig/__pycache__/__init__.cpython-313.pyc
 create mode 100644 local_pybind11/pybind11/share/pkgconfig/pybind11.pc
 create mode 100644 pendulum_alpha_compare.png
 create mode 100644 pendulum_euler.csv
 create mode 100644 pendulum_phase_compare.png
 create mode 100644 pendulum_rk2.csv
 create mode 100644 pendulum_rk4.csv
 create mode 100644 src/.ipynb_checkpoints/explicit_rk-checkpoint.hpp

diff --git a/.ipynb_checkpoints/legendre_Ps-checkpoint.png b/.ipynb_checkpoints/legendre_Ps-checkpoint.png
new file mode 100644
index 0000000000000000000000000000000000000000..26c4d69b5278ad677d198abd9e13a6f32204ae04
GIT binary patch
literal 89912
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

literal 0
HcmV?d00001

diff --git a/.ipynb_checkpoints/legendre_dPs-checkpoint.png b/.ipynb_checkpoints/legendre_dPs-checkpoint.png
new file mode 100644
index 0000000000000000000000000000000000000000..a9fb98aece785bd809e7ebaf55aba0ce9efb0ea0
GIT binary patch
literal 55962
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

literal 0
HcmV?d00001

diff --git a/.ipynb_checkpoints/linear_error_vs_tau-checkpoint.png b/.ipynb_checkpoints/linear_error_vs_tau-checkpoint.png
new file mode 100644
index 0000000000000000000000000000000000000000..c07d0416db6236e4e1fd1d00bcffbcecdceb2e4b
GIT binary patch
literal 25035
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
B3Hbm3

literal 0
HcmV?d00001

diff --git a/.ipynb_checkpoints/pendulum_phase_compare-checkpoint.png b/.ipynb_checkpoints/pendulum_phase_compare-checkpoint.png
new file mode 100644
index 0000000000000000000000000000000000000000..d3e2842d4f8e0b0877c7042c7adb6489a4d45f26
GIT binary patch
literal 94841
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
H+BfBQI%&08

literal 0
HcmV?d00001

diff --git a/demos/.ipynb_checkpoints/demo_autodiff-checkpoint.cpp b/demos/.ipynb_checkpoints/demo_autodiff-checkpoint.cpp
new file mode 100644
index 000000000..260a7b2ef
--- /dev/null
+++ b/demos/.ipynb_checkpoints/demo_autodiff-checkpoint.cpp
@@ -0,0 +1,85 @@
+// demos/demo_autodiff.cpp
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <cmath>
+#include <functional>
+
+// ---------- Legendre polynomials P0..Pn ----------
+template <typename T>
+void LegendrePolynomials(int n, T x, std::vector<T>& P) {
+    if (n < 0) { P.clear(); return; }
+    P.resize(n+1);
+    P[0] = T(1);
+    if (n == 0) return;
+    P[1] = x;
+    for (int k=2;k<=n;++k) {
+        P[k] = ((T(2*k-1)*x*P[k-1]) - T(k-1)*P[k-2]) / T(k);
+    }
+}
+
+// numeric derivative using central difference
+double derivative(std::function<double(double)> f, double x, double h=1e-6) {
+    return (f(x+h) - f(x-h)) / (2*h);
+}
+
+// write Legendre and derivative to CSV
+int main_legendre() {
+    const int nmax = 5;
+    std::ofstream f("legendre.csv");
+    f << "x";
+    for(int k=0;k<=nmax;++k) f << ",P" << k << ",dP" << k;
+    f << "\n";
+
+    const int samples = 201;
+    for (int i=0;i<samples;++i) {
+        double x = -1.0 + 2.0 * double(i)/(samples-1);
+        std::vector<double> P;
+        LegendrePolynomials(nmax, x, P);
+
+        f << x;
+        for(int k=0;k<=nmax;++k) {
+            // numeric derivative
+            auto fk = [k](double xx) { std::vector<double> Pk; LegendrePolynomials(5, xx, Pk); return Pk[k]; };
+            double dPk = derivative(fk, x);
+
+            f << "," << P[k] << "," << dPk;
+        }
+        f << "\n";
+    }
+    f.close();
+    std::cout << "Wrote legendre.csv (P0..P5 and derivatives)\n";
+    return 0;
+}
+
+// ---------- Pendulum test ----------
+int main_pendulum() {
+    const double g = 9.81;
+    const double L = 1.0;
+    double alpha = 0.5;       // rad
+    double alpha_dot = 0.0;   // rad/s
+
+    // numeric evaluation of derivatives
+    auto f0 = [](double alpha, double alpha_dot) { return alpha_dot; };
+    auto f1 = [g,L](double alpha, double alpha_dot) { return - (g/L) * sin(alpha); };
+
+    // Jacobian using central difference
+    double h = 1e-6;
+    double J00 = (f0(alpha+h, alpha_dot) - f0(alpha-h, alpha_dot)) / (2*h);
+    double J01 = (f0(alpha, alpha_dot+h) - f0(alpha, alpha_dot-h)) / (2*h);
+    double J10 = (f1(alpha+h, alpha_dot) - f1(alpha-h, alpha_dot)) / (2*h);
+    double J11 = (f1(alpha, alpha_dot+h) - f1(alpha, alpha_dot-h)) / (2*h);
+
+    std::cout << "Pendulum evaluation at alpha=" << alpha << ", alpha_dot=" << alpha_dot << "\n";
+    std::cout << "f0 = " << f0(alpha, alpha_dot) << ", f1 = " << f1(alpha, alpha_dot) << "\n";
+    std::cout << "Jacobian (df_i / dx_j):\n";
+    std::cout << "[" << J00 << " , " << J01 << "]\n";
+    std::cout << "[" << J10 << " , " << J11 << "]\n";
+    return 0;
+}
+
+int main() {
+    main_legendre();
+    main_pendulum();
+    return 0;
+}
diff --git a/demos/.ipynb_checkpoints/demo_rk-checkpoint.cpp b/demos/.ipynb_checkpoints/demo_rk-checkpoint.cpp
new file mode 100644
index 000000000..1e52ecc8b
--- /dev/null
+++ b/demos/.ipynb_checkpoints/demo_rk-checkpoint.cpp
@@ -0,0 +1,135 @@
+// demos/demo_rk.cpp
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <cmath>
+#include <functional>
+#include "src/explicit_rk.hpp"
+
+ExplicitRungeKutta make_explicit_euler() {
+    std::vector<std::vector<double>> a = {{0.0}};
+    std::vector<double> b = {1.0};
+    std::vector<double> c = {0.0};
+    return ExplicitRungeKutta(a,b,c);
+}
+ExplicitRungeKutta make_rk2_midpoint() {
+    std::vector<std::vector<double>> a = {{0.0, 0.0},
+                                          {0.5, 0.0}};
+    std::vector<double> b = {0.0, 1.0};
+    std::vector<double> c = {0.0, 0.5};
+    return ExplicitRungeKutta(a,b,c);
+}
+ExplicitRungeKutta make_rk4_classic() {
+    std::vector<std::vector<double>> a = {
+        {0.0,0.0,0.0,0.0},
+        {0.5,0.0,0.0,0.0},
+        {0.0,0.5,0.0,0.0},
+        {0.0,0.0,1.0,0.0}
+    };
+    std::vector<double> b = {1.0/6.0, 1.0/3.0, 1.0/3.0, 1.0/6.0};
+    std::vector<double> c = {0.0, 0.5, 0.5, 1.0};
+    return ExplicitRungeKutta(a,b,c);
+}
+
+void pendulum_rhs(double /*t*/, const std::vector<double>& y, std::vector<double>& out) {
+    const double g = 9.81, L = 1.0;
+    out[0] = y[1];
+    out[1] = -(g/L) * std::sin(y[0]);
+}
+
+int main() {
+    // pendulum compare
+    {
+        auto euler = make_explicit_euler();
+        auto rk2 = make_rk2_midpoint();
+        auto rk4 = make_rk4_classic();
+
+        double tend = 10.0;
+        int steps = 2000;
+        double tau = tend / double(steps);
+
+        std::vector<double> y0 = {0.5, 0.0};
+
+        std::ofstream fe("pendulum_euler.csv");
+        std::ofstream f2("pendulum_rk2.csv");
+        std::ofstream f4("pendulum_rk4.csv");
+        fe << "t,alpha,alpha_dot\n";
+        f2 << "t,alpha,alpha_dot\n";
+        f4 << "t,alpha,alpha_dot\n";
+
+        std::vector<double> ye = y0, y2 = y0, y4 = y0, ytmp(2);
+
+        for (int i=0;i<=steps;++i) {
+            double t = i * tau;
+            fe << t << "," << ye[0] << "," << ye[1] << "\n";
+            f2 << t << "," << y2[0] << "," << y2[1] << "\n";
+            f4 << t << "," << y4[0] << "," << y4[1] << "\n";
+
+            if (i==steps) break;
+
+            euler.step(pendulum_rhs, t, tau, ye, ytmp); ye.swap(ytmp);
+            rk2.step(pendulum_rhs, t, tau, y2, ytmp); y2.swap(ytmp);
+            rk4.step(pendulum_rhs, t, tau, y4, ytmp); y4.swap(ytmp);
+        }
+        fe.close(); f2.close(); f4.close();
+        std::cout << "Wrote pendulum_{euler,rk2,rk4}.csv\n";
+    }
+
+    // linear test for error vs tau
+    {
+        double lambda = -50.0;
+        auto euler = make_explicit_euler();
+        auto rk2 = make_rk2_midpoint();
+        auto rk4 = make_rk4_classic();
+
+        std::vector<double> taus = {0.02, 0.01, 0.005, 0.0025, 0.00125};
+        std::ofstream f("linear_error_vs_tau.csv");
+        f << "tau,err_euler,err_rk2,err_rk4\n";
+
+        double tend = 1.0;
+        for (double tau : taus) {
+            int steps = int(std::ceil(tend / tau));
+            double real_tau = tend / double(steps);
+            auto exact = [&](double t, double y0){ return y0 * std::exp(lambda * t); };
+
+            double y0 = 1.0;
+            std::vector<double> y(1), ytmp(1);
+
+            // Euler
+            y = {y0};
+            for (int i=0;i<steps;++i) {
+                euler.step([&](double t,const std::vector<double>& yy,std::vector<double>& out){
+                    out[0] = lambda * yy[0];
+                }, i*real_tau, real_tau, y, ytmp);
+                y.swap(ytmp);
+            }
+            double err_euler = std::abs(y[0] - exact(tend,y0));
+
+            // RK2
+            y = {y0};
+            for (int i=0;i<steps;++i) {
+                rk2.step([&](double t,const std::vector<double>& yy,std::vector<double>& out){
+                    out[0] = lambda * yy[0];
+                }, i*real_tau, real_tau, y, ytmp);
+                y.swap(ytmp);
+            }
+            double err_rk2 = std::abs(y[0] - exact(tend,y0));
+
+            // RK4
+            y = {y0};
+            for (int i=0;i<steps;++i) {
+                rk4.step([&](double t,const std::vector<double>& yy,std::vector<double>& out){
+                    out[0] = lambda * yy[0];
+                }, i*real_tau, real_tau, y, ytmp);
+                y.swap(ytmp);
+            }
+            double err_rk4 = std::abs(y[0] - exact(tend,y0));
+
+            f << real_tau << "," << err_euler << "," << err_rk2 << "," << err_rk4 << "\n";
+        }
+        f.close();
+        std::cout << "Wrote linear_error_vs_tau.csv\n";
+    }
+
+    return 0;
+}
diff --git a/demos/.ipynb_checkpoints/test_ode-checkpoint.cpp b/demos/.ipynb_checkpoints/test_ode-checkpoint.cpp
new file mode 100644
index 000000000..97f635e40
--- /dev/null
+++ b/demos/.ipynb_checkpoints/test_ode-checkpoint.cpp
@@ -0,0 +1,60 @@
+#include <iostream>
+#include <fstream> 
+
+#include <nonlinfunc.hpp>
+#include <timestepper.hpp>
+
+using namespace ASC_ode;
+
+
+class MassSpring : public NonlinearFunction
+{
+private:
+  double mass;
+  double stiffness;
+
+public:
+  MassSpring(double m, double k) : mass(m), stiffness(k) {}
+
+  size_t dimX() const override { return 2; }
+  size_t dimF() const override { return 2; }
+  
+  void evaluate (VectorView<double> x, VectorView<double> f) const override
+  {
+    f(0) = x(1);
+    f(1) = -stiffness/mass*x(0);
+  }
+  
+  void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
+  {
+    df = 0.0;
+    df(0,1) = 1;
+    df(1,0) = -stiffness/mass;
+  }
+};
+
+
+int main()
+{
+  double tend = 4*M_PI;
+  int steps = 100;
+  double tau = tend/steps;
+
+  Vector<> y = { 1, 0 };  // initializer list
+  auto rhs = std::make_shared<MassSpring>(1.0, 1.0);
+  
+  ExplicitEuler stepper(rhs);
+  // ImplicitEuler stepper(rhs);
+
+  std::ofstream outfile ("output_test_ode.txt");
+  std::cout << 0.0 << "  " << y(0) << " " << y(1) << std::endl;
+  outfile << 0.0 << "  " << y(0) << " " << y(1) << std::endl;
+
+  for (int i = 0; i < steps; i++)
+  {
+     stepper.DoStep(tau, y);
+
+     std::cout << (i+1) * tau << "  " << y(0) << " " << y(1) << std::endl;
+     outfile << (i+1) * tau << "  " << y(0) << " " << y(1) << std::endl;
+  }
+}
diff --git a/demos/demo_autodiff.cpp b/demos/demo_autodiff.cpp
index d72b0e4ae..260a7b2ef 100644
--- a/demos/demo_autodiff.cpp
+++ b/demos/demo_autodiff.cpp
@@ -1,48 +1,85 @@
+// demos/demo_autodiff.cpp
 #include <iostream>
-#include <autodiff.hpp>
-
-
-using namespace ASC_ode;
-
+#include <fstream>
+#include <vector>
+#include <cmath>
+#include <functional>
 
+// ---------- Legendre polynomials P0..Pn ----------
 template <typename T>
-T func1 (T x, T y)
-{
-  return x * sin(y);
-  // return 1e6 + y;
+void LegendrePolynomials(int n, T x, std::vector<T>& P) {
+    if (n < 0) { P.clear(); return; }
+    P.resize(n+1);
+    P[0] = T(1);
+    if (n == 0) return;
+    P[1] = x;
+    for (int k=2;k<=n;++k) {
+        P[k] = ((T(2*k-1)*x*P[k-1]) - T(k-1)*P[k-2]) / T(k);
+    }
 }
 
+// numeric derivative using central difference
+double derivative(std::function<double(double)> f, double x, double h=1e-6) {
+    return (f(x+h) - f(x-h)) / (2*h);
+}
 
+// write Legendre and derivative to CSV
+int main_legendre() {
+    const int nmax = 5;
+    std::ofstream f("legendre.csv");
+    f << "x";
+    for(int k=0;k<=nmax;++k) f << ",P" << k << ",dP" << k;
+    f << "\n";
 
-int main()
-{
-  double x = 1, y = 2;
-  AutoDiff<2> adx = Variable<0>(x);
-  AutoDiff<2> ady = Variable<1>(y);
+    const int samples = 201;
+    for (int i=0;i<samples;++i) {
+        double x = -1.0 + 2.0 * double(i)/(samples-1);
+        std::vector<double> P;
+        LegendrePolynomials(nmax, x, P);
 
-  std::cout << "adx = " << adx << std::endl;
-  std::cout << "ady = " << ady << std::endl;
+        f << x;
+        for(int k=0;k<=nmax;++k) {
+            // numeric derivative
+            auto fk = [k](double xx) { std::vector<double> Pk; LegendrePolynomials(5, xx, Pk); return Pk[k]; };
+            double dPk = derivative(fk, x);
 
-  AutoDiff<2> prod = adx * ady;
-  std::cout << "prod = " << prod << std::endl;
+            f << "," << P[k] << "," << dPk;
+        }
+        f << "\n";
+    }
+    f.close();
+    std::cout << "Wrote legendre.csv (P0..P5 and derivatives)\n";
+    return 0;
+}
 
-  std::cout << "func1(adx, ady) = " << func1(adx, ady) << std::endl;
+// ---------- Pendulum test ----------
+int main_pendulum() {
+    const double g = 9.81;
+    const double L = 1.0;
+    double alpha = 0.5;       // rad
+    double alpha_dot = 0.0;   // rad/s
 
-  double eps = 1e-8;
-  std::cout << "numdiff df/dx = " << (func1(x + eps, y) - func1(x-eps, y)) / (2*eps) << std::endl;
-  std::cout << "numdiff df/dy = " << (func1(x, y + eps) - func1(x, y-eps)) / (2*eps) << std::endl;
+    // numeric evaluation of derivatives
+    auto f0 = [](double alpha, double alpha_dot) { return alpha_dot; };
+    auto f1 = [g,L](double alpha, double alpha_dot) { return - (g/L) * sin(alpha); };
 
+    // Jacobian using central difference
+    double h = 1e-6;
+    double J00 = (f0(alpha+h, alpha_dot) - f0(alpha-h, alpha_dot)) / (2*h);
+    double J01 = (f0(alpha, alpha_dot+h) - f0(alpha, alpha_dot-h)) / (2*h);
+    double J10 = (f1(alpha+h, alpha_dot) - f1(alpha-h, alpha_dot)) / (2*h);
+    double J11 = (f1(alpha, alpha_dot+h) - f1(alpha, alpha_dot-h)) / (2*h);
 
-  {
-    // we can do second derivatives:
-    AutoDiff<1, AutoDiff<1>> addx{Variable<0>(2)};
-    std::cout << "addx = " << addx << std::endl;
-    // func = x*x
-    // func' = 2*x
-    // func'' = 2
-    std::cout << "addx*addx = " << addx * addx << std::endl;
+    std::cout << "Pendulum evaluation at alpha=" << alpha << ", alpha_dot=" << alpha_dot << "\n";
+    std::cout << "f0 = " << f0(alpha, alpha_dot) << ", f1 = " << f1(alpha, alpha_dot) << "\n";
+    std::cout << "Jacobian (df_i / dx_j):\n";
+    std::cout << "[" << J00 << " , " << J01 << "]\n";
+    std::cout << "[" << J10 << " , " << J11 << "]\n";
+    return 0;
+}
 
-    // std::cout << "sin(addx) = " << sin(addx) << std::endl;
-  }
-  return 0;
-}
\ No newline at end of file
+int main() {
+    main_legendre();
+    main_pendulum();
+    return 0;
+}
diff --git a/demos/demo_autodiff.cpp.backup b/demos/demo_autodiff.cpp.backup
new file mode 100644
index 000000000..2f2dcd067
--- /dev/null
+++ b/demos/demo_autodiff.cpp.backup
@@ -0,0 +1,91 @@
+// demos/demo_autodiff.cpp
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <cmath>
+#include "src/autodiff.hpp"
+
+using AD = AutoDiff<1,double>; // single-variable AD for Legendre
+
+// compute Legendre polynomials P0..Pn at x (templated on T)
+template <typename T>
+void LegendrePolynomials(int n, T x, std::vector<T>& P) {
+    if (n < 0) { P.clear(); return; }
+    P.resize(n+1);
+    P[0] = T(1);
+    if (n == 0) return;
+    P[1] = x;
+    for (int k=2;k<=n;++k) {
+        P[k] = ((T(2*k-1)*x*P[k-1]) - T(k-1)*P[k-2]) / T(k);
+    }
+}
+
+// write Legendre and derivative using AD to CSV
+int main_legendre() {
+    const int nmax = 5;
+    std::ofstream f("legendre.csv");
+    f << "x";
+    for(int k=0;k<=nmax;++k) f << ",P" << k << ",dP" << k;
+    f << "\n";
+
+    // sample points in [-1,1]
+    const int samples = 201;
+    for (int i=0;i<samples;++i) {
+        double x = -1.0 + 2.0 * double(i)/(samples-1);
+        // AD variable: index 0
+        AD x_ad = AD::template variable<0>(x);
+        std::vector<AD> Pad;
+        LegendrePolynomials<AD>(nmax, x_ad, Pad);
+
+        f << x;
+        for(int k=0;k<=nmax;++k) {
+            double Pv = Pad[k].value();
+            double dPv = Pad[k].deriv()[0];
+            f << "," << Pv << "," << dPv;
+        }
+        f << "\n";
+    }
+    f.close();
+    std::cout << "Wrote legendre.csv (P0..P5 and derivatives)\n";
+    return 0;
+}
+
+// ---------- Pendulum AD test (chapter 18.5) ----------
+int main_pendulum() {
+    using AD2 = AutoDiff<2,double>;
+    const double g = 9.81;
+    const double L = 1.0;
+
+    // pick a sample point for (alpha, alpha_dot)
+    double alpha = 0.5; // rad
+    double alpha_dot = 0.0;
+
+    AD2 x0 = AD2::template variable<0>(alpha);
+    AD2 x1 = AD2::template variable<1>(alpha_dot);
+
+    // evaluate f using templated T_evaluate-like code
+    AD2 f0 = x1;
+    AD2 f1 = - (g/L) * sin(x0);
+
+    std::cout << "Pendulum AD evaluation at alpha=" << alpha << ", alpha_dot=" << alpha_dot << "\n";
+    std::cout << "f0 (val, derivs): " << f0 << "\n";
+    std::cout << "f1 (val, derivs): " << f1 << "\n";
+
+    // combine into Jacobian 2x2 printed
+    double J00 = f0.deriv()[0];
+    double J01 = f0.deriv()[1];
+    double J10 = f1.deriv()[0];
+    double J11 = f1.deriv()[1];
+
+    std::cout << "Jacobian (df_i / dx_j):\n";
+    std::cout << "[" << J00 << " , " << J01 << "]\n";
+    std::cout << "[" << J10 << " , " << J11 << "]\n";
+    return 0;
+}
+
+int main(int argc, char** argv) {
+    (void)argc; (void)argv;
+    main_legendre();
+    main_pendulum();
+    return 0;
+}
diff --git a/include/.ipynb_checkpoints/RCNetwork-checkpoint.hpp b/include/.ipynb_checkpoints/RCNetwork-checkpoint.hpp
new file mode 100644
index 000000000..affb10a03
--- /dev/null
+++ b/include/.ipynb_checkpoints/RCNetwork-checkpoint.hpp
@@ -0,0 +1,53 @@
+// include/RCNetwork.hpp
+#pragma once
+#include "nonlinfunc.hpp"   // repo's NonlinearFunction interface
+#include <cmath>
+
+enum class VoltageType { ZERO=0, CONST=1, SIN=2 };
+
+class RCNetwork : public NonlinearFunction
+{
+private:
+  double R;
+  double C;
+  double V0;
+  double omega;
+  VoltageType vtype;
+
+public:
+  RCNetwork(double R_, double C_, VoltageType vt = VoltageType::CONST,
+            double V0_ = 1.0, double omega_ = 0.0)
+    : R(R_), C(C_), V0(V0_), omega(omega_), vtype(vt) {}
+
+  size_t dimX() const override { return 2; }
+  size_t dimF() const override { return 2; }
+
+  void evaluate (VectorView<double> x, VectorView<double> f) const override
+  {
+    double v = x(0);
+    double theta = x(1);
+
+    double Vt = 0.0;
+    if (vtype == VoltageType::ZERO) Vt = 0.0;
+    else if (vtype == VoltageType::CONST) Vt = V0;
+    else Vt = V0 * std::sin(theta);
+
+    // dv/dt
+    f(0) = (1.0/(R*C)) * (Vt - v);
+
+    // dtheta/dt
+    f(1) = omega;
+  }
+
+  void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
+  {
+    df = 0.0;
+    df(0,0) = -1.0/(R*C);
+    if (vtype == VoltageType::SIN)
+      df(0,1) = (1.0/(R*C)) * V0 * std::cos(x(1));
+    else
+      df(0,1) = 0.0;
+    df(1,0) = 0.0;
+    df(1,1) = 0.0;
+  }
+};
diff --git a/include/.ipynb_checkpoints/plot_autodiff_legendre-checkpoint.py b/include/.ipynb_checkpoints/plot_autodiff_legendre-checkpoint.py
new file mode 100644
index 000000000..2f0db5a6a
--- /dev/null
+++ b/include/.ipynb_checkpoints/plot_autodiff_legendre-checkpoint.py
@@ -0,0 +1,14 @@
+# include/plot_autodiff_legendre.py
+import numpy as np
+import matplotlib.pyplot as plt
+data = np.genfromtxt("legendre.csv", delimiter=',', names=True)
+x = data['x']
+plt.figure(figsize=(9,6))
+for k in range(6):
+    plt.plot(x, data[f'P{k}'], label=f'P{k}')
+plt.legend(); plt.xlabel('x'); plt.title('P0..P5'); plt.grid(True); plt.savefig('legendre_Ps.png')
+plt.figure(figsize=(9,6))
+for k in range(6):
+    plt.plot(x, data[f'dP{k}'], label=f'dP{k}')
+plt.legend(); plt.xlabel('x'); plt.title('dP0..dP5'); plt.grid(True); plt.savefig('legendre_dPs.png')
+print("Wrote legendre_Ps.png and legendre_dPs.png")
diff --git a/include/.ipynb_checkpoints/plot_rc-checkpoint.py b/include/.ipynb_checkpoints/plot_rc-checkpoint.py
new file mode 100644
index 000000000..13d0b7e75
--- /dev/null
+++ b/include/.ipynb_checkpoints/plot_rc-checkpoint.py
@@ -0,0 +1,30 @@
+# include/plot_rc.py
+import csv
+import numpy as np
+import matplotlib.pyplot as plt
+
+def read_csv(fname):
+    t, v, th = [], [], []
+    with open(fname) as f:
+        r = csv.DictReader(f)
+        for row in r:
+            t.append(float(row['t']))
+            v.append(float(row['v']))
+            th.append(float(row['theta']))
+    return np.array(t), np.array(v), np.array(th)
+
+files = [("rc_explicit.csv","Explicit Euler"),
+         ("rc_improved.csv","Improved Euler"),
+         ("rc_crank.csv","Crank-Nicolson")]
+
+plt.figure(figsize=(9,5))
+for fname,label in files:
+    t,v,th = read_csv(fname)
+    plt.plot(t, v, label=label)
+plt.xlabel("t")
+plt.ylabel("capacitor voltage v(t)")
+plt.legend()
+plt.grid(True)
+plt.tight_layout()
+plt.savefig("rc_v_compare.png")
+print("Wrote rc_v_compare.png")
diff --git a/include/.ipynb_checkpoints/plot_rk_results-checkpoint.py b/include/.ipynb_checkpoints/plot_rk_results-checkpoint.py
new file mode 100644
index 000000000..0df494825
--- /dev/null
+++ b/include/.ipynb_checkpoints/plot_rk_results-checkpoint.py
@@ -0,0 +1,21 @@
+# include/plot_rk_results.py
+import numpy as np
+import matplotlib.pyplot as plt
+def read(fname): return np.genfromtxt(fname, delimiter=',', names=True)
+fe = read("pendulum_euler.csv")
+f2 = read("pendulum_rk2.csv")
+f4 = read("pendulum_rk4.csv")
+plt.figure(figsize=(10,5))
+plt.plot(fe['t'], fe['alpha'], label='Euler')
+plt.plot(f2['t'], f2['alpha'], label='RK2')
+plt.plot(f4['t'], f4['alpha'], label='RK4')
+plt.legend(); plt.xlabel('t'); plt.title('Pendulum alpha(t)'); plt.grid(True); plt.savefig('pendulum_alpha_compare.png')
+plt.figure(figsize=(6,6))
+plt.plot(fe['alpha'], fe['alpha_dot'], label='Euler')
+plt.plot(f2['alpha'], f2['alpha_dot'], label='RK2')
+plt.plot(f4['alpha'], f4['alpha_dot'], label='RK4')
+plt.legend(); plt.xlabel('alpha'); plt.ylabel('alpha_dot'); plt.title('Pendulum phase'); plt.grid(True); plt.savefig('pendulum_phase_compare.png')
+print("Wrote pendulum plots")
+# error vs tau
+le = read("linear_error_vs_tau.csv")
+taus = le['tau']; plt.figure(); plt.loglog(taus, le['err_euler'], 'o-', label='Euler'); plt.loglog(taus, le['err_rk2'], 's-', label='RK2'); plt.loglog(taus, le['err_rk4'], '^-', label='RK4'); plt.legend(); plt.xlabel('tau'); plt.ylabel('error'); plt.grid(True); plt.savefig('linear_error_vs_tau.png'); print("Wrote linear_error_vs_tau.png")
diff --git a/include/RCNetwork.hpp b/include/RCNetwork.hpp
new file mode 100644
index 000000000..affb10a03
--- /dev/null
+++ b/include/RCNetwork.hpp
@@ -0,0 +1,53 @@
+// include/RCNetwork.hpp
+#pragma once
+#include "nonlinfunc.hpp"   // repo's NonlinearFunction interface
+#include <cmath>
+
+enum class VoltageType { ZERO=0, CONST=1, SIN=2 };
+
+class RCNetwork : public NonlinearFunction
+{
+private:
+  double R;
+  double C;
+  double V0;
+  double omega;
+  VoltageType vtype;
+
+public:
+  RCNetwork(double R_, double C_, VoltageType vt = VoltageType::CONST,
+            double V0_ = 1.0, double omega_ = 0.0)
+    : R(R_), C(C_), V0(V0_), omega(omega_), vtype(vt) {}
+
+  size_t dimX() const override { return 2; }
+  size_t dimF() const override { return 2; }
+
+  void evaluate (VectorView<double> x, VectorView<double> f) const override
+  {
+    double v = x(0);
+    double theta = x(1);
+
+    double Vt = 0.0;
+    if (vtype == VoltageType::ZERO) Vt = 0.0;
+    else if (vtype == VoltageType::CONST) Vt = V0;
+    else Vt = V0 * std::sin(theta);
+
+    // dv/dt
+    f(0) = (1.0/(R*C)) * (Vt - v);
+
+    // dtheta/dt
+    f(1) = omega;
+  }
+
+  void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
+  {
+    df = 0.0;
+    df(0,0) = -1.0/(R*C);
+    if (vtype == VoltageType::SIN)
+      df(0,1) = (1.0/(R*C)) * V0 * std::cos(x(1));
+    else
+      df(0,1) = 0.0;
+    df(1,0) = 0.0;
+    df(1,1) = 0.0;
+  }
+};
diff --git a/include/plot_rc.py b/include/plot_rc.py
new file mode 100644
index 000000000..13d0b7e75
--- /dev/null
+++ b/include/plot_rc.py
@@ -0,0 +1,30 @@
+# include/plot_rc.py
+import csv
+import numpy as np
+import matplotlib.pyplot as plt
+
+def read_csv(fname):
+    t, v, th = [], [], []
+    with open(fname) as f:
+        r = csv.DictReader(f)
+        for row in r:
+            t.append(float(row['t']))
+            v.append(float(row['v']))
+            th.append(float(row['theta']))
+    return np.array(t), np.array(v), np.array(th)
+
+files = [("rc_explicit.csv","Explicit Euler"),
+         ("rc_improved.csv","Improved Euler"),
+         ("rc_crank.csv","Crank-Nicolson")]
+
+plt.figure(figsize=(9,5))
+for fname,label in files:
+    t,v,th = read_csv(fname)
+    plt.plot(t, v, label=label)
+plt.xlabel("t")
+plt.ylabel("capacitor voltage v(t)")
+plt.legend()
+plt.grid(True)
+plt.tight_layout()
+plt.savefig("rc_v_compare.png")
+print("Wrote rc_v_compare.png")
diff --git a/legendre.csv b/legendre.csv
new file mode 100644
index 000000000..f5d25602d
--- /dev/null
+++ b/legendre.csv
@@ -0,0 +1,202 @@
+x,P0,dP0,P1,dP1,P2,dP2,P3,dP3,P4,dP4,P5,dP5
+-1,1,0,-1,1,1,-3,-1,6,1,-10,-1,15
+-0.99,1,0,-0.99,1,0.97015,-2.97,-0.940747,5.85075,0.902233,-9.55523,-0.85518,13.9708
+-0.98,1,0,-0.98,1,0.9406,-2.94,-0.88298,5.703,0.808861,-9.12086,-0.720446,12.9827
+-0.97,1,0,-0.97,1,0.91135,-2.91,-0.826682,5.55675,0.719781,-8.69678,-0.595392,12.0348
+-0.96,1,0,-0.96,1,0.8824,-2.88,-0.77184,5.412,0.634891,-8.28288,-0.47962,11.126
+-0.95,1,0,-0.95,1,0.85375,-2.85,-0.718437,5.26875,0.55409,-7.87906,-0.372744,10.2556
+-0.94,1,0,-0.94,1,0.8254,-2.82,-0.66646,5.127,0.477277,-7.48522,-0.274384,9.42249
+-0.93,1,0,-0.93,1,0.79735,-2.79,-0.615892,4.98675,0.404353,-7.10125,-0.184172,8.62592
+-0.92,1,0,-0.92,1,0.7696,-2.76,-0.56672,4.848,0.335219,-6.72704,-0.101747,7.86497
+-0.91,1,0,-0.91,1,0.74215,-2.73,-0.518928,4.71075,0.26978,-6.36249,-0.0267569,7.13877
+-0.9,1,0,-0.9,1,0.715,-2.7,-0.4725,4.575,0.207937,-6.0075,0.0411413,6.44644
+-0.89,1,0,-0.89,1,0.68815,-2.67,-0.427423,4.44075,0.149598,-5.66196,0.102282,5.78713
+-0.88,1,0,-0.88,1,0.6616,-2.64,-0.38368,4.308,0.0946672,-5.32576,0.156991,5.16
+-0.87,1,0,-0.87,1,0.63535,-2.61,-0.341257,4.17675,0.043052,-4.9988,0.205586,4.56422
+-0.86,1,0,-0.86,1,0.6094,-2.58,-0.30014,4.047,-0.0053393,-4.68098,0.248377,3.99895
+-0.85,1,0,-0.85,1,0.58375,-2.55,-0.260313,3.91875,-0.0505977,-4.37219,0.285664,3.46337
+-0.84,1,0,-0.84,1,0.5584,-2.52,-0.22176,3.792,-0.0928128,-4.07232,0.317741,2.95668
+-0.83,1,0,-0.83,1,0.53335,-2.49,-0.184467,3.66675,-0.132073,-3.78127,0.344892,2.47809
+-0.82,1,0,-0.82,1,0.5086,-2.46,-0.14842,3.543,-0.168467,-3.49894,0.367394,2.02679
+-0.81,1,0,-0.81,1,0.48415,-2.43,-0.113603,3.42075,-0.202081,-3.22522,0.385516,1.60202
+-0.8,1,0,-0.8,1,0.46,-2.4,-0.08,3.3,-0.233,-2.96,0.39952,1.203
+-0.79,1,0,-0.79,1,0.43615,-2.37,-0.0475975,3.18075,-0.261309,-2.70318,0.409659,0.828969
+-0.78,1,0,-0.78,1,0.4126,-2.34,-0.01638,3.063,-0.287091,-2.45466,0.41618,0.479178
+-0.77,1,0,-0.77,1,0.38935,-2.31,0.0136675,2.94675,-0.310429,-2.21433,0.419321,0.152885
+-0.76,1,0,-0.76,1,0.3664,-2.28,0.04256,2.832,-0.331405,-1.98208,0.419314,-0.150643
+-0.75,1,0,-0.75,1,0.34375,-2.25,0.0703125,2.71875,-0.350098,-1.75781,0.416382,-0.432129
+-0.74,1,0,-0.74,1,0.3214,-2.22,0.09694,2.607,-0.366587,-1.54142,0.410742,-0.692286
+-0.73,1,0,-0.73,1,0.29935,-2.19,0.122457,2.49675,-0.380952,-1.3328,0.402605,-0.931818
+-0.72,1,0,-0.72,1,0.2776,-2.16,0.14688,2.388,-0.393269,-1.13184,0.392172,-1.15142
+-0.71,1,0,-0.71,1,0.25615,-2.13,0.170223,2.28075,-0.403614,-0.938443,0.379641,-1.35178
+-0.7,1,0,-0.7,1,0.235,-2.1,0.1925,2.175,-0.412062,-0.7525,0.365199,-1.53356
+-0.69,1,0,-0.69,1,0.21415,-2.07,0.213728,2.07075,-0.418688,-0.573907,0.349029,-1.69745
+-0.68,1,0,-0.68,1,0.1936,-2.04,0.23392,1.968,-0.423565,-0.40256,0.331307,-1.84408
+-0.67,1,0,-0.67,1,0.17335,-2.01,0.253093,1.86675,-0.426763,-0.238353,0.312203,-1.97412
+-0.66,1,0,-0.66,1,0.1534,-1.98,0.27126,1.767,-0.428355,-0.08118,0.291878,-2.0882
+-0.65,1,0,-0.65,1,0.13375,-1.95,0.288437,1.66875,-0.42841,0.0690625,0.27049,-2.18694
+-0.64,1,0,-0.64,1,0.1144,-1.92,0.30464,1.572,-0.426997,0.21248,0.248188,-2.27097
+-0.63,1,0,-0.63,1,0.09535,-1.89,0.319882,1.47675,-0.424183,0.349177,0.225117,-2.3409
+-0.62,1,0,-0.62,1,0.0766,-1.86,0.33418,1.383,-0.420035,0.47926,0.201415,-2.39732
+-0.61,1,0,-0.61,1,0.05815,-1.83,0.347547,1.29075,-0.414619,0.602832,0.177214,-2.44083
+-0.6,1,0,-0.6,1,0.04,-1.8,0.36,1.2,-0.408,0.72,0.15264,-2.472
+-0.59,1,0,-0.59,1,0.02215,-1.77,0.371552,1.11075,-0.40024,0.830867,0.127813,-2.49141
+-0.58,1,0,-0.58,1,0.0046,-1.74,0.38222,1.023,-0.391403,0.93554,0.102849,-2.49963
+-0.57,1,0,-0.57,1,-0.01265,-1.71,0.392017,0.93675,-0.38155,1.03412,0.0778563,-2.4972
+-0.56,1,0,-0.56,1,-0.0296,-1.68,0.40096,0.852,-0.370741,1.12672,0.0529387,-2.48467
+-0.55,1,0,-0.55,1,-0.04625,-1.65,0.409062,0.76875,-0.359035,1.21344,0.0281948,-2.46257
+-0.54,1,0,-0.54,1,-0.0626,-1.62,0.41634,0.687,-0.346491,1.29438,0.00371754,-2.43142
+-0.53,1,0,-0.53,1,-0.07865,-1.59,0.422808,0.60675,-0.333166,1.36965,-0.0204052,-2.39175
+-0.52,1,0,-0.52,1,-0.0944,-1.56,0.42848,0.528,-0.319117,1.43936,-0.0440907,-2.34405
+-0.51,1,0,-0.51,1,-0.10985,-1.53,0.433372,0.45075,-0.304397,1.50361,-0.0672611,-2.28883
+-0.5,1,0,-0.5,1,-0.125,-1.5,0.4375,0.375,-0.289062,1.5625,-0.0898438,-2.22656
+-0.49,1,0,-0.49,1,-0.13985,-1.47,0.440878,0.30075,-0.273165,1.61614,-0.111771,-2.15773
+-0.48,1,0,-0.48,1,-0.1544,-1.44,0.44352,0.228,-0.256757,1.66464,-0.132978,-2.08281
+-0.47,1,0,-0.47,1,-0.16865,-1.41,0.445442,0.15675,-0.239889,1.7081,-0.153408,-2.00225
+-0.46,1,0,-0.46,1,-0.1826,-1.38,0.44666,0.087,-0.222611,1.74662,-0.173006,-1.9165
+-0.45,1,0,-0.45,1,-0.19625,-1.35,0.447188,0.01875,-0.204973,1.78031,-0.191722,-1.826
+-0.44,1,0,-0.44,1,-0.2096,-1.32,0.44704,-0.048,-0.187021,1.80928,-0.209512,-1.73119
+-0.43,1,0,-0.43,1,-0.22265,-1.29,0.446233,-0.11325,-0.168802,1.83363,-0.226333,-1.63247
+-0.42,1,0,-0.42,1,-0.2354,-1.26,0.44478,-0.177,-0.150363,1.85346,-0.242149,-1.53027
+-0.41,1,0,-0.41,1,-0.24785,-1.23,0.442697,-0.23925,-0.131748,1.86888,-0.256928,-1.42498
+-0.4,1,0,-0.4,1,-0.26,-1.2,0.44,-0.3,-0.113,1.88,-0.27064,-1.317
+-0.39,1,0,-0.39,1,-0.27185,-1.17,0.436702,-0.35925,-0.094162,1.88692,-0.28326,-1.20671
+-0.38,1,0,-0.38,1,-0.2834,-1.14,0.43282,-0.417,-0.0752753,1.88974,-0.294768,-1.09448
+-0.37,1,0,-0.37,1,-0.29465,-1.11,0.428368,-0.47325,-0.0563805,1.88857,-0.305145,-0.980674
+-0.36,1,0,-0.36,1,-0.3056,-1.08,0.42336,-0.528,-0.0375168,1.88352,-0.314377,-0.865651
+-0.35,1,0,-0.35,1,-0.31625,-1.05,0.417812,-0.58125,-0.0187227,1.87469,-0.322455,-0.749754
+-0.34,1,0,-0.34,1,-0.3266,-1.02,0.41174,-0.633,-3.53e-05,1.86218,-0.32937,-0.633318
+-0.33,1,0,-0.33,1,-0.33665,-0.99,0.405157,-0.68325,0.018509,1.8461,-0.33512,-0.516669
+-0.32,1,0,-0.32,1,-0.3464,-0.96,0.39808,-0.732,0.0368752,1.82656,-0.339704,-0.400123
+-0.31,1,0,-0.31,1,-0.35585,-0.93,0.390523,-0.77925,0.055029,1.80366,-0.343124,-0.283989
+-0.3,1,0,-0.3,1,-0.365,-0.9,0.3825,-0.825,0.0729375,1.7775,-0.345386,-0.168562
+-0.29,1,0,-0.29,1,-0.37385,-0.87,0.374028,-0.86925,0.0905685,1.74819,-0.346499,-0.0541331
+-0.28,1,0,-0.28,1,-0.3824,-0.84,0.36512,-0.912,0.107891,1.71584,-0.346473,0.0590208
+-0.27,1,0,-0.27,1,-0.39065,-0.81,0.355793,-0.95325,0.124876,1.68055,-0.345324,0.17063
+-0.26,1,0,-0.26,1,-0.3986,-0.78,0.34606,-0.993,0.141493,1.64242,-0.343067,0.280434
+-0.25,1,0,-0.25,1,-0.40625,-0.75,0.335938,-1.03125,0.157715,1.60156,-0.339722,0.388184
+-0.24,1,0,-0.24,1,-0.4136,-0.72,0.32544,-1.068,0.173515,1.55808,-0.335311,0.493637
+-0.23,1,0,-0.23,1,-0.42065,-0.69,0.314582,-1.10325,0.188868,1.51208,-0.329857,0.596562
+-0.22,1,0,-0.22,1,-0.4274,-0.66,0.30338,-1.137,0.203749,1.46366,-0.323388,0.696738
+-0.21,1,0,-0.21,1,-0.43385,-0.63,0.291847,-1.16925,0.218134,1.41293,-0.315932,0.793952
+-0.2,1,0,-0.2,1,-0.44,-0.6,0.28,-1.2,0.232,1.36,-0.30752,0.888
+-0.19,1,0,-0.19,1,-0.44585,-0.57,0.267852,-1.22925,0.245327,1.30497,-0.298184,0.978689
+-0.18,1,0,-0.18,1,-0.4514,-0.54,0.25542,-1.257,0.258093,1.24794,-0.287958,1.06583
+-0.17,1,0,-0.17,1,-0.45665,-0.51,0.242718,-1.28325,0.270279,1.18902,-0.276879,1.14926
+-0.16,1,0,-0.16,1,-0.4616,-0.48,0.22976,-1.308,0.281867,1.12832,-0.264986,1.2288
+-0.15,1,0,-0.15,1,-0.46625,-0.45,0.216563,-1.33125,0.29284,1.06594,-0.252317,1.30431
+-0.14,1,0,-0.14,1,-0.4706,-0.42,0.20314,-1.353,0.303181,1.00198,-0.238914,1.37563
+-0.13,1,0,-0.13,1,-0.47465,-0.39,0.189508,-1.37325,0.312875,0.936553,-0.224819,1.44262
+-0.12,1,0,-0.12,1,-0.4784,-0.36,0.17568,-1.392,0.321907,0.86976,-0.210076,1.50516
+-0.11,1,0,-0.11,1,-0.48185,-0.33,0.161672,-1.40925,0.330266,0.801707,-0.194731,1.56314
+-0.1,1,0,-0.1,1,-0.485,-0.3,0.1475,-1.425,0.337938,0.7325,-0.178829,1.61644
+-0.09,1,0,-0.09,1,-0.48785,-0.27,0.133177,-1.43925,0.344912,0.662243,-0.162418,1.66496
+-0.08,1,0,-0.08,1,-0.4904,-0.24,0.11872,-1.452,0.351179,0.59104,-0.145546,1.70861
+-0.07,1,0,-0.07,1,-0.49265,-0.21,0.104142,-1.46325,0.35673,0.518998,-0.128262,1.74732
+-0.06,1,0,-0.06,1,-0.4946,-0.18,0.08946,-1.473,0.361557,0.44622,-0.110616,1.78101
+-0.05,1,0,-0.05,1,-0.49625,-0.15,0.0746875,-1.48125,0.365652,0.372813,-0.0926587,1.80962
+-0.04,1,0,-0.04,1,-0.4976,-0.12,0.05984,-1.488,0.369011,0.29888,-0.0744408,1.8331
+-0.03,1,0,-0.03,1,-0.49865,-0.09,0.0449325,-1.49325,0.371629,0.224527,-0.0560139,1.85141
+-0.02,1,0,-0.02,1,-0.4994,-0.06,0.02998,-1.497,0.373501,0.14986,-0.03743,1.86451
+-0.01,1,0,-0.01,1,-0.49985,-0.03,0.0149975,-1.49925,0.374625,0.0749825,-0.0187413,1.87238
+0,1,0,0,1,-0.5,0,-0,-1.5,0.375,0,0,1.875
+0.01,1,0,0.01,1,-0.49985,0.03,-0.0149975,-1.49925,0.374625,-0.0749825,0.0187413,1.87238
+0.02,1,0,0.02,1,-0.4994,0.06,-0.02998,-1.497,0.373501,-0.14986,0.03743,1.86451
+0.03,1,0,0.03,1,-0.49865,0.09,-0.0449325,-1.49325,0.371629,-0.224527,0.0560139,1.85141
+0.04,1,0,0.04,1,-0.4976,0.12,-0.05984,-1.488,0.369011,-0.29888,0.0744408,1.8331
+0.05,1,0,0.05,1,-0.49625,0.15,-0.0746875,-1.48125,0.365652,-0.372813,0.0926587,1.80962
+0.06,1,0,0.06,1,-0.4946,0.18,-0.08946,-1.473,0.361557,-0.44622,0.110616,1.78101
+0.07,1,0,0.07,1,-0.49265,0.21,-0.104143,-1.46325,0.35673,-0.518998,0.128262,1.74732
+0.08,1,0,0.08,1,-0.4904,0.24,-0.11872,-1.452,0.351179,-0.59104,0.145546,1.70861
+0.09,1,0,0.09,1,-0.48785,0.27,-0.133178,-1.43925,0.344912,-0.662243,0.162418,1.66496
+0.1,1,0,0.1,1,-0.485,0.3,-0.1475,-1.425,0.337937,-0.7325,0.178829,1.61644
+0.11,1,0,0.11,1,-0.48185,0.33,-0.161673,-1.40925,0.330266,-0.801707,0.194731,1.56314
+0.12,1,0,0.12,1,-0.4784,0.36,-0.17568,-1.392,0.321907,-0.86976,0.210076,1.50516
+0.13,1,0,0.13,1,-0.47465,0.39,-0.189507,-1.37325,0.312875,-0.936552,0.224819,1.44262
+0.14,1,0,0.14,1,-0.4706,0.42,-0.20314,-1.353,0.303181,-1.00198,0.238914,1.37563
+0.15,1,0,0.15,1,-0.46625,0.45,-0.216562,-1.33125,0.29284,-1.06594,0.252317,1.30431
+0.16,1,0,0.16,1,-0.4616,0.48,-0.22976,-1.308,0.281867,-1.12832,0.264986,1.2288
+0.17,1,0,0.17,1,-0.45665,0.51,-0.242717,-1.28325,0.270279,-1.18902,0.276879,1.14926
+0.18,1,0,0.18,1,-0.4514,0.54,-0.25542,-1.257,0.258093,-1.24794,0.287958,1.06583
+0.19,1,0,0.19,1,-0.44585,0.57,-0.267852,-1.22925,0.245327,-1.30497,0.298184,0.978689
+0.2,1,0,0.2,1,-0.44,0.6,-0.28,-1.2,0.232,-1.36,0.30752,0.888
+0.21,1,0,0.21,1,-0.43385,0.63,-0.291847,-1.16925,0.218134,-1.41293,0.315932,0.793952
+0.22,1,0,0.22,1,-0.4274,0.66,-0.30338,-1.137,0.203749,-1.46366,0.323388,0.696738
+0.23,1,0,0.23,1,-0.42065,0.69,-0.314582,-1.10325,0.188868,-1.51208,0.329857,0.596562
+0.24,1,0,0.24,1,-0.4136,0.72,-0.32544,-1.068,0.173515,-1.55808,0.335311,0.493637
+0.25,1,0,0.25,1,-0.40625,0.75,-0.335938,-1.03125,0.157715,-1.60156,0.339722,0.388184
+0.26,1,0,0.26,1,-0.3986,0.78,-0.34606,-0.993,0.141493,-1.64242,0.343067,0.280434
+0.27,1,0,0.27,1,-0.39065,0.81,-0.355793,-0.95325,0.124876,-1.68055,0.345324,0.17063
+0.28,1,0,0.28,1,-0.3824,0.84,-0.36512,-0.912,0.107891,-1.71584,0.346473,0.0590208
+0.29,1,0,0.29,1,-0.37385,0.87,-0.374028,-0.86925,0.0905685,-1.74819,0.346499,-0.0541331
+0.3,1,0,0.3,1,-0.365,0.9,-0.3825,-0.825,0.0729375,-1.7775,0.345386,-0.168562
+0.31,1,0,0.31,1,-0.35585,0.93,-0.390523,-0.77925,0.055029,-1.80366,0.343124,-0.283989
+0.32,1,0,0.32,1,-0.3464,0.96,-0.39808,-0.732,0.0368752,-1.82656,0.339704,-0.400123
+0.33,1,0,0.33,1,-0.33665,0.99,-0.405158,-0.68325,0.018509,-1.8461,0.33512,-0.516669
+0.34,1,0,0.34,1,-0.3266,1.02,-0.41174,-0.633,-3.53e-05,-1.86218,0.32937,-0.633318
+0.35,1,0,0.35,1,-0.31625,1.05,-0.417813,-0.58125,-0.0187227,-1.87469,0.322455,-0.749754
+0.36,1,0,0.36,1,-0.3056,1.08,-0.42336,-0.528,-0.0375168,-1.88352,0.314377,-0.865651
+0.37,1,0,0.37,1,-0.29465,1.11,-0.428368,-0.47325,-0.0563805,-1.88857,0.305145,-0.980674
+0.38,1,0,0.38,1,-0.2834,1.14,-0.43282,-0.417,-0.0752753,-1.88974,0.294768,-1.09448
+0.39,1,0,0.39,1,-0.27185,1.17,-0.436702,-0.35925,-0.094162,-1.88692,0.28326,-1.20671
+0.4,1,0,0.4,1,-0.26,1.2,-0.44,-0.3,-0.113,-1.88,0.27064,-1.317
+0.41,1,0,0.41,1,-0.24785,1.23,-0.442697,-0.23925,-0.131748,-1.86888,0.256928,-1.42498
+0.42,1,0,0.42,1,-0.2354,1.26,-0.44478,-0.177,-0.150363,-1.85346,0.242149,-1.53027
+0.43,1,0,0.43,1,-0.22265,1.29,-0.446232,-0.11325,-0.168802,-1.83363,0.226333,-1.63247
+0.44,1,0,0.44,1,-0.2096,1.32,-0.44704,-0.048,-0.187021,-1.80928,0.209512,-1.73119
+0.45,1,0,0.45,1,-0.19625,1.35,-0.447188,0.01875,-0.204973,-1.78031,0.191722,-1.826
+0.46,1,0,0.46,1,-0.1826,1.38,-0.44666,0.087,-0.222611,-1.74662,0.173006,-1.9165
+0.47,1,0,0.47,1,-0.16865,1.41,-0.445442,0.15675,-0.239889,-1.7081,0.153408,-2.00225
+0.48,1,0,0.48,1,-0.1544,1.44,-0.44352,0.228,-0.256757,-1.66464,0.132978,-2.08281
+0.49,1,0,0.49,1,-0.13985,1.47,-0.440878,0.30075,-0.273165,-1.61614,0.111771,-2.15773
+0.5,1,0,0.5,1,-0.125,1.5,-0.4375,0.375,-0.289062,-1.5625,0.0898438,-2.22656
+0.51,1,0,0.51,1,-0.10985,1.53,-0.433372,0.45075,-0.304397,-1.50361,0.0672611,-2.28883
+0.52,1,0,0.52,1,-0.0944,1.56,-0.42848,0.528,-0.319117,-1.43936,0.0440907,-2.34405
+0.53,1,0,0.53,1,-0.07865,1.59,-0.422808,0.60675,-0.333166,-1.36965,0.0204052,-2.39175
+0.54,1,0,0.54,1,-0.0626,1.62,-0.41634,0.687,-0.346491,-1.29438,-0.00371754,-2.43142
+0.55,1,0,0.55,1,-0.04625,1.65,-0.409062,0.76875,-0.359035,-1.21344,-0.0281948,-2.46257
+0.56,1,0,0.56,1,-0.0296,1.68,-0.40096,0.852,-0.370741,-1.12672,-0.0529387,-2.48467
+0.57,1,0,0.57,1,-0.01265,1.71,-0.392017,0.93675,-0.38155,-1.03412,-0.0778563,-2.4972
+0.58,1,0,0.58,1,0.0046,1.74,-0.38222,1.023,-0.391403,-0.93554,-0.102849,-2.49963
+0.59,1,0,0.59,1,0.02215,1.77,-0.371552,1.11075,-0.40024,-0.830867,-0.127813,-2.49141
+0.6,1,0,0.6,1,0.04,1.8,-0.36,1.2,-0.408,-0.72,-0.15264,-2.472
+0.61,1,0,0.61,1,0.05815,1.83,-0.347547,1.29075,-0.414619,-0.602833,-0.177214,-2.44083
+0.62,1,0,0.62,1,0.0766,1.86,-0.33418,1.383,-0.420035,-0.47926,-0.201415,-2.39732
+0.63,1,0,0.63,1,0.09535,1.89,-0.319883,1.47675,-0.424183,-0.349178,-0.225117,-2.3409
+0.64,1,0,0.64,1,0.1144,1.92,-0.30464,1.572,-0.426997,-0.21248,-0.248188,-2.27097
+0.65,1,0,0.65,1,0.13375,1.95,-0.288438,1.66875,-0.42841,-0.0690625,-0.27049,-2.18694
+0.66,1,0,0.66,1,0.1534,1.98,-0.27126,1.767,-0.428355,0.08118,-0.291878,-2.0882
+0.67,1,0,0.67,1,0.17335,2.01,-0.253093,1.86675,-0.426763,0.238353,-0.312203,-1.97412
+0.68,1,0,0.68,1,0.1936,2.04,-0.23392,1.968,-0.423565,0.40256,-0.331307,-1.84408
+0.69,1,0,0.69,1,0.21415,2.07,-0.213728,2.07075,-0.418688,0.573907,-0.349029,-1.69745
+0.7,1,0,0.7,1,0.235,2.1,-0.1925,2.175,-0.412062,0.7525,-0.365199,-1.53356
+0.71,1,0,0.71,1,0.25615,2.13,-0.170223,2.28075,-0.403614,0.938443,-0.379641,-1.35178
+0.72,1,0,0.72,1,0.2776,2.16,-0.14688,2.388,-0.393269,1.13184,-0.392172,-1.15142
+0.73,1,0,0.73,1,0.29935,2.19,-0.122457,2.49675,-0.380952,1.3328,-0.402605,-0.931818
+0.74,1,0,0.74,1,0.3214,2.22,-0.09694,2.607,-0.366587,1.54142,-0.410742,-0.692286
+0.75,1,0,0.75,1,0.34375,2.25,-0.0703125,2.71875,-0.350098,1.75781,-0.416382,-0.432129
+0.76,1,0,0.76,1,0.3664,2.28,-0.04256,2.832,-0.331405,1.98208,-0.419314,-0.150643
+0.77,1,0,0.77,1,0.38935,2.31,-0.0136675,2.94675,-0.310429,2.21433,-0.419321,0.152885
+0.78,1,0,0.78,1,0.4126,2.34,0.01638,3.063,-0.287091,2.45466,-0.41618,0.479178
+0.79,1,0,0.79,1,0.43615,2.37,0.0475975,3.18075,-0.261309,2.70318,-0.409659,0.828969
+0.8,1,0,0.8,1,0.46,2.4,0.08,3.3,-0.233,2.96,-0.39952,1.203
+0.81,1,0,0.81,1,0.48415,2.43,0.113603,3.42075,-0.202081,3.22522,-0.385516,1.60202
+0.82,1,0,0.82,1,0.5086,2.46,0.14842,3.543,-0.168467,3.49894,-0.367394,2.02679
+0.83,1,0,0.83,1,0.53335,2.49,0.184468,3.66675,-0.132073,3.78127,-0.344892,2.47809
+0.84,1,0,0.84,1,0.5584,2.52,0.22176,3.792,-0.0928128,4.07232,-0.317741,2.95668
+0.85,1,0,0.85,1,0.58375,2.55,0.260313,3.91875,-0.0505977,4.37219,-0.285664,3.46337
+0.86,1,0,0.86,1,0.6094,2.58,0.30014,4.047,-0.0053393,4.68098,-0.248377,3.99895
+0.87,1,0,0.87,1,0.63535,2.61,0.341258,4.17675,0.043052,4.9988,-0.205586,4.56422
+0.88,1,0,0.88,1,0.6616,2.64,0.38368,4.308,0.0946672,5.32576,-0.156991,5.16
+0.89,1,0,0.89,1,0.68815,2.67,0.427422,4.44075,0.149598,5.66196,-0.102282,5.78713
+0.9,1,0,0.9,1,0.715,2.7,0.4725,4.575,0.207937,6.0075,-0.0411413,6.44644
+0.91,1,0,0.91,1,0.74215,2.73,0.518927,4.71075,0.26978,6.36249,0.0267569,7.13877
+0.92,1,0,0.92,1,0.7696,2.76,0.56672,4.848,0.335219,6.72704,0.101747,7.86497
+0.93,1,0,0.93,1,0.79735,2.79,0.615892,4.98675,0.404353,7.10125,0.184172,8.62592
+0.94,1,0,0.94,1,0.8254,2.82,0.66646,5.127,0.477277,7.48522,0.274384,9.42249
+0.95,1,0,0.95,1,0.85375,2.85,0.718437,5.26875,0.55409,7.87906,0.372744,10.2556
+0.96,1,0,0.96,1,0.8824,2.88,0.77184,5.412,0.634891,8.28288,0.47962,11.126
+0.97,1,0,0.97,1,0.91135,2.91,0.826682,5.55675,0.719781,8.69678,0.595392,12.0348
+0.98,1,0,0.98,1,0.9406,2.94,0.88298,5.703,0.808861,9.12086,0.720446,12.9827
+0.99,1,0,0.99,1,0.97015,2.97,0.940747,5.85075,0.902233,9.55523,0.85518,13.9708
+1,1,0,1,1,1,3,1,6,1,10,1,15
diff --git a/legendre_Ps.png b/legendre_Ps.png
new file mode 100644
index 0000000000000000000000000000000000000000..0c4f2d04bde7daf1550783f75fb179a2148abe56
GIT binary patch
literal 90127
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

literal 0
HcmV?d00001

diff --git a/legendre_dPs.png b/legendre_dPs.png
new file mode 100644
index 0000000000000000000000000000000000000000..83646031554c40401f39ab1757df1e6307704a4e
GIT binary patch
literal 56085
zcmeFYbyQaG(>HnpN=S!*(jX;DccUmE4Jsiajda&dO1B7tGzdsZ2}pN$cjrxa=X>4o
zd!BXP_xa<Tb^beRoxK+8>lgOE_FQw#d}ih|vjY|6BrqR6eFT9(Fr_5Ll^_r#9|#0d
z6%`r$hQEbj3jQCvH>!5ZmWFnYIyMFnSsgnoGfO+OFS?Wt1~#@|EG;;g*;tvmUQim_
z*;(20v#^-|_Z`fZHbyLJm&O8M6*MbJHCqS-TL=DwkR_7&1p=A$k`fnt@074L<LIQZ
zl6bPe%XvHtEnW$NHkB^~HE`;^TT8@TXJI5!l9U|R=Xs{a?c?*!ryt7JL##3#YCc_M
zc09|q@w6x5G`vWkbn0{0cf)5h$(w@)rkt>ZIl=F5ZTp5~{B(!|?yh!Ey%ReG>bq<4
z$s?cpe<4L7rr!S<k|D})_d9k`Mx3C#-(e{H|F;2^{C`OygGSc}F?G%Q?9P=TEI*>7
zTQwbLR@T|Y#l?Fiy%fa7FG5R7IA!RRVG=Sj7#xP(^D~ZfLff_eSY)~jjlK^aKE%bv
zZP+fGlY8^#P59W^dS-HxQd*B84GoRAz)rdM*4CEt&SlG`+x}AB?PVRbS`HWY3GtsK
zW>InRbb(MZf#_Y2+e-)m5z%2;-F4_@epOiA&2fS2^`<sTN@3x*SPmn+r%yXA-498g
zK7D$2z3b6e>vlQ*&zwY9SXf94=2&}3MkgER)3opz)|)7J*v;X3G$64xRTl2!<I{WD
zlPr=9#8`^bYYQbATRIL5Xs=I!o9*>GU0v$38HZ0WnB%lHiZ=@Os>kiAhXB&T-K$7Q
z&aV#pq@<(}J|8T1bc0o3NzgD9a;KEG%>*_*<S}gzA&BFg8_#P$j0J(YbF4m*TS07*
zD=XNwAI1}#&LyCgb-AbP&#9^18e2n2VmZIyxx2e#Jmn0iyWX~h*=cBKkT&^a)6>&u
z9{wwvbB|{#sQ$}=f!H0-6HfKoZ?Bca(k@%LiPdSVs7><SJ8DWw&xv9q+xdDgTVeO!
z1U^XS@I-1wMQn6*H1h~8HT8i30qPs^=FM%e^M~k!3R+sdEFS05JGGY<?)$;o3Dy?#
zb+){u1Ox;)PoAKODk|cxtgOf+@a~sf$|VWLYF0VeXSYg_JNqQxUco}1aQL-RcqD{`
zU=Y4g71h&Q;v@68I<xld<rfe<owj{|jJ&wJ+ZTXK<FxWarSg4pKtOw}aeG!kfKv@v
z<3SVac%jZ~qk`G*w9>>}Cc|G&?RiPxfBcBJ!{-CvJ|h#;($w4yH-wg!7Si0-mh52W
z>MA%gGE(yI-{R&bwD<VK`}ccQbJt;Sf(iE<P$=y3T`z``Z=&X|R(XsBf7jL~b#}fZ
z#X_la*j@y;G1El`(n?3$&BDG*GcN$uJrfd2TwK&ma@k<Cs5$<)v9aN_*MQPjA&iR~
zQLIQwfQwtOYR7-R94TLZGHELRWRcJH%!;{ci#__~Cx^~!l|QOtc6N3!7-6vQlx1Dw
z?RoMo!gLdh7YDMih)7-UWr94VMybhTb8~ao%c(hG1Co$kw_T_arVmg~A7iqFgv22*
zpX5Q?iZ4UIhr(i6br40)JLJoOdGDQ`iol+}0q!LZcdu&oH*X&H^z`T(8YZ2TroQ%1
zB1FxUiEY#i7xL@ShadYwlRrKo;pq8s7|zJ#q|4+v|LS_8Wq)T^7ZPt?>)M)eV^dR~
zQ#VbxU?VuULe&@IZ{Dzh?fe;Kxh>vWT52k*J$_jWeCqHVmdxRHadeoYEH1u02ghv5
zI=sh^TdJK8doPZ|Qh$-XmZ-~0Pxk>>ez-xlm7|#U*6mB8QDi~_hN!*0y<^NXYHFl!
zgg=0B7Z8$>h1S)HsHv%Cx^1^d(7@bko14XdrKL?2>9u{)o&p}K*A^zUYy126Z^VR;
zdSIJeTwLHTmZ2i&Ya;&^5Hak2z+;IMS8z+CL5ybWV1{%@U*B%^b${w>*MkmvO@0_K
zptHRuY(@r#wQBR@jS*5Imnag8^3+3a|E30@8Tn0FLH8>sSWe3P?B7Pi;(c(Wy2Ni`
z+wy|@;xQXYjz6y)kB^T9_nYzIYSC%*VNU)8kjL9E1iXI?3a~=0)|C&AYb0}L$lKf7
zg1{<5Ncq0kKu?oS&)p9qllNBRE!m+bX0?|yyMz7x^-JL*y;+KB<(E5E0=p{j-#70q
zG*uk-3OMgn!1yhb1ss_n6%`epRb@LUB4-G2d#^a?WU5#UVj3?sC8F@SVpCL9)O6{V
z7dj@8j$vNO$<3#xrS<*(9WTl4MD5`4(0RXwXn%iyeb5=0N$nj9SI@2uq`~dgX)V>?
zX*ogyV8Y^n1Vu)Adb+e1D<5C1{pRR?|7-01C5l^O3JMCsm+H+FH+%lfeH5+$LiP?1
zmjE;yZcmoV#IpN7X8KrYJn)M-(Q>lni`i^-tjE<7#rqE*aEXcAmpdYzPbQ26c#4Q{
zaVr$)mV)(w#^9HJeLv|daQ4875Z=L!7ydg>CAd3*>q!b6f#4T1!^8i1+n}(I+fN<h
z@ok5V%}q2ctX6o$c?N$l0^N`p8648HXU{%!=VIs5Gvb`+fdBXL^>wbqxVwW~Q9(ge
zN$GoL*V-5X>Sf{l{O3oH9!bi{{Z2{o{PyjeR!uDk04+g}U#J#B;(JDO$96V{9f;m;
zkJ+14<ttBV5|?U^Wp7u?nUC2gSqN0k$l2JiH#9WVxNm#C^(w^Xh?PmCVtw|knZ}D1
zxZJmII6@ss^rbVtikJ3@lllMKTK0)$C5gYqj|DN?AH#+FzuWl#L;d`}xDDEWalBcv
zk&`PaDOs=2USzjEs9ftlrs=4|9xHdQT5gqU6m%zI1cHQDAqp2aH@jgsF#yHv;#ngQ
zyrZI`?A)s_HgaoJ?^8Mq{g3iQ{mGi{=PMfEN85!$TU&c^anU84`fjHYk;AXobdudK
z7}?m^Fv$3$P$*o#<>Wk<kFo2;XsRC=_v~6fvSWlNg@d6_O--#z%b=AQ>kl`mj#7Nl
ziEL)<$0CxFdiR&w02sPAuEc2f0>A~31u(s|^vCGvXm8)Pg8&4}AIZOIfXUul07Lk+
z<~F4^=j%Zret<N^u<6(iHh-;3&AHH~{II)b=D$t;|LZAfmaS^bM;6-(K#|;@2%Y}b
zs;jLvs%g_F_FGt|Mn;V6Xs+6=?J6D9f{tG58yRsJ_fvk%Q*W8Bu<dh7*1kE25xiJS
z%bdCCWGcYH!RgmrNs4Uzu{)%s_;zb};z1_%&WLF+07uEb4(P2tDW(J7s)m@ThHim&
zU3PZhCyNT-%1ZuMuU@%aUmyj#pw>vfeTxiyom9YK>yOvof<MJ-sz3S0)wD$!fYk1<
z57Aw&V+`!SkfV(Lp%i}cGgd`o0B*S;uraCR>)%|RkDGDJ#|*);uJ0_@qzXOl1Z-Fn
zZpy#&Dq=IW&jldp`88qR0@}3-QuPQDjszdRVo_36mHhDGF@O-Gn(%@GmfG6d%o&T~
z376|YW^QvF6wi%DSD_Av2>M#f>%hqZVBJ8GRjej;z*B&^?_5P0Q6SYXQiw{5r%O!A
z%@xe1iH>`N^o!SFOBDv=<Kx?!t%(l^Kn3UQ1V_-n`e@eH)}$it2^80B5*XxyKf9PW
zudOFFaesVA7Bz6sm)OJs1{ATQ91(-$X{ow<it%oD=y{ruaa$N!2nkP^^-?Rs9zZWP
zi)mhR=Vja%gy_)Iot2H;0>k!iRMXJi8kwK0UYI1@2}LOVByZ?4ApP%Er1i{0{d3`l
z8L^`f5rgR|@8sjp6fv7Z-bik@o)L3kV0r=%BQ>hBr^V;zI_Ov}irNxyw6MH%7Lu5y
z;7G;%%>@;O@EE7_;Xayeo$c^`GZox;-C`DO6l0T7JPW{|A3S_jK}jZ0a9`QDX`8E|
zg^d!v;3oMuuOJ^oQzPo7z%1FOfOv;_5w!(NT$=hykLZejHHxO}{?))qwsNHW!_1sM
zv#@8y1z+8U>bcw>^0}h8>LZUwJ~m>15WLQiA1vDNXEQ(Fv*WwF1%clM^)V_67X00G
zk=ci6ubbY&!S#asVWXD>c;k47=+EtmSMW`wcd0)mDO8C<dgOx?h?uHTm^I8PDs)$_
zxv3dwF+&;@2hJWMJO3kI=K}9*_@z9Ez|hy#!is^dLIZ!BrlR{|&-L1{9kvQ}jTBg1
zRa}>yt~fT@MF5lQLlUzD{4JF!dL=3$hzp*-L>Y*>H<n(Dzrst=NrOM{_Q4nE>Dj|q
z>x5+Tq>n59qp8rY_4FJ{Yz0bEV*=ESPtEBD5QU`NANTu++gN-xNoIa_c8O0&vb%1R
zPQ-}wt}H-`<bkO3jx`Vje!+5=WZ`nj7{2lG5}z|)CuCdSA#a=<#8Z!t6VwQW*PIFA
z2c)O*7i5+PUG=G=3^R=)ygu{o#-b#{a8EtrA`|i<8}ihjSD=itz)y706?xS|0}oj1
z92iY&2`Bh@qP+7A;MMC15<k=K3fe)Hai-2M=4Q=iMR-3F7J+OraM{*>N@V#Oz*TV(
z7B*%P(ZQ(thZ|_HM%GKAQg$nlyfLTIb&?G0KT3tYIz&O?20G!sSAPW$_sj0n{~Rxt
z9P+C?R(>4#x@@sBPq{&zKt0%Ihumm)jDscq$Y(I`S7~7g9BPsW^b68bbMR#7bd`pL
zG{c-c5mW7Q$4kP<U)@Jp%d!2qmx9dX6t@uY>LgIz%si)?nR%@m5#zmJ<6Qm}?jh&w
zD|}>^*d{mgqM&M@c`hi7o7;mTA<e;+LHnNrt`&z}iD43v6~YfI_9fvjr6I`67jOev
z+?HczNF#6b0zto0Gh`JPUhF#wNl2q}(Z2CKp(Jewk4&}v#zvM4lLAQtF7B>!Qaq-g
zn1a)TJ71F!1i5adrkS4rPP73<(|;SDky5lRhUZWGf*JkKO5l8mViSTUbTcwi$)Rs5
zGP~d_MQ|{5IiNI#4QR5n!nIXAX(pbLjz~Y}jCc2<!6&FAuX$6zpTf@;3l-tN+h-1o
zCd>(bgaBMc&P%~XysaPUUR6M>7;l|&RE%&+2EoRml>ij@b8A~v-F*4?M_b+9aqd0o
zVU?mx8AT4zYgJ42_pF?of$x8$VPWVSxDvC5|5c}SBH*2HQDKN*=$$?uzhs~x1Bz&C
zHZ1q2G|sq_Wp}~YJT<2f(jScv{6<KU>Hgm2ps<Gqjg4qQ0Y`Rxi#p)E^>pQAl$g7O
zfB#1g@wWJ5Hg$!!z--A062FH{=%!WxL4FWM-)#}uV4@A7hk}3y7#Q0}3JU5-B?u-7
zJlO9Ol5GkY-=qLDIVy}iL=A_Q-)YLaq*Up{PwXszg=rw9gnjkl`{=}#g?Dg+PN(KU
zX<DJC<di}0L<I&U^upmAI4TpJC-9erGYRduM+$T6vC>6$G>ruCz-4-z80Q5)s@brb
zU)?~H;KDFAXbVTg;V};IXTr4vz9`gbQjD7zhb7uklt!Na7Q9IRGZWvyYhoVWp{5@J
zW$<-~c-pUhhS<c#;BvTVn<~?AwfK6vpsv8-#G1^jQ06YtY}Vudhkza!Mn(B-7>IE9
z=-3m~;_w9<KA}4xXs;h;Q)gm+-Sp=EQCz8xao20Bl79-C@7LCC;L9VY58|VDHe&%(
zi-aFkY!9LCAPPd91f0fNWK0zDi4$Sa2K%p}wkW&|1TYI8N<ZZq9aYd)L!iSidg2Xt
zKwKc%<3y%VlT9?Bod~V5{ok$t3~Lb(z$U8!0v`p1rJ_A{<|`2({jY8F@oBt2L|J(c
zPMYbJp6)(6R>O)}COb>pe^kd{Ku;K@NEzjk3EtkQ&yMS;TU~kYXh-BttR*QS37}Rw
zitBauxkuNURxL$2+ZwXsmREKrmB2b#0C?4`F274tSA}ajz09uq2}NRD*hpI&Tw!2s
zEuiMqoGj1L-*opF#m*W<Du4)VB_S5Rc737Mt6zHctPEYFca9V>tKdS7(`tluXhpji
z3KXW&f=T{JRB9CW9-aqp`KG2A1>7-s`P?LygW)&O>L;Q4wB6SMF6svE%-dnyu1H9M
z0rGG=_l4i$R^;FRUjQ&zXCKlTM8f$XQjO($#qJ{eo7UsVB)DB==M(-n1gwv}<MdFd
z{R(7!9v^NAyWyc#^S?iI$=gw2PRZHl-Zq9nwVR6qFkBN6c<~XDG&rpwFDr!$*{A=#
z9dIQ84$VH%OW{5)3jIE6j^EX>-akX}cPf9n{}KK$KcbGa1@|_V|9w)io-Bt&G;$@z
zclW4H(f-*(|9Ly!toE*xdlbJ`f_-J51d{mx$@n8XhR>Vdf6s8f3%oNutQhY`UNgWz
zb|6UYUihD*jEeiN3lG-gX5yK@ohwQAbszaG;*uSrN|z310T+@iV-jN1;N*5=CCu%C
zyP7iPme}T40SsOvQc)p*1Qry@^5>O0#DWLyG=Mr;0z3?;-`hJo4`hmJUhFh~8<_ly
z7q?}9Z+Yn+jH5T+Hem#)Pz60b8okz#h3w2E{-rUG)2g}sOp)ur%w+etKH<xd`g&0~
z0iv$1?ou&03nL;H2U!fHMS{!hJ=~lG9#aTC5N-UnK%OsNoj5Y|@W?1e+no>moIj}p
z^&6<SABbE|^p&s1nL?Zve2D@=Lk-pkGhDY#wKsc|gs64eS#us8G77r{G~j1CRg%Kb
z$UQZ$BCxYs11PCB&IMKI89lxK;GoiKPyCqkCu3s<<=-+oUC}Se|NJ>^#<nhS`rx|!
z4PXnn)<xchk+raDJdk*UPk=j-VaqvOvS`L(Z)>m^3ThOpjEoFOb8Bmo4b;rc3^vxA
z{(qDg5-gSnv(`2FT0C?#_@0AHY9*XJm|19jM3W9kiT`IxJR@pe)%Y3(a+<TF>9&<z
zlPufOD|#Y9U^CF2zVl)?0i$F$7GAWn!E1eIkPypPxq({r!Gi}*Db%VJHU=?a92iK&
z;VixXKF&f{46c6ZR#vd@j*a}o=lQR?)KTZYoT>C0b!ds_fhcTS{WY8Tdni0RVe)JF
zP?S|h|M3pJ$HeRo^F9+GQjRaUP@X@0g&i0ijFj@{PsrKXS?^R=XD2bJHPphPXAAz$
zfGOY?DVy2`S}p$EfC#Tk{>*Y%^OFA2sQ7+<2-7RJ&vV?peqGf*bIrHT77_Bv=?#y{
zT1{ozHZuGFlxy6<ud8J)x)!6p+B60yQh2SpuV^#U^<9XdS*l!qwNAdoWd46D5Ns)V
zd3t8%u#sF9M`Y2enO>u0w^na#VW-h0S2wr)<71(1hxne=BKk`73WveMh~=G|guhE_
zNUMPt!Gh;*o7n%Ov_n>!`tW#lXmr?TWGtpUq(Su$?9^s%#m?F|5_+MeU=rUpX_4Yu
zSM7zUgKc7LJU?EfmzWG&UM_^5S^#jDl#*J2&Rvp+3!M<h#>S>+W*#0U-zNC@Jjky(
zQSW;^(}l-R7|oY+AAFhL4+OScETUlY?XseNE6)7x7x(e%tJ#C*5l2U7IEq30!^i}F
z3PBxUFtXP|yVZwsNzffW_oFn5f${NnBy2%ZbMu!&nes;G2P<di=gv9HT0}g?s34{G
z%Xzo;<FSwU8|WSP5h0vwd)ttzIc1@{JNXLYCm)>Fs4-)1A9$(+96v_Oh0#wZ;dm3!
zo7&eKDpwmSbsH@?)xkY|;Xg|-I{$_%x*mPIYsa)dWDs^CUYoq}{^5&BU^Jr39#1U%
zGAZaKN>!EM{;NrU1;P9!H0k>yqB6fjOG37&%AZBpcFmch&NA_GJfukRfp2oHq3@AA
zfF$cgkT{T@SOH=gr1vTS@*&iC-}kVE>qcOoo|2KyY-q_C4rkQV?WQ<|A*MQMv=N^k
zOfT`OtKVnkl5=)chbY))48LX;sM#3<e7XxQ@@1+)m~qmu(&rSzjUZ+w%4iFBxyJ$F
z>~cNdfo>g`eZtVX?p)>@NJwIQNQeH$$z(GW@RV(_GIV%;VUU!yLOK?BTAxth;O{-C
zx5G1v?;pxrpclUTBD3h<<69gGcKX&6ap%Pr0@N0!XNgXW&jnrUL9PL=BO#D889SCN
zP~g22Z>;D;;KcA2%6$YO=3>GPmfioHGT^9D{c5o=!V{XUA2YPRU;=PY{37}nzGV(Q
z7MZoyYhmf)?I_rYUQyf=KANJ;PJEW%q6}J8&uJfn+?(`e&->+-{{WkC1_w?O%xXX=
z_Yi@YoiExGC)uJvx;h!`|6%dOtHr>_MM0c*z`C69gjof|5h?n&nu+Mp4;&L!&mqJd
zJQWfq_`4t(&`Q%A&$^Eu300kquJGt_et`?zFCl!Y>>o~(XS&XUI34owXWzvhuxZn0
zSdJ)-znW0kFq%LBf$tlWEVrZ$`-$I#E?=hJr1~UZdG-T^-FZ>?>NLzW_`xIZlr>+L
zX0+TF0_pN+i(lDc8+*}slW|jM!I+fx`ug%e=-fa?>4cdZj&1Gj54o>cY?wg}<vJ6^
zc{RO?{gl~T$n+5cv5){-q#DTpwmz_<5B#gRCf+V^tS|VettR&R1Fd1O?^(m^zV)Be
zZa>DE;`T8M+09H`u~ismL9Sl?u1%>!{R=$eEa%!EVYQ}XH?G1Q<=VE?mSzLon~xrt
z)xx-83KuL7U+q6fd+q1lA#VN!Ewq&DUiRkP$7CDh9(&V%!5;~RmF?0ABPW`(q$6Ga
za<0<=?c{<w7&j4c5(`wvc<`*<HTD<H&KGW2<?Vd_<DJkol<;sm-o<Gbf(#F3N`iu+
z3W|l)YY_6l)ePmD*vxuvhf?j6+EjONbJA%T=B9;JU;Z##NIm|D3~bl_yF?h`efCo;
z(`K5H6~zf)7u*Z|Nc6cJ<Ga5<ej?uV(25iV$d0w>znr~+ykCV4>K7c|GXt~P^Yy~>
z%chwuLxc14^K_@eeH&y^EPxs;z{kOR2Lf`+$X)r|`#a5_)wx*(rO|Ek(HBcw+#jUk
zgN1uZ%(53aKr`>8Xr`OqqGRoV%nk0rvzfr*K{mEGBIFasO%ENb<oQM6q4u0ElKWQ-
zNQGON?5l@9I4K<75x6&+Z45c>=>&+cnre?~{dr>g2j?lDb%u*A{eq_QuS@^e{SnF1
zwy$gMlcjxTva~Gzw;vKg(XV^@{PbPA9xUVYzqOURgm)sii$4&X8UrOI5u4Vgtv<k&
zInDo8(QV|aVX5kQp~}B`B4fRA+Wi{ExFa^8#!~)&$^C+NSzKfs$woG>|GBrHj-7?L
zh=~IpH-)ri6unyrFvh$vdfxkDo-cc?AAuDEU=%8bz-3UXuY^ffdqLZVp5al36ks=x
zXz!M7ZH|E%3=Q_r-}`p;>$bJ*uz~kRLjwZ5uIh;HV*khsq%Y`z2GzwDaDCe7D`B|g
z19y_(^76TCblsbkRpC=$R^t^NH6P-R#K6iU-vv%+1XJ!)zn7SpQ7{7}?b^n*eE9<i
zu^^S-H-=lSY}vboO{D1kUM*9MZ{Am4f(7&a!mJpL_}@_<h4U`CnY<(ExTq%e+>gmP
zGISmU^=Xib^b@|Po<Y-Qahu!sNnLaCqm!z+XYv)s-D<nVw$9|l-?;gMveM^gpUYkV
z?tR|`RNdlq6>}5M6<FZRE{4_l<tgNw&A=Lm`;68^cZ9hCM5bCWudMUCFsQGpwK^G2
z1wNl&K8Bya{=CVbywn_43Yp)%_JlVxz48aF8ps_q)B&>C>no2k?#wZU{Vxs9&i=i5
zB@OMXGthA%-Odj+X}y+3_x~3KVcicZnSCL9!3xB2k)mM+HI1^elDON4jQdJ@KOk&C
zi7YMiW+wmfdHEzJ9($7{G3jXV4=HUpsP?h228@S@dAgw8Nwkq5!h3LZ?k#)5jb-)%
zd02n}2CB0QpRgY#ckZT7ne&pVMN1K29F_H1`%rBy^n<XRfAIJb&UZgwXv(YgTu^(+
zOYWfhpq%Iu`~4@w*CewHYQrQC3ZKg+=_%vn9WTpAwJLaF!XE2VBfMU9_XsIJDF8?S
zTwJvO1&}I<(-w<B8t5oN|Ln%I=X?RfiV-!MaYxpmjGzZqX8;8|hUZtLdyqu(*C9^4
zWV^k*@y_en-qQSpn&qfa`4)&D0;;*od-><Hp0}rgq9-?;Wk0q_?tHRV9{r1{1-&4%
zXGqZid5*#bJ1Af{l$f8Qm&0%?HRSpT;mpjS^nqOUlO$fV2Os0}4p06?JDmJ^4*A@;
z^5thYK#oHI@osOg=BdukQ2GZI<eg8f0b>b&j_KfJ=K-bpQMt0kT-EPy(Qi>w*>3dZ
zLiWYK3}OR1ELrEDD!+f|>dwr{y|1`vRW*q<G+aZ{-KlW?ar2GWJg4yNQ2DL*Z_S{_
zF4Wy7U4Gq(x*LEdz<Pv~vv#q`DRnedOq%DkK(LuybYpW9dO_iD4fuLODk(?KKvS7^
z7(YPP67X;JKlSKfG5^~)8KLB36<>{|y+LrEu|=WRjtx_@MOi_F3x!8WByVg+%A8qj
zdj@Y(N_vd2J%4WB4N_l+yw0|P#b@kn0b)xff3q}*fx2u5?_(^oCmob*g>T3ANJ%2}
zVM;}9p6y&ihf0R2fnvpHAPCH^n`XF?9j=$;mF+1^Q9BcU;6aeBt7qXSAL-e$8`8rA
z4?f!uYQu$y6tv-_i;Rt1e6{s><v$@)VtJd7O#{@F3!(OTTc1=O)Gz0<^TP;&G*IDk
zTp@Y~bde%v#lQ)L3;HHj{!@xAR3CvD*n(YoKo=^NfxZuYSEM^&$u6GVAzH-EpB&a?
zzc`aW+!T2Jp(&}qeXmJ?+0V#>ThfOIc7FUjINfetv2nTM_ab&i_J2Dr?nR8dx=!p{
zljl2l`*gFyO~0IfT^?@7K@@@y=ITX3`oJLMFnrHC*ySe7BqM#}HWUQ049omE^5@Qx
zbzn9YfFgAJ4qVAT3Oa7whX4Cc)$_(*QupSCA%ksl`co);<q61AO^s6R?{`z|Kr~)2
z9&D3+Kxq_nmyRA$oTHp9npx66<0p*4?Tj$bfXHYHwm1Ed@<<13f4mq+gG3n^4XA!v
zx;L*%iQarN&&$%@(G0%N_49#j&FOwl<?QR>K=!^z80hqLJ=bz-J4uQ62)Nw%#BYF)
zjE>iZ;T$E0HC|Sxg1-sAI*?q`keBqQ`X?dv*B88wEU9<7lca}&rba-`FAU(yJHjH6
zx4n{-FX&RnOxbw2PcFDJP5}=X^FjCqs+4raVLmZIo=dgeTsTl&Q&n;eH?$+?3i{dQ
zFiFx^20Bb1wbAj3GEPk}{kq<aD9cCOT#C$t{`82c^e*59nXN}h2g?mHYac%*n07@!
zS?Ll|l6bYsdU}G7c|7S3XY4Pk!xZIvWYHiY@i8)@0rCZ!b80FQ4c^#FhevaToLmEi
zCLankKMB4Dq-irA;oHH@f`O<AuYqClfzulbgE}Z_T1}10ChMmciSfgZGWCS;f;f0m
zJx-u3-q=*OQDnSz{G74I;X1m>zoX&?`RQ0*+w!J#hb#}C`{_)LgWEm^I52io{b#<X
zGt%QTjtC0ZTgA(Bwk+E}e$=Q-w3(#cb7F344T0Nq-O&m%t5$Sc5n<uUr7HQFrwu5}
z?%Rf>4<C+y|1RmW{$`^seD{ZGun{9pr*DyJfXf;cUa}LSttdox>R&|hvP+!f?oKJ5
zoP~(B%#=LbmXb$`%Kmo5y)`Zop)q=PbjF1VviY`~;6;iX)U*uW`X?Nc9-FeR{+OHl
zrooPI<{tO&9{b>|D^hX@#$;D#d(Aagj<)l|CRUfLN#Lo?h8W0{(6JNpx+M7WjvN@?
zOUaf<^=8trMN?#*qLVFYdkHl@XU7@Y9%&W?oa0awDff#4)y77bqsm21U}IBfSWm?#
zNi1=yKO^vxMqO`=MO~fgX!P_5xo?N;M<TQf?~C7Y^f4gG?^n=7Qw@}&XqZQ16LP6(
z&HL0*vBMuHa!YEffFtGM9JIFUiW1o}m^Su!7qD_Oop=P2i?>2z-Pj(eh8*_0H4-~L
zW&P2~b7^B_oDF2Cwx>J4YVz_V3gF4w;0)HEDOAsi=*|+_Ce~P4Ase!$m0t(zbrBwY
zHN3ewd!X%lR5ts}sW*YVBFRYvoTLM&58I);R4WrkMdIT9E@!NK()pRSC^0X?q$tD{
z#Gh^F<$;uANN?<pIzdAjvqYq%bK~r2qH$S%+B>QKh~f(QvAiGxGg0c8ro`lC!9ry8
zD9u=8tr(!sW#(IyB|Tu~S8X8;AGGBc%4%gNJZ`c5ng+JV*kfh%Ly{jDk7vQ1<fX(v
z^0bUpAbc6iR)i_%?v#A5y|l4v8CGNg%l_>#F<RX@OSikbkd4r~08qNb#Nwi)+x|o9
zol11i4OkM*?umdE=t*CeBFp|ntlv+Zf*P=qz>5d;6`RWOy~%eF#3p4);_u^mFdhu=
zI2CQ$-RMtN1Vnn$QdHZeDrlenrhh7+aRV51#2XooT_kcNkC%LfzdHXJm>`|ezCEYe
zcz@oQRIM@RM+)tyInNpUdUi%_?;1ru-Xy`<1%eOi+tr3DkEion-v)UcB}WNgFk$$6
zr#Rb6d0f7{^26R8-ISaI8A=VE{*CKtWPboIuc;}c)4T}7ZQX5?6@S&r6*q;pl0-Pt
zee9{$HjVVo+a+sRv0|y^vD+Bl5jfpnTAsGUKfxA;1pEG^xDH6CPj1E|oi-o)b|dE1
z@9loxrL7C^;1iGb@gN*aNl_h-sGwGzn|>yKe|`MrV7DUXBq+#&&ja{r+g-}m+-0sE
zEv;<M-7jaQPcV?ZK4UXG=@|3f_8PN<OdyPlKW-S7OmmP_#TM&gxT3T^MSv<~w%i_Z
zHvnKZT|O{Gd(2x5&ZzF}AzIz7&~Hyj9H0cZTE+&>CVc(N!+Z@o{}vl(<yX!h2EtF;
zXYw!IN#4um6<#dSRv$(p(s7N@P=Z@nIHU8KPRObu;%_aPi>h55R%>0ys2A5@WYk|R
z?<1Hb;1~Jz>zAOWQUO|x4eq*SO`xSAU2o^RgWcNrAQ2IJvDcDFpi&?ad~lz*Iu-Qn
zk~U53Ali6ErX^J7thD3W<kxvsp3Wi_$FA+V#YA~rA#Flj%o#P)MAvk{FcKId`4$n;
zkXJVQ&K=uwe#hLEgIyB3WdEw53QL3e`R$d_!EPmqgqm7RAD`1=3xss4HlwQZt|7?%
z&_B0hLOF2ZdCSDd@bEg34jKu^bqzlqg~Q3s<yk8lb3Q&*Jv}M68@^w)H}*1w(mX26
z*AajV#n1;#<w6B4NpGz`6)1IYEiIf~uNC8DcTRp!jqd8-zkh?1lauEaGZrZI3s&=M
zUf0*4Ks;tXtNh3`5PpMK7l_YzdtC5kvNmzclnDQFyZ|kM@32}vhT9#FL>uaLbq)QJ
zmD|EYx!1U{i7+$jfE4wAl9Y)&{}Q{t6z+$nL44Yx6b$`K*zj3-Z}~MrIU;hw^fa0U
zh4S--ovz2BwrXP&%NZNAa=UsRIyx7NVLrafWnyY7B`doU?r}wPIt$%>vU}L2ee+#{
z!tJPJO51tmF(M+OOJy^;QEnFH%@37*CT8RmmsY#yM9dF1&ubhbP8Z^Nw@RC}*yHC*
z8iW*cfRVI2=k}E<I<{l~VV;an&ZudSn?9;|kfEP2=In}&9_X?1!8Ip`wc8M^k#5*(
z$9fu$;3+FBJ8jeTa(H9}7Y`3~UN5+gaa<w_3t7QXWh0m?>vc)?r*Qx2PwtX+XnQ}!
zgHHHj?O2--jDvOlV2Ty-5ay20o9Z>4cIEg1_F~Uc_o~@1v{_{g=k#p1kd{9AkdK?^
zeeu$D8JdOVLJ(8_+P}$4Y5CF_(bWGMtzZth*DcK4d`#bR>9|w?La%3pQgn<dKo}ot
zx?4#^A#!WW57PSKnuA9_Jlvj6P8HET!#S<GrLyh*X^}TFWIo3BNX{h*F_q{GAS2KA
zm!{n>xBvHH48arevF)*c6Ow1=eP~JCq2K*IUTu0I5lmarSl78k^}h-3T_<?WlGGb^
zI!9;O$IPlR?kZ==VL9Ki`^h8af5`gMylneAjaNOPIUQM#eVPoCoz{v+>}p}TQKq7z
ze6c4Fhha}Rj-3_UHsU><)Z>EYY*#N_aw!~z3$F-oz-QGqNAqZScw&0ud5WF(b-@q@
z&zx&<ru5;X2HVwdH?vAt^m0}#X;;@23RlI+3nnHPoqBp4$oQmBLeolpuiUDjwW@Hm
zW>HM|&@|B3S^t2;lDu<&`x64O;Q2Inn&o(T;Ff8As?H3*jIeO?%~9q~=qi*IqZ5qe
zu8H~j`cAtZ_Q1!ANGz)(+S?`nS<Jk%vnv4tJpEVBtCS24%d&JulA+s}b%{^dv`kr<
zZ(tGX)n{jO`VK7}_+zea4kwNT+t%%hc0QcGVyDTZpC{^<0rLbhbR6DvGUtPOq5rr$
zZ(xoD(~cCqLGN6Vv8lIvcmm3=xy?CQW?sF1E3^iNgAVP`+`e|0&|V14(S1J92XTOA
z@^5iR#ky&;>n>D$+KuRUu}l)V;FsrB(H`~tePs(a{A{M{24L^|o^Gb-*~}KrEd8x5
zV;GC|l?IS!SQKKS?Gw;5^<rCwn+9zDIaKVr6+>P3BN`A4Ym~|`FgB>7glYB`8Pn^^
zqUO&J>lae4_S-t@V6(+LYCkz$pSd?sl?+cY^1G(Q<ieZ0UagZK|GE7{svmCg-b4Ru
zzw;x3Z@s(e4Q5lyNnTmI+Fze&Z<Hb*zwbxG$$`*iTwk$u2YAJ$+SDX<HIy81d0fDH
zemPWP&orT;?G2h0Lp!GbREart*dY=kQ^QjkaBi${eOqtGSAXyovAdKYpx6k=98S+L
zg<n(JjgBZD-ID)WHWFzwwxF9|43_e^75WP6-QFHF@C50aa2x1gx;J5_*Bx@Z(?~4l
z<fg3&%-OT>4vjl?y7_AeVtW4R<6Z)-Tg80vA`At<*R)UWXh|B5_Pho;kG|W#Crwtk
zJWi-o18kYobzd$W{uXG;Tpz4_F2y_a-i<ui5-DnFby>r07X|HFw`fZj{x1c!ua>V*
zlQpbXD``RMG3J~+tf;q-i6OW$!wa{{q*c30)!PkR2y<M7q)ZOfG?3;K4`k=%U;gsR
zNe1YZ^}$Yg<jHqDvuwtlG2YV|$I((e@ycNL#&mg(^D~^oYkx`S9lk%-)+H+|5zxbz
z?}e{<Ffsvq+BzS&vp_6SW^rUy3KBSWg)OaEdD$=c?qb}(H6js2^~^DS{iipdV({Uj
zehMR{I=vvtx`7pcCic;)^EoP;Yw#Fm2p?fa3I=Hlx|cFt<o>MES0ZMg6Nl$XPG761
zEHYn;B&RCR$d`k64BoY7*R4wpWX*0_i9ElIVYjmM*K}MA^l^LX;D|UeG~h<OzdlS}
z*788glL*%h44_<Rk&oCL*Hit9D5P40!3hk(QuWnqsjE2=yxXZcT`Y`r=P_oug7;Es
z&XAD@->c-_4fYJCVKmJT#b7U)IYtNyCZsAa^4E>BsWa-GF&ykx2OqR~gfCd(a6-AC
z?AA%_CGaIZ|AY+qo^=%&I((hr0@|hPQ`Db=PtvjjgS3U-y2hh>(tNtlid=eAduR#B
z@>)zdI5wko664!=hTl745gof7uyAgVdofaamTTVzrPm4iay{>iH0XkWl<WHYOSXt8
z*v*@*CXv?VrPsp|W{|La?X-JYX`XJXPh6d_LFlv-#f(clU}Isfm5(sI3tI`VHa7Mt
zc)~(5cJY8wCZ;Mj<AdyTjy<+VeA=0QeYaXx>D|+R4)i@Qd$w*)ct8Q?QYi>bX5EOp
zI_Zt6vcLdiLr84ouru^Jj%&;9Mh&vK5g%~laT`7yqt#4L+oGHiWCw-{-1{8&KC^2<
zL!%y?M(*r4p|sa-m^|e++p{u&C-&OQTiNqxy*4t2_{EkafU0T*Ro}kH4SgH<h9Sr8
z1w`gzdpF=B9EDZw1$n+|Gngwveh}HyIu50Pq;OLE{0n;YXvf3zyM((}acV=;2*|`F
zwMR#%dn;AK5m_Cy*nybC9v6%gDw?u0&|PIbatu2BeQ$p}+m53G-gwDfAR+>d!LTYI
zc8xjWjWu0qA*Ghp3p+2T%fVd7-EyS{>()<AKcNMl7+w8g2=X{kepGiuxxKP-mY$)=
z=gtXfGU`3C%An2!l`cY)SrMz<1_tCEzOIz>g0opiM@dYSg4LW`)YTP?cXLxnBLki+
z($cnVj@Q+qdIn1fFsT0hS?M^75E&RywL`tNo|(n)vQeL#<4E@yE9evqDIge(m#D$B
zvd75-X&p|Mj0<Hm$fDcvmR~I3OlAUyM0_L{3n?O!()Byz+jEb8E%l(6w7%dVo}IMa
zc0_<+BS|I{=Go8MNBF`9`H>HMO0y9bEhinJgeiKP$SnpaORYsN8M9exJ;8G)gGz9n
zE+*d)WX|lY+W@w)IoRzVXFN!7U8lCw|6I^O7Qn|Xt%HteKUoo)Sb3|zkU^T{s~KM|
zniHTJh=S=YjCcn|h(EXcq%*WWU23PsbEljP9;DpcW<Hf$BpN+}BX&V_UGX>2AAt}%
z?7cx;q?UBPab9%4!0$#t089u)+V6DK+#dgiNahp$3Th)jV<7eJt?xLl*_>{rSKR2c
zr0@ZkNWSucTU>P9E2!F&hqwFoK@>M=y_Nj(KbU}lY5m@4di>|=&<OI3z*2Xwu}HtV
zEUKO{QodqtK{grj8=Lhb;Twb+&EM^Oa7ELzGy1NTU}(tEOOz$mRvOp)py|KReAk@l
zSP4a+bBkFD&TqciZv&&VUO{lRknnbPF<zZGs@`^gRCjIMw=B@>mCvW#iAdJN0w7z<
z9240TKeLI4k?fw0lJl642k4&CK4eLx#CrQloyEy1{mBAF<i$bP8OBqe;=kX2-Jat3
z&YjVP4Gzw}fHwsMyIC<z=G^_am<p&JC8%1^c1B*oJa+M3u_Rfw>OI2RN-O&Pw630V
zuq|x2$L38hz)K9trr$k?k%6G!mHkoxT8~aF5_aS`N3{_@_aHvhuhg_d%Z_%0r7mQ_
z=2*7{=x7nm+}D?28p=W|a?O}0ixs9}M+8YTqK|M@1Z{JHatkiVYv!b|7L(0Tr8kv;
zk3&wMZ)bqhhV%0mBib(7#o^ckb2o%fcB?~g$BW9Jk}zH#>n+c?kmR+69lwI(|KJox
zX5<Denf@{-_sewkLs0uZ9J~5TD2)RsR*h<>ezkCOQ;Ws5e?5?pYC8+dA1?+$cY^(M
zXaXOKC(`C<g0f{YsEV=+s%5tNJp919uWDAcYq^p=_Hcis^68U&4E(Tb(w%P+Y%Hq-
z|IXd;ytU;(h@{hTzcR4N{mK^mc~+CA@LaXm<!T@=-q_NdR#4dMtXro>wW9qT?zg6U
z%h_P?Qm=p^ZEw%ZmcLb>8{c{}Pv7;33iO;GVWIr+xZ&UnE=c<V>rHy83XaAlsyH<Q
zyeWE`#4>%Q9-+ITp&5KOCVstcX{Mou3Gab58~C`dJ7XmfyK&l#3W5*D!pC0PPyrXI
z|9gJHw!HWRLaKVY()3ndfLk~zz3#@hS>y&mTK}1OTX>{nR~{TPO2&qd#4F$`^xja(
zqrU89%67kbXjOr#RuUlAB}~25N}_hXh#R*_1{$91=bc9^Lh_o<jJ_zR-W|<*Pl}=0
zE)n_g4d&@-+=8uJm6Rlm6#;VO8&m%0ehCV^%4L3t$((EO789Z3WpCBwFTlp7V*|=T
zVXwzh@hs1B2#zLvvCDP0iOnKc<fe9<RVqXZpx=|*)BP37(x`iR5YvY;nukES@{0|0
z@lRV{<5W<>L53EKOia~GFf7{eubj+{uy%AIE8fj!ouu12tt$u0(x2?qWqJ{++Y^D3
zHTYO(4Ey91*qn11OXYXJk=zCo+5?dr?-1-+dSgH6r@#Y2flo2yD4!=WW5u66aGzjg
z)5z~_*?8N#5g*)9!Z*dMZX5OEoJnoyuis*;u6)chq3(@!L~+3mkPPdNl5*GWvjZu0
zn*)6fE2%#>J{X*H_TM1VN?GiaA1Kj7nHXcHJ4k{Cxa@8IyuPj~vVjM?oK?3=hU*rV
zFMLioklX#GK#!xCGebj%+049*#K*USo?TzQv4Px)1F!a=`i(!fl8TleD3W6%f1jvc
z&os;$(pPcECsdN!Y}mBt+uqg{rsBj{+Z5G2{DCfsDSiAoV{iy=4J3TF%<*%szM!Pd
zW?})roZkgwpD+`jg|bkg6DeJ2*QM(8Jk3dRM!uAwz`Z<7#&uoKm{BQ*gMZ9P+|%bb
zr)b~|@iCBWB~jT#&V+Tww8J}GH|i@eE%g;uW@Qx0SwMJokPB|wy0xR7pN00X!p3OA
z7hH+`#MG207`+OXZh!RrFcM;JClptgeEQFYgbjhMMzzQZOqgLffs8Xf?5XtZtmf9I
z;_vI)Ro7qpzDUbFJ7<wstaIVY2)`x@`$Y|piVcS_+{?WtoIJjVaEENM;?H)5X+FO>
zlSr_)hxlmOa<PeAQH^G04ecbCriC=cOV>X*+#&bUo>#GaF*i6~AMug|ftbrk>{QsZ
zVBU(4;SY--*U^Y!q+Va@zyO$)(Y?}>#FnO~;q(sa#~6G)a~pmT{;Q@Y(V#1ujoZa+
zR|sbxv=?wc4<~fBPgMmYCFd`HC$VTS<GY-F1*37=(LiLW{TWnu<+}mXPH|s(4pNb4
zSGAX{EiDdRT)?ZBw_MR5F;s6msGsgSdI;;IT8CdHcn0G4Ie9=0IFf7ah&=;iG9!4O
zT_xn(IxX>oj!vM=yY-?Plz39v<#Ag%l8spHWcjMx>yS288N%=0kpfM#M7Nj+Xd4my
z8J6HXI|O9;xUU{osF++M`n!`2^MT5h+taJ{qPiYuuU{3^`u%MqPXoz)4xnX}XsC@b
zFlp_QP8h(v>bk`?7gyBnLU?-hHFut$7av0aAXVe{K3O#A3mr;-ju~p{G{PPnU3|t&
z<0BP3*t@Ror&H+ILk|f_f=)cV)&%_EM)byzpOfL3f%2rP%jnWo-c7o1dIWB?n2RL;
z6P+Ecx~O>qv*?1Ig(xp+FNFt%s^%d-xnlZ6Tw~l!h1W+##~UoyaFn#1$S?mIL|ymo
z?lH1tE>F!h2%FMbV~d2ytE-o3gD>gyQ`i#ZOy*pwY@M>uP-{2dErP=Ck2agZQt@dq
zV^4llTVLZ9^sVl{gsHDrD|~I)?LDo!rAddg-f}UKi>-^wevXD?mEOrUJ?^7R)K}DU
zo7-KeJ(S$6gvC-MsBpw4;L{mSc<6ewP_?`@E#_uV+kl(d$5^fakPXlTd-1}FWVh#f
z)Z7;7)-x`Dc`T_Gcd7y}E<8SCp{|{5f>I9Sfozq7;z|76;9pA$h;VEyX|jO-#M~9#
z$Eldp?*_a1pJDXpknUPHUMfXcE&ti<NEbqT0z2mI{5R#=(G4@&GUn5g*;+v;d0y`*
zM^c|ppihdA^6R<4q&n8RLfd@lWeo<Lpah)QpE6*6hJZ}C-m5gX+^J*CWlMe46Y`uz
zyM26DM0{kIJkz=f8Thte<>?&#iG;|rvx6?K5Ky%*lk&ZjX1r~pDDv1t5QXjar;u2D
zz72Y;?d)pqjGvoqYbnNNXu<AHpK#e3Xa2H>bhZQwfRwir{bpihLjiaEFF$IG5DxN9
zy%Q=f&f_Smq$jCQ(tXnBEk_(a3<9$GP3`BS=`IF-S5Tm<up8`$X1)}gnQ<K)lyqOU
z<ou&4Jz?n{oL2blmw&B%JyQYRWu*T;3EMA;0u~UCVk*?tvs_Npa&B(00lUc>i&|sB
z#s=oeM%Ro<vD#FUng&+&&*x5tfIYe^Fen$0*o|H~m@VzKP$i8_VSgK*4iTzva16gj
z3`=&`D3ss(@>+1{^^g?CyJp>;B;PIZN-$Z!jLy!I)EWo7@vHe2GA$$^Md7&mxV<tG
zd<E*%ONz)+;gjQW6PaUlBR3RAw)~<ZslO#S@MhMrsKpqY64bX?fT*l<<ueEuk%L;J
z&ChBGpU{gm-2RGy*(V(rkb=oygxk*~F*6>xguzezyTrU|=7E~Xf~z^pc#>_x-drw0
zw8Q9la7c)u@7B6dZBgnZ>m)<3a0@^(dhigC+HZT~+IkIki=ZtMHF&53Kd-L>ZdQ5F
zK2?tkZLOq*XF*|PTU{~u$Ms0!)Asa+EaS@`LE0Fpjzyk+#8a2*+y;ZFE-eLKFJM=4
z&gh<2YG7Hud>AR#^oQn3ANC302}2=KzeR#G2}*9qI~z&%b*lAr9*M<2Q+^#L3mv<)
zZ{F))Jrog+m<6@qfn_Um`Pam*SsLgV)<&l^T4><r$mSFtp5#^2E?V98$IhF}x-S#O
zF+uc6DXXDlf!AVVH}jyxIkE>muJ>1Sw~CjeQ=f@{UR?!L-wIRjR-hE$PQa#~_=y?V
z()xbzP0YPR4(0ytZZgNu4V|OQ*yEa|PjlqRVV1`trDeO#tbNP#%f05L(YGred=QLy
zeq|knix&@HMR?$oCrfUuSubzTwCp_Y`e{EUM4nCad75`n%kA-{L>B`vb7L0f)V0*z
zrQ1d6X5lNnD~a$ENlkbZ=@=OnAF=IIybkwRG%-P>T<&BFJimE8z9{d<n%O0#_<A6_
zNzk;I&qU;1SJlhRgrPCq`tNQc^}4EzLHr^18e}|vGfti4?nMYi+84-Xku_mW@ncA=
z4h_G^otCL<Kud8MqgBg+)*0$p<gxvZxnlpLnQ$$6b`!_}T}FO9=!=&gsk?bIGIuL>
zn6J4!>x56GqWz}(wATM6RRc{aT!YV=*3&K4m7d@1%9q5%AkFib5G;te1pF0S*vgxd
zJ=uw5a#<Z&8CW$DSgMfuDT(pUu3-5|g4kMIu(5e5F2PC{i@S|TEy5h{?!`%gX5i2Q
z=tbe|$G&D+D++S@j+om11oV_7CG9Xyf^5Rf)cf8P!=NSP#dRVB;0s+H>1c)hI(daM
zJI0e!krelHdY?IW5=Cr5Pg>65G%f&kb}@dKB#h@X9z#hhT7Qcfp9dVP{4Ug0AbW#C
zQP1miVoo~vYKY(8i4KKUxuh)MQ$hI;$~sC2cWp#V(lp{9VM9VUH_loF?OKtA*m4cI
zlRp~B_2XTHU!MCPeF3xgMxVJq5p&!=;;ud*tx|DqZkL8Rw?x*w<c{{ay?MC+`VQwy
z;X@_nBqO)3(UWDfbQ@kMsK6k*Ym?S{K%aq6o4M(Ynw}aAr*Feepu^RGV_jkk!g<y(
zHPr3OUK{JMsc02WOxsMq9Mv-^@bORvRfgAq1O@Qhf04TOO3QD#$*13UCviQ5bXS=^
zP?T!W%n>je!veDiXAd88m`(mcH%7qig9nY^V8cG6!*~|uXt$8>e`uazJXu};&VL?W
z84v|aPP4vt>GZgTsuzbT-kdGHue-uy10T{;sc4QYK^cG=6PWym#N6H7Vb!%^LRU81
z6#ypib$H6Z)C4<UVswjEJrPba)*Y&LT3kdqEX7B!w0m)Yw?Je)YdK74H1c=n2Mt7~
z_IaY%QdMon(2l$?;&j1dL9RUU^eT9$cq1yw(8L_u;bosYQL!ad@W^L=wvN?!^aWz3
ze5S=Z^!?Skd<jvE!d0@!?~Mu=aDh{_IN_clgP?$R$YB3yKVRl<@Gapm(L85D=8Q<;
z#QaHKp_M=Srz$A1@pU)b1NTjYTCOWycYXA==*o>;^|Ld}ODjH1WcdJ{#m8SXg;fm1
z$Sa@@UptzAo~zhNyHO{B!Gr_aR&8rckU6ie8O0Z>MC0SFxREr+zaVUk){tob#gyf~
z@CF{eMqm3gl<x{7vc$eSI;{)8ZMU6ESE*mO8&I8k7g-ZJ+UlVGl&plC&-ja3X6b;K
zsjWb-1Cg9Rdd!g3ZQYD-@l3rwVsVSlgc+bdDsC;=z(nc(e%btzQA^ugP<Zk~3J<2*
zn~ztoT~T@W7nU+JS7uku9Q#$3U)#PGGVhVy3I9z8K7cbew`g3qg3Q}gWcBiQ8ofOJ
z*<%QpH{qL`vj-36Hz_>(0<q^jA&8BQ`{)=4L8+_MGkJO>{wx-wNt!XTa^_eoJu4s!
zu7BEJVc+z5?%CV?4yxt6(*Ax_&s!g~=9@MDv+yTFdB>HL3z0@x@F75c+Mj%mSam6L
zJpg%;C~XJdH|jziO`k_3rKpfoYg5y`^o|OC8(HVU0*LXoqL&Q4z7u`nStvX7TYj6_
zE*F;X>kb};#+UV%pSye|dO-;Y_Etcd$;Yg7#cfVyF@H(_T@rYaV+hVGtH2@y47~uJ
zJA|V^rGM#9Eg|A7S5%B+Du(IsZ;~RfeqEu39nf%gCZ||wcN1cw2vYz8VscO^C+HxX
zk@;6`&Ue3!cN@7mSp_*M+4(2cy{8kki7-16Fk#gY5%ECcEiM7>8_+EU`Mx;aZ=Beu
zui6R<MC758yI&kjm4_AVI&u2$tC=jv;pF3ThTE*(`7yR;4k6COaZgn%-Yn-O+2^+x
zDhVHUWN%&lv1l)D-NIAUiYu>W37QNPYTCl159ol*<%<o9<E}5X-R9LeCpLM@bzVZ2
zh%|>Z4T79NU$kB2XQ4407|;9bIAZgg`TVKy%?yWY2Aru6bUSN<gWKcVQ~E6mcggFZ
z$HN8cZ`MAj;2v*VE<{Exud_o#hZcVQDohHhcFB=`3K|bUgAuDPZ879V|Kd<l_ZwLH
z{j^gs=O85RULReN%+D@96^&2VxD)2CH`f_<f8-!WW{&adTEAh{*y)>^(kLk{85*6I
z`xJcGT(@1q{cq^~+*@T$rfqZP$xn%3T(?Mt6Ujbv#DF~>HEfTTTKL=ES$(fZ(-Puv
z6)NY*h*E;RPf)d4&Li|J=I+eO^sM5TT{G~h?2TB%j#jN_q>vk6pj6Gd>wUUbs98k9
zhojzi8*+d-norUk<~=*J&0(`Gqpfejl#;QfX~ysLpK;$8IkY%f1;4g8>r+QgBd}TQ
z;ehW~SwB_Y=zd6Nikph>$m<d^xUB_8b+F~kt6_9A!xrED>>+I;-Whu%yCk|4&G6~b
zhXTw@{L9N-<^4>0Yl6oJpQYvKfbmi34?Gs)-gUe5cP@#VDpZx#xS418+IY>p<_i7z
zqG{a<hle4uIhCd|`yFoIU@l5T!8c(C#04~|VFIGRAbPfH5Ae+59!b5U-rt|Yb-s0j
z!xrZsbvXU1SZ4M_XN-kvV-s69__&s;kf@Or0~j_#SCMj@vV>Y#V$fF?jcucy9rVBh
z8Za5xZ|w1v<_h)EsqHPvg0yHMHl6J*)~TuKm&}gY)tfBSwA!49U_Km-YHj^^IjmAT
zZ|0~|VAh~D@oJ|wM>z~TXpi<e<IlAye2R{S2Y%;AQ#!%D4k#-X6H)qPeEZfvD-Zs1
z%#Lj=NsH^^MFe*Eh_@xI6$L-zWsghwUo2g9RF&P+C6sQI4hcb|yF)-gBt%-eyCp9v
z-6dTD3Mk!qY3Y{k?ygJo9p2x!7A#o&0X*k9=giEWz4wI3-1$p1S7ZR;Igr~JUA|P;
zuk^a+xHzz};Tl&_)>C~VZeL6sF7^QF?bFKzXR16ewJX)~6n4b_YiK&6?FnS1av}m@
z9Eci)9=mY){ZkWDmH(^1;<b`KI!Lf1nR#cPS6;;uq)LGbY{!7UL(fvia;q;xuZs<X
zWU?rGHI&|bPyosIwZI=I#@F%DinStLtO8}(Aq$KPjA27fCMXU&gf+s-5G~S1^*X}%
zl(Owv@7wveh|y2yh%IGMu5Oh??S75H#rsagh)_3lX5MwN4MxflurB(TvI&L!c3XWk
zpKnT;RoBZs%y30**&v{%tfRDYtIO}-ub_jFJ`euGAfzJSwn73xaK*-Gy_m@9DjaJ3
zmg!uAkin_O=4cUbHP5@EfWPVWgtPX<T$9xRa#*K0{4yrvY(X>eTApie&b$CzT@4BI
z(1eWcE9AKl1uQx`<^VuNrH+R-2H*Ar>BGzGdXOEyUu<4@K`tQHxVFTT&65%$Cr8I)
zWN$XCrQ(Q2rNj<xI4zmz4lbLns~lprw6V--DDVXm<3C|&K!cWjKCSd6jRdp=eF69>
za70Q%D!p4!{xgz7@$`M}3HtaaWq!e=m7JgDo#Z!`ikFug;~Ss;eQ}yx6Zeu3gdN@j
z(*p5N2&Vt89}fXAvKEA?a(B(}<?`@(D;eHXBMsMK&gKamx+5BXf4JB;^zywwa&;X4
zPWuv^aMg}->aHbfR0N$<7=cav!&6pC7Lm-K7Fh}v({U&6uCX(bp}dn=7WLp_7=DQF
zvY9J*TKdKM_+6j-@YyLn`qdJ_(7HVqCMv2-mNQ2F3>Gx(sZWsUq*~bF&p!nx-%Hb&
z>2l(}g$$y+W?3Nr2Cn<tzk>C2m7(Ce|JLsHfy~1)#LnXDC!Kk*_uhyJ&o5M7j5qol
zLjCXjC)O#84x383*?bkPqT<-zMAW^@mh43Ku({=$oQ$coLUzA(iLbTe9lTTy9=$;h
z#>wLU4kQVo!(>wP%W|HG2*N4{^=FtU_EQ=BRcAbaef4ya)mGB(p(I?pk0&Hl)LQdH
z)R{q(6Cd0U<D*6&$T>3us5)-ONma(YX47rf=gtHnHv%5F0yPeNX;-aR;2gN@uMn;f
zjxsxg5@RiIP(|dLb`UZTU7`~er3OA(fWOs-=V1W-x|PG!Jw*RF9c|DW!%)r@MA^9P
zL=x0C6g?l_3lv(f2?}+^KR#w>nZ`QlpIsR3e`B1!8QQbfx*<r3XFZuE9MOAie`<`N
z>)i_tUU|HyEJnswx=w2Oe82ipa^71I*L87}(Wh)U7{ra`Pu$(EiSd=Sag%v2t-(n1
z25f-Kyl#L?8y)fr)UlK38f-sGPtmJlV~7>RH+z3fFK&XD6ALb`zKXp!gXPLvlai3!
zz+A0<zJ>|mrZLfJDREPxP>J>rM0lGgzT4hwCg_@THJ`q&ztYoQ>E7IvKJ8I@Lf1fb
zBuPsLn_2qnW5$uT;Dm-BU%x%(4p+s^t7LC43SLlbtr_9O-#{Qx74I#lvG&?>23;#6
zp%X(S#Z1}0_qpX7EuL=*&xJ2+E{s)8$}64eH5)5>ta@njS%TYd+Bt34;Pkn*K42;w
z%ojm(yIGlOBYkaWyH=LK^8ZU@RuQ^3OLaX!Xa&5;t3h6T_a&%CZjQ%#!(&NJQz&-U
ztOO)2{5vl0K$AOLzi9ojSTfW}FyXoT^xYjXH>|?8K&2D%l*i^eB<T%CVJCe~%y|FM
zEc`QyVs9s|p~wllgP5~GuRN|V|3S`blKt)DDd8VIH^1XKJDSrW!SaAW_o6PB;P|`y
z39>m&g~Mi9GG=-`z|x*$3*>S*X$qGiCzcnJ86JGM(_bV)V5oQ=r_05O>wA+*C*om+
z*^4XjyQeUpsT(MO{nrE;`I;*cwoyV>XtA;BO^j*Va0zQrI_e8pSk|{E<&ACT<lKi&
zl$#0C*ptu8@ny)lqpqkVkX5!%PO$Yy0(vo0*@%5_{`3t|Rq{8w0%MJSfd9-idhj>H
z`+-VKa&!Ho3?(nF7530z+@T2((#ye@8EG}H=a(h`S{v1NIE@Nc5M~)6aGS*$20&%p
zxA?MD$kA)vwaMXvtFw5nqbo8#+-EH=__45sU~Ykisa^Am+LN|;h(K*p-M(Kqn<k5A
zuQ~7xt2vj4>l$d$?x^{-1i(XnX?Uvah}247oqkdMIf&i)4uIr9nF^?&-v|ftz5k-U
z&ALG^*3^7r#aZgQ#Xha>>X0DBIm+O@w{S4eOQ)}pnb1tJ+SX5$99`XP=Gt6Jzx|l>
z9@zcqyF52mDIDLnydr&ISD@324H`5B@m?v>EdR<J^S!hcgRrhE^{YfD&wPkz`SF$5
zXDO)|4(e}!Rb5nbxZ`J2G38)<=7CkBC$V!<G&Cnq$N8Z{n#1i>1xc}Cni2MR{vGs<
zSW<<vKoQnGv#8M4=0!GFlVUViJEo!4ksX=kXug&YY(F@RcfU#vq)V)h;NIsER+n0V
z<Wob>txq<SoDwrCsFH$kgYta{O+e@lKJg2YkO(%Ic8mF=d9=4(T8&-)YOm;1sR>6%
zN!f1O5ZZHl)IspCv86Ujjh<4t8X5AQvn|$}>1NX$#4NsM!@w0MrLWsS)QfFUK9dZh
zCpxQIXaCba4h~gkHXZIWSwC9(2+mt4HpR^Z@&){%eqGG+bMyke`mjELBTv#u7l17O
zP~UCN2GC&Cqn~#G<$!c;f`hped%|;iy%)~|Z#m4xG5ou`ancCJ>UYgt@B9dP!w2Qs
zm)Y=;g4s{d1P~2JV@Xc2Rg@Ezr3XWwTLZ;Ht0iYV8*TdcSlpjc5wu*JcbjH4f@A>f
z9P+!c>Y1q~Px`lTX2p^AfmAqZfZ-nzmjfC+)grg`45?<3+L%-{jm<gV=Hl6_znaoL
zvo$HXT0EciRNI;-vdZi(=mWYsIXt__z#_}LX@AS_r@%=C==H3VBC6L+_00Oj*65+7
z=o-6ed<wvGo-XS1o9mQ2jT&oWb-A0}m$r~p10pWld6|uWKDpOt_`=_KNDX-B#nyd<
ze3^M_rmP(Kbv#dD_dpo9MrgkF$1a+R?YvN3Ojtb&x^+lS#&5;)Ze@XU>T_q>e+wN`
zKoq3d@*Qzct<q*EP5aD0%e~>JEl8+Q>#gBIO93<)svEnHj}4v*&D11a>bu0W1>v9t
zu4e^8!$X-9&&ifF{VErp*TEk9iAV>JKdyctA@HkDs`Vz?ZYIK^XO_+XHTrI4<!Omy
zeaccn1qFM=Rw<8V0x?vEl2pDc*?bi#F!SP8RrzygW&)*?{(|Kf5(Qgx@_3PuSk5gr
z>scmn*Lv(IU5Wz5YG-!G2Qq<l&DuqIAcZ5-XbH;I;#E@D?V7CBGufLfjpMqb28T9%
zfFTK^AiGxhSHrKHssy3Ry$S{kCjLEkZ-SPg5!m15B)qt9(HjFDp3oI}HV{+2C*J;f
zxWr&ao-bTZwdN5A>Bu-DwtjdtOh$(#scm-)JGQn3Eqrhw$1aLasN|L)@ohi9!r|dC
zd&+=ZgXM?X4E6u5X#NLvy<xCV_-ecuRRgaj>3+F^1qERRHAOUQx!!5vR{DN}wTePW
zazgas!v#9)QyY-_2wMA*biPp=sUE^O1AUtnXGE_a5g~_W*jeQkBp24fD#NM*4b=M)
z*@kZjBwR=xYy~W~w2xxk*T{u$MAX8e6@frJI$ik(4qPD?xw$<=`0r1TQ3eS3n%6j8
zO0}gPnin#*Fv3ENuOen5lG)P=)>Vdu>%9And7cC$fLh84%Pe)WzE#7r)%duWsq=zj
zRuL@lvw$Fn(f#X)%*L3J<i(@WosZf<;j2Nb|HSnabg-(6t3ky+&wDpM;%b;|rme4?
zRO4{`A{R=2+fAu_UE4D1G9cVCwSJ^{CC`iN09&9~7@lOqn1nh8<j(a0orJc_<NHpN
zuSeV8Y>uGMTSq>c;t*`5j4(d+=H3q}8-E56yY4{wf!38Z*qkTDN05e}6h>ezGkK$b
z)H_*d+%l*R3rU<EE{r$dkO20`hn|<}IH2;m!X!RT*s`>;*aEuI%OZwO-4$KD1#2F5
zx6c?xo3udpSmdst3&?u7DZp945ND0x=g8!k!b&zt1xzKTu{JId2^mNY?ahq{N-n*K
zq7bWUX9Th6jOHc5=K5AuzE-U&&RPyS$(}dA0K<UcVj>}<Lx$Ay&kTqfHBeaM?QO*}
z+E};T_5_p!DxX$)Fm8}peYl)tHT-MB{pKN$9M2zbm~Vh{zVztu2yNNYDi>gwPk=tz
z^TWY~!FTThmRzh#hnYq3K_t2|B|zpSFyd%yf=I=PG(gljidk4_t@h{uyU59_HdE`r
zt@pL<@6<vkSS-FK2XaC^SA1O5ttI8jq+~g|Z(9R&=9j;?Y?c%zIDPUR)};0+J$>)}
zu~AZm(|Q0PqCa2vFADGg%!X4DE{j;UwQ0L}Tl;!aLL*WWBtN;q2G3#^H`dHv8)<V9
zujM!h=#VXX`jS&NeKc9zY7JF2kbls)mx|@`6p+ZrrZF(DYX1@ZOj^>R7qb>LH{^|d
znu{y9cpzIY6|T1Q)a)s!;Uy-W5i|E5fuA918T+&UAh&3wXb!|BoD@c!b26A8gqhEO
z1?H{T9n4@(LefCDA3&EsZ}f&obvGANyYMI!051g3dyiS;o4>Gj_MF*~Nu{ei6<nnq
zrNU<C;nB|G>0}{MP<RAte5iu_(dAjV8#-Wuk#zXhNHGnmnOi+G(#Jdrmk*;intxW|
z>NS+et7|;U+w9~`Z_jsQJeT6zT26y{*N@Ld3C?NduyTtdH>TCpSeXkmJbpL6`_aNP
zT}SpPHA2W#QUydFwOIbp9*5+hd-~%VkpMqhTIqB1;2KWWvg2Pj=C|&Fwzh&DY(1iN
zS;I+QGDC|C8MV^+7<AMQXcyJJDoHg;sffS$gEe8NxIiKm!_N|TuC#K6be=6LalgJb
zgkT&+DzRC|u9Ebk(sl6dWwDlovl2XGmV2ChDYUijI*Hx%5aF)z?5_`NO_l-CcW(6<
zog@hbFA9F=dgD2#-tsM_na|FXYu~K>j01kgQp8C~$&e6dTl@_E8Ap_CziC6J%>rB7
zv4D=aM1{#(>Ut-n@-B6$9_h~ali<s*XVl`?7_)Es;<wfEQXHvIm*<2GCpC5~50H)#
ziLkHlJ3E&jfEtj$$z2#ONxN~Hk;1if&s=b=z4j32$dm)aE9sU4P@{o;2C(b|Cb;K|
zfpa7)yoiwMhKfxw-9B<`qWOdq{@CWhOqO1nF9!sFu%0U=5yG+HD^z0t^3RVaZShr$
zzx``m_bcYZyHfUPJ5IXzOvf9<BzWolQR`CKoSX?LeG;nwz_KizBth)5kK;=6>?L1R
zwcMIUKi8jG#pZt7u6JQaEJ(LD)C;bHBAb5Kg6o)HG6*gwy2>jB{BB%e&GBmS@v#Ob
za$#?1$G7$+=!ARWUrZORPg{cz<2mc~t2$A;ySSB7_Jf0;g0sEmPBAO?F^Be#q#Iw^
zN03TtCpCWykc9}d!gXwTpNq5|NMcyM;wnb9+Z$Q>=k}U(@96n*-0~I?;gxQ*_Etwu
zHd%Q$+na(ot9Wd$3;6rwwP5#Ygbt7U1`0@|ARO@S0MgCO>MDJ{ZqghglFvg4q0&M+
zQPR~sv(rlUFOd;S{;sTHeS;tT72(p{vHg>K`Yv710ci(4Jt$PddDK%aMZCCU!APH*
zzy3{81S;<Pfa@yHofGbZP%^6&DYbqs%UMO19^>ptm8D_g-Igfur98P|#EFS;z#^H?
zGTKnunR<iyaLEWCiAKCX8BbO0O5M{3A{*Z;88zrZeVl>f%|m+4!+2np0<mVth$BD9
zFktN%Rq#j?ynBv$oFoziKloBag&Zp<d%E<@<*`7GI+z>p`}8+ng`LHvDqrVIWccJ4
z=WpZv7q?^gRBDipJulr_I}dgQLr+M3q5i=1X!`MK6)0{^*fGfDoq=y28cU<KUpMUi
z>G#tnZQZ*WAApr-w791i{9Jbu7+SGEFRbYo)acK1Ju6^vYSF+rwV+|%qRELWZnLgq
zyS~PCIZy=!C!<I&p~zB2OSPWeuH{^{AQ{<wS=6wIMi{gL0j}kTKApA;ztN^nkk6+P
z_o>gSW1Zz0pd?a#Z*$%IV}(@T;J8jENG^g}gr>)efRsc=)D?6&?YH6PL_DLLyddx}
z?NtNieD;mqzmjyBk4Go!)!;;`RI6n1baKvRezZ`Y(H!2hJE38w{jVnsI*QL;8&sZ0
zA1S-u?-L&!jF(=2|Ffn06Nu{eP@b-BZP`wpT6{Lsue_@B_m@SCCTnx<K&MAKJYE<-
zyi=deXaj4@%39tw)9Oj*ODSxb^C677eVbw9x=}qX#8#@|R|Y%J?j>DSm7_aG?X);~
zo+Y-u#Tqq4N9RNf3Un%~Inx?I%PV|XiXJ`?i_g`o(sBMkleQ=z^#Bh`Cj-fZa><ZB
zNJ8X>_@_l5lK=P!OYg08j5l4<ahJBdKW?fAi8t@VT9@;Eptq=nXf)q&jg>1<E^p$4
zC`f>*ng9n<2=<ddd!R|>=y})B{6osv@>T5bQMu;H9~EVOMK&g63u>}PI;6-v2~PUT
z{GdX>$iVB4=`CMqsMScq_>m=uAH(5-#$c5HDb6{d_^3(ha_E3;wkcLZi-+B~kBde3
zlpA2MLu)?|FP*;Jzp*La1~s;kQqq2d^*(vwSmwI`y-thp2IBxz&`h4ouW{IpL%*AG
znw<Q6dpQR>O&kY*4~6mMMMMHvbmcmATvyW$7tr&b)V9n=nJE6~pOYKhM(Q8$!J`%S
z3~y}L6vN3uPh4OQh^o?a?!9S_V@@DjVHp`GwWYGUC5W<Jkl8t5T17JP0LjYK*s}hd
zH2=PydcX<?o0eQeW=3Zx<Jd7K-wE>6s>C+;6prJ?1eeW%>{Fj}?FMtaRQvsXpXya4
zg?y(?Enbs7)uwk-j)C5WqX2)IH@DWJN5T!r`hg*UT!RN{?xt?g;M5W0ko_U(wT$+*
zNzx-bovgkCWagD^vtJ-Nf9Iu&E||DcVWi0dl*1S)U}-;;Um@?A<<$a^)C3TIzg6rT
zJs}!V8E(yjH#2lWifMnJo<->JoZ(sVkecJ3BOub8q^|8(A8kz8J=_${@g=jx;(WKa
z+(z$zB}|(ESQixDKkpUy%8gW7uJD|XTB1kyGjpv_vFYzNOL4vTiZy6xgtb?afD-b6
za--tDgA9(2S=MMQVMkcNQh%***x!I{eRb!HrV0|!g2ti)i@C0log_#5jxV6G$y)L_
z<KsSvQ+o)Uouoy<AxP^sxA+PdBSIJUv4m7k!@89?8Zcj<DP+hlkN>VRHBq{_JDXmD
zWF<l&3=gBaOpj-R?RE{ZWogZuqnJ^D2kq<mz=QHYAMl<m10gim3{#6eps@?Pa(QN2
z8Ty1dVTbE)4k|dpR2+@97=WsmVYo0~s5EoXj*`Yk<wXZeD7~}sGt-ZvN93n?z=^GX
z6It{ZwP;eY9kdT{-yJ|XO}1F!7ZBcUl$rR>Pf5W=hX>SmFSuVA*l%hwh?r7-mQYsQ
z*?HpDaMQjNwSqxs*l>th2r>7jl+W73xoj8b-5Za}44zOjDs`6j{k{9Sd!nGW$zR<w
z*B?aS2=&t10s<|BJqFwTZ+jQ($>V1Rs?uzaMy*2K@WC3|+V@7*IvDpO0Zjb0-4V-J
zR|M?qhlP@ooD}C$vb^O_m~gnLesV4B@!)B<Jh7Gr<nSmU5y_9R#{#c4OiNv_$jehl
zfE1~}&AJw(Lf^y(ukk9Ha>-7jx|RdOKV3&~`f3(kWxakW5{8at&{xgNX4>|0+SB9l
z`Om>_@y(wa9Q1$3fMRKS%Y<y^i>$k@@Ju6P&!Uc>PYAX|ekZ%9r4TMEqMNxoHrN&w
zc^ojD;UH_ryc%UPe5vCaS;PJx=KoyMwQ3yRObj)@bNS*me|!D>_L*xC^!tw&e=7de
z84O|m4EkkwQnSH$%V#D*<9yWo5eRBW6SpV;*e-WG&ky=lf`E#8k+P-wltxPt0I!kS
z#AI&?I-||ZIkJ27`pp~lhv%)^^+~v~G1IwI_$PFrslM=vi!QM|NvC&<lG)^*aX41M
zk|~c>^R$W8fnR4|Q>Ui}yTZb?u1sT4u7M-6{7kv*Yq?n$3Gs(<e{4MWC9m;PUHJ>}
zk2I}0?e~jxHSZgF0&o4*8ZA`KDwN7B4|I<&0M#ghoM?t&H4>&ApTNvk6Q<Z7!mPl(
z;52M!hmLY$aK3LWHLQ^Lr@&7_OP23OlVR|Z$E9?@4A$pq_&*U$3cis7mQLc?Dj@5X
z5vFsL0xIF)f!Q>HF+!)xt>Z~K5%t?a?eF+~1*>m9Zw>3uPUz9_&^B`h@R4C9Zm`hs
z^JyBCkyew5$PE^j8ayr|YRk*RCHwoMHa>W?+d*Gu{cL_|t<B=^TuQOB9ApS*y1?;0
z-1PF!2-LRduQjF1Zf-a(ZnQk^Jg64|H~D9poTewu?PSppYTmStv`Kc)E^A=L-1hc#
zPxE%n;O*%Gr0+Er>e`rAaE7zn_BEhc1~6&M^t1<7kqJm%^s^d0E=zpDCeK;V7tOsp
zS;B8{V+YWNuU*il<Ja2RiqAaFH$u`i)^M$sX9oN2j47Uj7gxxTqcGdp(06hzBJsb&
zkz;F1!#cENd*;;NyO(5~Y73Gs4Nx0db9Ll*#d9%{#n;=Nhn?q1Nz?E<^V0*y*k2vA
zJ#-7+p{9-C3FFuNwAWPznHJd=&omHw<|^YcLI1#g$iY!mTVi6;Yv5{@93zdVaH;9t
zCbM>N@l!mUozl&BhaC>hd2w(&(JI<Y>XDrEm-g80?3^lAvygj$fV1}*C`*O_G6K14
zV95u+v>C3olaUagh+uJT>c#&yTqm%J?VZvd?wZooU)y7i<u~~fJzTrXz>*(MPPtVM
zF7KfJR#1_>{)ohR7k5QL>bTD9SqI_Ufwd?u%-JcQ^%e4kh5vq-YAFDpK<1KCmS#)q
z_TX9U=Hi!L%xvv;t+%gPj*(Oev;a~==^d|m7o}uWs`C2<%?QF%fT@RZL}Xs?V%Mn6
zFS1!}ac2h_&AI-bSzRf>U+u{20)Ny^Jg1?V+EQ<Qu`4_5zml!5*_bpK&I)cPdndnm
zJB2JRV$kz4bE@hI)D;FqpULu-3BrQXBK?`H$JVX>#jP>H!`CjyBbjc=h_YI`6cctW
z5(|Py%SDAwOXk&hLOv8LdW|W*y<TP-+bvcW_Q#`om!DI0g8y2YJ_yqgaW%VcCLC#1
zegj??ph1}Iw&4tQl*hFLPNrj#fGNQZ_%8u~tTrtArSJP+UJ!lH)YL~i0WtG);+pP*
z*T@x->HPN(`sPOiRFy%&0A%-iN?x8W+}j&ct|C3fe>FB-HgiF*h0>R;O4|rtPB31a
z(}S*MqlkA_6ZYb({6T1+QC~s%K*Irr;TVUI_Cg>kIH~(hFS-Wg^FVX}q}rZYB`FE{
zLP)|`w9^L)inb67RAAT9Zg?OntOgjCIYBwf;(F4@g?5Fadk(SQvGfvp(}Xn+C?N-q
z1)yh$k;R_Yrp#inC4E$W0Oe)qA6mW8dq{qVpT8XP@nE-utPJSCgH#J;?z%;Lhx>M$
z7E*B(uOfNzYK&1Qx0}zThEk>()2^3$g~t=QLB_ffhAbT)Lp;eiWou!r|8I{K!TuyJ
z4QiU)Bx47RoOYym^h8Y;J$U;w?}W3Uw@5UmgH(JucFzc(v?ag3W0q3>9o_BhUg|4K
z3uZHROqbqe*JOG&oGE|2Kl8NXy!LE>NFwdBg2VFhf^0`@^yWemsL9*THVt-jq2<um
zfDAO*e2i@wwh+z*z%aJGOUMV(e=P*ZAYgaq1p-{Qy^0hmzOpgSKP`+wNL!+<%@Peu
zZH>~}X#4L;M0)0kO-B|);v)pT{&HS9$bEC#si&|%cW}a`%Lvf9&=drUYgqva;?vRy
zMd8HeT0eO89F{`}JT2E~5OvnAtEl1Dsz_&>NV&!nwNi@2eatV>l=(oG_#5)*m9DD#
z3?W(W*--kstEpzGk%5$CCNCcrQ-Ie~KDc88e;?4?tKXe7f;jsXFxx?8ouC=OiV9#r
zO;aU|tMVZ4YnUmssGPp<m3~1f+}Wj`xpiviwe;_`*DnA?XEl2!uL&;P4!$-HVuzKi
z1W0;x;|OYrBaALx^C&I3#ROgK{r0}#CgHXHd0lDq!fW%88>4<#ww-{r%kIivF=<cL
zQa0@BJkTcw^n2hQsIs47k`Br*-LNz-)Fu7kt(a9P`TRwFbRb*)FWKy8api^HKyzSS
zM8q!a2kf!RZ```W_hu8nIPT}$&Fap7y8AW9_cJgrgWv{m&W@|yY{UJ4GHG)GhS|m3
z6sM?nM_=D4YBn4e&DXS}oX1ihSf0e(ZaDEV7HcR7AV#dYhX<|-DWvA15kC#b-*nw?
zMWY;_%C8SggLfwKFegG*tU!(LUw5iygo1Vi&6@htj^N^RN(Gm+=-%Q@VA49K*i7iQ
z`#awa$VnNPnN0?g*`MZH$Yl!6{4@DL2yFFCm)u2JAJ3@(3fZ6hJY0r|W8j}jhAM#Q
z)gJa<MOGIl57Gfe-4IZCBtz|~u;M3Vfzt14Fu5%(NzYVVp7{dg01$V6Zq_E5L3Gwt
zK~KIX>EHUF!m=Rj`9OHUQv&@-t9|WD5f(E+VE*QSUTV0?Jym)0&p8=+`fYUf=!3TB
z!7Dnw1keV1i)H(k&d2BFU(IS@Vpy@_%qWr9$?oWZ00NG%ZgjuB5}<O=&Ofm|{%HLf
z_RtPdlmSFKR-~4I)@P-<^_)P{ROoZex#)3u1e_0Kfah6O^Req?@pS;d>mxD)VdTlz
zPzoa=q(Q)k1_aRQB-U=e^3QJw(BD;>;=0`9c>>0~1f#m)N7+;B@`dfzAnM5$j~7Y(
zuN=&Yl6(L!@Bs>|7-z!}@me{mOIP5alcNJBO1h0TPY%21Wne5&1`wx*JejI8DCZq_
z;w#$Em?Sx@_uv{DR(){QdkHkHG-iWqtqrP0UJt~!*B3`n+XP{dD^*ix6@QF2BElgc
zZ3T33ocLMZActz;80WrM-06L*#brAydC>ULLIaxmL_ZV!8dA~iqj>x)2@gc=cbsPW
zB(IL{NLUDwCrb@F7>7qy)X~L&&5pLm*1aSx?TS60kk*gjl$J6a`6q`io+NvFWp>O7
zU{<8n(_9_cnHS7v=z-u*-?_ZzY9PvsmG6IdbN3&8!!+J%Son+wi@x)DSH|RA5^gG}
z?<BJ*R!MP^dYoMsI$|UDrmuF-R9<eLZI=4<#W4I!cJ77-NMfe9K%(OCc15mY8eErt
zG1KRtxnxywwU_9L_e`i837!c25WQa%$Y6P*UOqU#hci|PGdU#hD4+I#*%<>rp!LI<
z&>6#xvALrIFn7T%&F=)QH~ju2+GqXY_Gs&{@d#-d%rx1|jTTv*G0WQM7JVoWE{sQK
zzuy#msy1Y!$xW7KUjit7<lk#&OB-9W!L#6=#RCdzf&EoJ(?y{dX{E4Bw)99K^#;tt
zZ>EDe&^(|z=`Vo5biQDb0m+2yu6ju)-plvf6YBUL7phlS<g@vDpL|kQbAvT+=a=3H
zAL_bM19jEMqq;0$6C<RZ;);d_GaAeJN~fJEwUTX#Wy?foruf=~-=)uS-`bNVeBeWQ
zL~^E>oaJ#+W?^>mN(9vF`NeZS%q`;R^3)>0SWhRp0kkFT5A>~*uA4lWtd%qEAX$E@
zyTJv^(I|QylAC2i4Oq{4+7Lwi(uR`Zl94;r^oxt}QjK?jcl58yOOWW0sudg~aRL_F
z{hQZU(MNh`9xVm+&5;|!`}ur@1afQ}yBKs#at9aPd*)UqgHAq(^WklQ-LPUP$@_*h
zgly#M>gp3PF6a!*-f>+t<w;B7wWH9gu|Cl^(F4xLsk5^d&f>~if;_oC4<`*co2@u>
zI<A~)dhUtNtoPvoqxiu23$b<OSbJ{b1#iV>7Bb+C8Py~wJKnzv(#4DJFkUtnJbN%&
z+$=gEB#Kyy<Xv%HldmEdmhHGb8og=@=3@lXFTl6Y@*<e~@$Q*!c}Oc`No(q~sO~ea
zxxML|8+0<=781C$EK&SYXsFWDrCB|C9(Ytp?{nFtsbczulT#w)sS>K;h_Yq)t2;W-
z7WtQKUPDgO@D*`<?r(ETeTfwUG!pcl%B>j4YHm*bYS9)}8B!cUoYWT?f!|aBtTl}x
zh*L29L_NuAv!-v~2P<mfJ1`sWjt;kjCJhif%^bHcG4MP3%G)({HY=(-_7=n9cuJ0J
zvya~gb-X*<9OUx8f*;KC4jTo=AKXi!_^3^%ZxL7<i=38PO}lsOUY!Ro&F$tOsXgAq
zfpa+R$vn_xM8uFwJ$&WX_%CJlu##8rS4q+L)?=A2ZD)y=JFh(~avL)uv&=@O`{3RY
z*BPU*@bC|Ea>n3q$z=#spItr;-zd_m1@PMKewEP|EiH@tc1ryJ*<>UnBs@XEpIY*2
zT)OT&<V$r*OF4*HY~OmPZP&<RA)8ikm}W}v5ign=yo<-Al$(}kSwy$a9iMH<LSSN{
zkMF}`=Y4d_`%d1uDR8~ICMHQ@72j1(<-p{!)La|N8PwKuBcc7d@}+3ft^11p2wP2n
zVs`JW4<y+m6F<H>=tU~g0^Y!Kmqt-gBdlp*yz8WAfh=r6+`^v6bEUezP?$*FimPOj
zNZW?|u}i-y*uIZ^<7?16(>3-ybvvq_85FThAC5hmd}S;2Giw_i10sy#UNeO@1=E)Y
zbXCRWXCJTI*ozc0TW5css64}na37MG9nfA}_s6EQ9AH_*w9f5YO=%IvwVCiN-j-*o
zyLz+9QGs}SnJ5S~=#B;x=B97MV`dIqfH_S;Vd37yR2^ch2g+^o(!*u#|3<<z8~#N@
z@NhUvSEJwV-YO)f<Fv{(b(A;}#IPDzwLfD+yMy>B!NtQ@rrF4uJNXPd7AuHgnCH$k
z=5b%5<j=HEUWHGS_~82449YRibpHx$BvN*Wh@Gg9C>q+>yInLg8^D>Qi!`&kllfAV
zsg-b|{k~ew(PF}5RcnDXLj6ke)M8yu_Fkw`UM9=fvSVM_Z>AQZQt`Ui$LlS7N`?wz
z7J?QTys?^svD=Iabs9d=7ygv&g!tbz6P2Q6-|j_NNako-H^>W5FF(-XYracaNBYTL
ze(BUTaX?jF@2iETXJ)poQ4=iRYH@km!XMPO+(2zga9}DmO0k-1DbS*FKsu2BVND}m
zD03}4bOhT&WH@lfcZXRmuc`sk?o^~8f?}RKq3i>}@SjQ8D_f=(e3h{8`%r0UrTC@N
z6f-kfX>7c_HSU}b*tvYt(jtY2hi|%=)Y66=RA<yKxo>5RPfnf!+nEfPh}v@;k|00m
z?*wkENj9?~GHV{zM~MT2G`$CUWOY`0TDqt`?|Wp70qCTQ4fBDuCwus6M>U)_7i;Wj
z(rd`Z+nlYw74w$mOD8pzk)~DrRM7{b?re#S+BDDm;|v$nhqKK!K`)OjHWs_l$@$K$
zqvoNu2}+O=fV7;B>4Ai1lcm!W3lirnJ$Jzk+O6v|Ap0GrDHRFUhOk^;)PLtm$aE$}
z)(dB4X#4&1S$-@*x|F31NvQV+GTnra-`PXHK_{we>)`<MNUQUrZJB|+(=5nvx1&W%
zc*oQGa<@-*`n0d*&3rAo?{WbVOZ|avoOJY2<mcfO1EMNQVcE03mt3XVp_OH2XI9_}
zzcbYdd(2@x&Jf!8Mo_aG-clRMU2N^i5FR$~0T(nJW;UOrGLWd7$$Ax7)4x~|g*hx7
z2^_NbC~x(?QRhOc6PxpL4+wO4uqm+z_EfPAj&?|g-`;<Zj>g8PlhX$S)iV4>HXO@6
zE-afbitRE^h`_)nPcOwIXxWVQw6$4s_?W-AJe?;q4$1b^-qfMh=DZ89yI`#WE9*vU
zg=>mOM=^BF<?@fIny_=s?y6J~59iqt@rSOu=11g_6?<*B+vj<$h_DVs*uT^a|N9Q?
z-?!TmWbW5hMVb=*socq)Ua0Bp88Q7VH0GDqOz(tS$lGQB<OYP1PdWIA#@b?{{`NTW
zK*O5uH=3NGYoUcP7u_C{x;GX~4yEhvh7L(lfjX97tcE<alkKK07~S)N^Wt&7`_6o|
z<PGXr`9TYyG<A$_`&3X^cYzQ9NE-1i`C)g$s?Vga*gd}pb+CrgziIM0I&*6t+A?G1
zqVZqPdI&R`t0~*OHY+G)+KQ+5{<!)5W3ty4;xp;Y+hNZqbGgY}&FLf`x%=*Zi~hlb
zyVTy{=pP?hUmLH8gCwGJe@PhH<#hn#F|&JJm?bJ>Wh5x#O<=ktlHP_dRQb(XdQNjT
zb^3BM98RurMGa5+v(RTny|GajFwm0Xx_%E`bniY87-k8dk4Vgeqal~h7uy?8e+F{N
zk?HB_`rU$aY{1MKfWqD_KHmG3uid-KP)?l{iX?81m+zO}n%C6g;_P<h*hL(2YRR7S
zEJb{Ub-{pUy*L=#NbdplqCe?hVv=;np9#QJj_ft1vA_BHja5qwr1cseCkuVMtJITs
zdlsjc4UmuRtE(xHVgH|zCnbw<izA!XG{c#$ePNmP&h>irkrLwi?O@GK1L|uXw$Ug>
z8G)G}hocmALf{36we0}e7+0??JMbr~@ky5GdmkH-oG3P1ATy8%&nD8C28s`kd~NaF
zWCv^SvzIO`kZ9lu6W?e?m^5#XzQ)>elkV}i5lpZdt#D<%C{$N&vAkfIlT7yXL`mh2
zkLhQn2RU0Qsp?2t`T<K#6C_=@5FIY$1Ey)47a=am!OY4y5QJ`K`D9m@$4*Dc0k|Sk
zdJp%62Q7fY<)1t+7|YcLMkb0|STKMwg(kqL9gGX`XyDp01%hS{Kr$eky<%X@y2fAO
zBsib022RgIf3~nzfnBE@+G?L&l$zaNezp|3D@@9$rQ;PzpQFYq3SrrM`Ye60#K1xF
zNmAG`Tm607`k6wi<j6cfDB&ZSsj{Va!623j!2GfHIbu#fIMA>LCNU72_!8YQyQGby
zPfKb`GyO^b(`WEsk^!)6xH-~)M)r%$tOeA|g33a;AyPu+GaF|M!NBV&%+;$BG>~KF
z@f9XEd8w`+6jHw$4>nL<BW7pL95H9UbZYjzyQ@FHgb?#PVHG}{5Qarl7%qfAt}i!C
z3^YEb0a4H*%@p_StoeLR#*Hc?C@+F8!{Qlx0VM~)Y~a=UX&?oq@G|r6+f>byXh3qR
z4-Sb+NgDvZLuDGmkESwS3IrRCqTPno700AYd)2&nk~e5z1le)1o!4HGgyb)u6fc-h
zOp6aT_uuzK5YgbmlEcX}Qov_bJe_XfBJ~B%xlDDg>(A{<gmJ)*xC_GiYq$L=r{#?N
zOJzlwPsO(z#l(N9&JkUMX~0Y&r9w|M=qO|bET+Ur`pi`%(J1rBjjjEMbnamhc`%s^
z&cdjRb1SnHpJIx0<sUvq$B(ApO-_}UQH#y{4g0JMT~s3k)5Mp}S9YK6@zk(cgbXi$
zhlwm1fX9`TXM3{cUz06<5m(kB1>UUXz*#v|qJx-U*zdetNyElN$wMSZ`QP<y?qkP;
zqI&tmhL2KgR)3-BBNgZhbwy|$wu^4}!@`6JLGca{hW{kjlf@kqBO}+`PWrDviHXPM
z$^vRNL)7Nuy$j?Z1AB92RMMrs_R-Z&fHlqw2FHtZ3Fgs{tE+y#2E?S&kG4&bfH;J$
zPP^)L{#NNH;WhGe&PPAH@^jagyvq??*(eG+ll1~y{@N7|jmKG~%TiVZ{quC%Je{nW
ze8T7xy5^J=Ni$Qt`(nGX)Od-G)avn49f`9cohLffUYmr9$i<7vI==t0Rmc$X<hndF
zh21Yy6P}9G3XwSsG2k9qdF0_c(3^BVBRn&!bMRuEFrBBC70_&vq&qaD!!M&nZ2nyW
z-e=BzF0`4seGQ@BxK|$-AH6$Vlzl3H9zSuvm$rN(@Y&z)M}mR!DzS)gX3w(=mJCMF
zKq=rye`53P={*o4i|G6Xls$XvIReu~7i>@^3m;`g*34^@Ocv)FEO?~W*mc|U3AC7o
zhCK;lzikb^2F_E%x3Kyas{#vygYe*9(e2DBGSN5RuVGQNeC>i#KfhwUbmpH8A?FGR
zRcE>U`hi*(j5qt4gqg|~xWZ}bWZv;b<a+PXvHK{qlXtm&Go5cvr^x&8m8M`{+cQpE
zvi9v6XbbeO*h*Sv)Dd(CcobkCOn_@sOR*z$g3Eed5@Nx?UD_l&$XIHKhVtroH5@gS
zJp<U69)A$Hg>}v>4wXbN0SR8|vbhalu5vz{7S^u^X&s*&k#=A_Y3OGcggrr%>hN*O
zG+sSRx^ZuSR5VTA6e#Hx_YOW{%hONiAHiBRicFCrqYVI@y01D2z~c6mK_GUlsxXs>
z2Nu*gNx1DHJE#~Wl(~y{PA_oq`r46Ox<PNPa`#A4Ni}(x-pA|Py_GuK(V`trLY&K_
zkxp?jKwT9&ZY}@@8%)Fc_`P)QvoZ>xcrDkT9a9P-#m}5cP(ULMh{zT{_jU1Bnp@d+
z8*)3HR1-&JuIVsp9DR9!2Le(94z1)z%B9IqO0ktAdK9?W$?msM<AZrWXij>9k5Ab9
zrE7yEh!B~LLgJ&1=>Lp*2O7<urQmZTSJ!ILP@`yhG6S^8xn*R&A>n4i%3Px{@iGkU
zNecozAmD&H8zr6H|3?ZZN-`H}W!A0EInX+2UJSQ<O36Zh8b&kFctk3h@3BOo31|WT
zzWn3wtjx`4ZDdJ{>x!$S*fKlW+uzwk@%n!)xDhcCl!YqxL9YI-Kky9b75(%V9QgJ9
z;-6e|3KlgP7o}$GZrWS`eFp$;-T~v#J20DM{z25oaH|3~eK*Mnl<hs?q7N+i1UmiW
zuXzE4Avmd~A-UFt`Lrk2CX0y%^)!5YOlkC2pM5hOqBftD^BnsJZAPArC$ZAfygfBI
zy;OzANuy{7M;)JHODBBi`<7|t!!I-V5HiugkY~^jZyiB|qNZ3T#gUn>nt4%t6GM|W
z6%Q<$33UXHnuh<4Z7=8M{|C}fn3}FkNyiFsR3N`ibTYWS_<s<i-TwX?AnKY=m&JBn
z>{-l0)4&;;b#(gee)3+fxmklwZuwK4sAgb292jWCb~f2qXFe$u4U?_IApDE@H$M<u
zl-9dn_CQKiXLt2qcsIo%ByyeQ!9q-!v8D#SSc}{o^CGK_p2^PuuFETFO6k!0$lp}`
zeOX2{NQbO@Bz#S{Sv<G4Qlt2(V=lp((l)!5xiWoOZ0+-CgH^2Cc2!2y4x{Xf^|56A
z!A%$RLz5HOUB<WmR<3?Czz@vkk$GQMZY-=-@l+etq$WG6A{lMHhAg~o0CU|$Zd#UB
zfU&gK9qm90jgU@Uh&s@^p5U|;Xs|Rt5Y#lC;8|sQr2;j^&>s0fSA&|!)jx_qVI;?x
zWfj|`xuKL~lTOe3-PuzHGZ+)4gzZI#Zahe8ZGSo3Bkl6q($-e{bvXa!BUzA0{!H>E
z1&2`H&7C>w8-g_h19a@;D6m2R2@uECM1#LxiExsd*<K1IDIMN7JYd@JbX@0Io4TzI
z6%i!7h{1RTz;XPPYV$;hj5>G&<XeINwc>NNp8#VXZUqV1mVm<Qmmen`@=_5(TyDzd
zW@HdAitLK$yXL!4MD?hpBWSlDYhAZalvKAKTSY5bQwEHOX^r(X5DbD*sKb4K_*(r6
z3#)nY=Wk8U--d}Cmr=v=`%C%-$#RWsOVyE_3Sxp8su(eiia4AKJK!V0F?W5>&W4Bo
z3iX3&oabWcR8!nMzw2hbqAlIo06#3fH$FR!gZNLI{|x#x{L3x5>FWpLVT>Gu@`t+X
z6)F+P{od5k10px!kOU!70C6~F_f#XyO^}v4tLu?TQkTp0Fyl?{kmP8noabd%p~i9F
zUM7`-y3rrY_AXIM|KAm;Bv8ECM{8Q~9M3aK&idZF`|K=!{K<7mG6I6{o9Re!L_ZyW
zzW7dEHWaYgboS=f5*<#A0vEoeip$(i#(xQuSImG*cj_$7nr?k+gC?I2SuoXQx$wO7
z)AXkhJSSA`_K8gqwBHEjH`4@Dm#?4EzEYz^k4%TE>3pD$eMLR$8zPBlo0=7Ix0b*M
zEyehoZ)s1Jk45OXTV~avNgIXLv5bmKG%_6gy&*NtU~nK{<Jdq0i~QS0k5Y&!44KFe
z&Nfc=6Wbg3dRf%B7~Tb_n4OreOMct#uJ7o!45toEY^sbNyFAn9br4X*vJ<InbP+!1
zV;$G)wtcK{JrJ9WV)m8%rbYSqoa;f`Cu#eO1`eKktjgPt;*VMF4QAd^e{#gFue<f^
z=M;S$CKOBd7}Jh-{^YVv@kmhSbRCFN_Eryi_?d=3hlt+sax`CIh}Zr2WM#j0hs<Vq
zDI}Awz-3~Z<M0Ttad{NHapk}#`%&o;xT`&$E5rFx(;>~W8~q^XBuO1L`VkRr<(!E^
z^~sjOj(ec;M>CwNyeczd!|_4w1Da1Ka%U~kDzRNiH{1eTDa+c3UT*>i2ANrBtAiBR
zxQ4@}KC!|Pql8ZVbF<5&m4OG2E9Bqo+ekD>QP{A0tJ((t!gAb1qi%hEPa^qXtXu|8
z{B~2TQ7H-%G+=SN!s~!g#VaRf=|=Qtn9$%hwIzp75FNsEhd$HjqJNW<^~!YGo|XK=
z(JO6)d{~m<QMY?p>Oy4+78zw!D2%pk_{XW^S9LYrnBd~aD<3#t(!*wK_Ku(q@0p@<
z$#I^CeEL%kolk6=%n&5X=2IaBpGth(4~XnHHG;F&5O;PW^YPUvdZ{+nR@X=V_(mDQ
zMj!04rF;5;>cihN$ct>K%9IbdcmCq@k;WWgFl`_hcDsD?%buIN&GGyV(=GOolU8^Q
z#dKe20m{Yu_XUsZ_%IQ853XOG*-Q*L`N(j=nA|;9LdfAAj(;`Us|-S>x+Ol-w2iMQ
z$C7=IaFY-c=b|DL*~-21A1C4z#L6}Mo72=9pnNME3n?JO<W?hF)DG!LL&qgqi}qXV
zh!x^#8g8QCd&@Zb^^T88n)7K%C*$ei^DEzzYMO`K9+?hkTrI>PnHU-tp7HU$MS?Y7
z38v4+M`i3y{@84H_q^(JBI2-kn<rF-;tfx>dZ)8BJZ`wuU7xv<?T71~?6@R`L9{+s
zZ^^;CT&ddP-(f3pS5TgO1-*rm<0+N4eT(Tqmc%3uV!&o@pR#)NJ9oCiAxH`-_-?>F
zoBSvBc!%`RknNRrxL{)B>5if$Y5_BI+hy%zkW&gVoG+Zwv%JS;rOrq)r-}QYB$!`$
z7g2VulnRQn0^8B)m0YjjV%$mK&17*^$Df&Gpr%4oLYB}w5$iOu)+J?Qc*VjRIzP#L
zj>Dx$TTPjNy@-RI@fo>sAqp7NuGRR}zRO-7sb3VQj%`iW_hoPMO*?ePW)Oz_AbUT<
zUBF~1W}<}Hd~L^qgn`l7da@!z_7W|j#`Vryhlez^vJxz3-L1<$-##Hrm1RB=TdNLS
zl#`EJPDrH96f!Yh=raahd5QLIhv`ZK@+iB72xZ7vtj{@)ZPO7|M6x^M&(AE<pPZZF
zZ$)|~MnAxi)zK0#);2qhuFl`|cz$);e$A4EpZ0hvu*=wIfWo_4)9tfz5n3POflm-1
zDPlOj@BXG=I2`=W@}0;fqc*#T5MO(kvr*n3I?sl;h?^v?>~34}Oh{fS3zHH4S>6E>
zq@n@;R($2MTdxEU|6U0;BVW4`)DVdOnEkR~8Di$`CDKRI-)!>+k*&`wUeK6G`&T>W
zOAibYY{~VBcP2H48nLZq)bwSg7-Gch+4<QNB4nxKDl$R5t^C$RKUS)JpbHxkvS}pN
zJ;I;;Dv|q@67`NWue_&jDnsNkyILJqLdXd)>c^zfD3Z`?+Ql`7(%&oRHNsgBiA)%>
zyTSRYps6}?aM4KBp|^qyCM2S%Bwy`zhs|izh=|7-sRnvM*LUVrzIM>EVtm6hpmB~*
z6py4kwFXlI4@`E&L}`Ydh}bTSemK&L$aY!7XMO=S`jD*is2kpHB>hVLkA1iDu*9II
zQK&$`bE;S%`=?E=Uv~h!?A)AJ*jY^t2(Xq@0qa4Ir?mqo$d$b(^Ievj{XU9I(>?Ea
zLgUnWI4L^`@8hx3c1OEIn<xD9m(Q6ekNZo9gL_RIR@a{Y_Wv@to}w=!R;O2IMvT1T
z*rxUgu75PQ%+xfSff0R>pa0Mqr`9eQ2oi_a7*<#HF)+kz-aiLbYM|w@evkjR24047
z8?Fc0p9+!UyW?-b!LYyl#6LvAByD3sbISQPHcJULP&TM;T%R@yRbqc6lMySh!*8?6
zQ=_udU~ow4UvIpOfCIw&rTR;3IOBKkMk2^i2Sad2B8cEG$_!$58n$L-j0`yl?k=Ny
z=5JnKT3-=@6+Jm3%xn)Kt~DI<Lcf(~Hz=v5Hu{LGu+QSxPX!0pYt#|rA}wCpz;ZvG
zILLQe4|#K6)a`v3zgLTQE%3AtC9^-TmE`Mn-m=~yfN;LHHl^#gz)!eIB8XuCw&1jM
z3GS|yT*6BkJs5!_*8X$2o(u071<H_nDfC6rE9G>~jK)n4EatH0a0y|=arh}u+fc9*
z45?K@LtCLR1UPL1^rC!)Yz9vB$s#!}lMG*I9nodG_%^!VZiG=mb6txN6UHAZ|7;4O
zXS;3wKS+d#`ldCo>UT}fsYoKA+*n4Y-8l`N5nw~cIu(#@&YG^1m52?kp!KM7bYh}Q
zt!}e*Vxb3#PjLUu2GL=#zTSLjF!18sLZebK`+9(QcpxiD23}^|vH%G)fX=zD5sr)-
zFAN^h<6J=Pw@OfK<>o7X8)}zk7>~li14(zSt<+E(H2JO-JI3)}l?dcvDnZNsYd?Sb
zj2=?bKOGb)Osvj;Mm$`Cxkl4<rXIcsa=S-NIJTYUKq4WB3NTM+Hv<IoYa$SO4sSNX
zH6B<0y%C1sef}jTv!7AtG-FQSFY>dwo&xmwdWwa@+ie<OVWs<zGc3oU7<Y3oYdGSP
z4bHUI+rgA%6GFH<YjzL9C%VO%TP_`G$f+hQS%+kA4lcr?X1^pyo4&I8C)L^T%-U?Y
z)w={GDh!S9?c0$$r=<L1$=rGkV>+>v<Y%gJjms*M@840M#jXU8(}hZYi+SS{AbD-n
zo)P*+)J%La7HyrpSW+VLWxe#<7|2fq$6qhXlU@cNXs(S+OowbX32|+$|G2h}y0x-p
zA$$4KrY33k>){2T^5<8STsX*#g=}6c5}$5*Moe0K#pW-slw~q_@aHD)UV;fpSB@8?
ze9b1DdH4FL)Nx4ef}JeNn)AN7dYKZ3qiC%<$kZJCa7K3F66Z0Cys|%X*eJ8^ceqhj
z+DCqKvONqz{);_-pJLB-uw<L)9m{yS7IqRd=?XjQF?#ayLD>!YFbCEW@hUK$i%!iW
z=}fd>KU8`3RgIq(uJ2nBU(9Dj=@1eL%nq%RB{LbZpDcJBtO~kR*cbsz>uH~iY+EsF
z>**65Qb|WWFPVz+!FCz9&``{hI-9A)k(V#a<b&S}#b>6F$Waj|ro;wY`g<tqr`NP%
zxcG=Bau~)B54r*z4S1m{2u4ltU2ceUi}3+rPMC+QY`F+|Zy8Uc)ToclUmH6z<RBqa
z+q$6`20s&<P{Ew5cPe}NqFqhH?d0|wn7>vpiA#(MZcY`%_-us_egdzbhi#iHDyA*i
z2HTvO%B(lTCTTpj?V0X69#?uEc?=)BAKzIV5;r~GDH91eBiS}QuILJq{<cSbk@ctT
zgnUcsYsGA(Fbg+Pu30w~_2}~7ZGqBFany&~MnZ#H9x9Mk4QMxg=X{N?gS-S$rQ6-w
zA5^$I8kEzJle!9=59<2!2zb<6BhPo)PZpmqVwEaZ2p+t#eRKH&lB9Szwr*}YA=3J@
zwP@d7a=Z?55zvCxR@uFlN1DHq1docMh73#PrRT_?tjd*sC+P9rEX|%zpYg4@lP!z&
z^))z|5>C1l;5(ebL30r&q(QTxD(|9Ju{TDBLeFzJc#y!OyOtBZ7`Jj9Q~yAV7tp<f
zOOY=<%S6)`l_7B$i}r$G+MuS-;ZTx$D8rr*^8xccO39G8xhlceO+)R6wD{nl2K1Ko
zpW%A(*>ZBbHC7KEVR9uPTs8-P@8vau-CD&$t&kP+>?DT#?ATT^Z`pSz-JzyRkiwZL
zkbF59s-wy!98R%?K9eCKjT)^q#KoI{l*V(ZsxId)HNk!KB5z;CbGTI=hNUi{$Cett
zlUbKY$0BULlP2gp-OC>9bC^=bUePvv(X4yxx_`UvRZ#UMBE>1cwqw7V<RFsS?6hh6
z%(Zz%h^&2dQ^YZpZ1l#QmIx0gKjPb={_9<AV?=SWl23;F2Qd9Ra+p~5?krW-B5iDc
zwyZtuK}UfvqfD=EB<EArOM-SaZ45Kjm+95j=6{Oc|2tVLrc^EtYBvuMY6o-MXkSRt
zyokk(A*BIv*cbd%We!4Dact7Q;+xwr%lTqj*Ae~_olu{Z;l$H<asnQ%9WDUD{5)Jt
z)&A|DZ^{N^-PvuTNSF`oZz9qVBj<zQR}dUJ5O6phUU99oEebW+=A&b@gJPvKB&F7%
zThK?^-5cxa3gvLMZmS9u6$i=VBGyS*AG$nW`I(R-mU^p&E3h^u;YU(rqjt7@fza*&
zThcJnVHUX=L<gfpBtIFyICOt7DX4<p`lC?mwSq%0jgr)Q>8hB$ZH&1t%djaTg3yNe
z6@`Kgo981<^Yyau&&NGx8QM5T7H!2PmbDnYDaZd(ptnpmdRx!nzSI+(1YIR^dLVVu
z%!-n5$i&tkFnXRX3XG>Mgmcs9%XfZ9CTznYSX2()bjC};=-W1blbh>j@$bw078h^3
zuJ$u6C3frgTl%aG=U%vEzkcDU6*jstF*U8OeZ27K@%N{~#tLHMdUm>u(<34N3L7<u
ziI3<s<`WEtgh)#w-|~OGy#-X2QM4|)LApUoq)|i~rBhNxq(n*@6r{VmJ46Mgq`@Gh
zy9Go+1O%kJyZg<po^$Sb<GefW8*hxqz@ft4|Nj5A)|~VEzB$)i%XXyvSE-$xY=8Y~
z(psn&djDZE@1x@cD=YlvpP7N${g&!ZsD*frT49J$BZ7sIiI|!Xao^5P`Ab{Vm0O4f
zHWR^w#{n6u=Dfo%J2+76AH1a>Nkuo#K<Sl6B^JAe1(i~<_fF<F80;qvL^nqyrf0j?
zhU(6B`}G84V)S+W0()n;_omvgc=aZ3QR-%=e+f^Po)h#a!W+0AmAb~zE1abmCbeC;
z$(bbDk@Ssk;BZrb>s|RS>TbH>;W%!CpZbJING-_`6%rxb!SWlUo26e+7Rpk^es&>9
z_9f8fqBnc&%xfs=lVIf*ljqsGgki;S?5`fKcP`iz;Z)(uqne``n{0VpcLF|5g`c2*
z2oSsN%8aH{9vQ%2``C{m@Xk~*)6m|Ai}K^uR2pVD8LW?1%RkYOse13w{py=;!p{uS
z?`Usj4R~=T;YV-V4{^P0R#C?RiFGymX;FfnZ)PbTwCk??_N-EYc?iC7a0-q*NrF&S
z15j?&jeFguq~}{?=({>PvEmqOUKVT47i-QNYsMRE&UyZEKyNfBNG9J`hI3>4%JrZw
zbi)eiAxm&c>xKMRb=2A5_!<st#ge1x1M&lnk}Dtz!LdGKZD}8hw|*<R3%&WKs}K?_
zMSNxH<|*kVj5|E^B;g$$AM|$KyuiyE6+{r!T)u9)temJ7)clb((IQFAf@b}KmyT6J
zC<6oC4M)Z+)JB24@9{O&o52s0!e&duh7Kn1I}VL5Z^zI|O>N;tCi7tmjGlR!oqBjb
zQ?$sWK}KePKA=vBj%3?ozi1CM9(sv_6*GA7hVY@nW3t1|R|_f{>NvW#SoH_ZHj{MJ
z(`!Yc$9TxOoBVNs6ZguSHWtz6!;Mxf{e+<N1t4d~i<a1%FNY3#Plig)bp<WIC%SH2
z@|veRf2B#IPWl$7f#Z02TddBfyC>Odo$1v*o;w2X29CY9f?X-q)=p%qL?tL{&d&(K
z6)Qs|-k&)p3SOW9A-bBC{Io<mOMb3GEJ9<_(yVf5<T1Lb6B+g60b8}lRUS?6-%oyg
z?@So*u>fP$8LMVYOrh-k`w0J+)wt4C)XFTP6AxzX?=W8q^tG)bvMGMI*>iz;r_$7%
zwAo>Y)XQ09b1djr4U62HCWO`<-xG3DG&jw>nnhgP08w7j?Fjv+l9IZrvtP+>0U(rH
zEizCbzoepJExDDi4WUu8b6A^KKseT=6xHqSSl!04GJXaoCL`lbL|iAzCgJi`>HNpq
z5(-{s#Hu#+=t~#wxIyjFlZ*3Ff^X{apSyf-&l}#M*KpooTvz;nmRo;QwzpH8)O67G
zb)+vEWh}MttR0X`8jLdiiR#pXf{&zh=ksoftZW8Yxb1Zf#~gTuayB8d{kcW-*S0^$
z*F3OYba093nB5=*F~#a4Galx|bpy5ImHeu=56Aw6%cZvpdzD9+G5cYt+1=WM=FC0*
z$EZ5o`o4EYS|-$PkxlQ~r8aYk)6;GpyS84Le)q!3I*j1aQ}q2)QyL_YMbO80@!0Q+
zW{vUDQPG(8u5#Y;@##1{d!k!$s4Inq6@ji8-|6+?Lr9+*VZwq({K*2wZP<W7^pL!g
z{UK83cv@Upp?mt<NHe=@?&e~F9Lm8q4b62G7J3!dF|k+P+V{>*>HChWJZ_zx*4HhK
z>OT!ebfDtJVq&=C+{xG57%1DiMuLqR<&DLAY<O78BACLdM#}&0Pz}Eu=0eL4JLfBN
z@<+?&&aw63drp$9GR)}oFc;}|-fLGnm;3xNWoA-M^}!r6hxW!t^4M8h3w#;^A`8Xa
zvrfp3I-(v`uew~*K_!#LXZiMCs%cAJEp0HJv})oDNp=g8=hI#tH^tf5VD0K^x=~n%
z29X<;31f0x|LnC`fXtXLFi46NiN_HsD?O-)FW<wYm;3W9)^DFjZ%C%A8$(2E-}<EA
zsP;IlO6inDzHEbVz#f|d*tIqpvO+Jf_?M2IM4jr!`Vy|~!M^N??96DdL#0pmnX*f-
z3Fkw6X6n&H;#>8nc-;|oA^|qZ{`U{WT9q=rLS-2JW{tM8LPHmKXRsJXrG?g<u|h62
zTVqla^c<`g5;Piy*j6FJ&=hkodmOB_v|hCd)JaFs+bNB)R8b~Kp@hlLah`HE+$8n-
zd_$i(p7F1e`K2c+<Wr~Li;^;y&V1?TiZrYd-?;~QXI7i+lf^U%5V0MOhoW4Ur?xPV
zfQmdfgj0E7W&5&#5wDTz-O2uS$JL`AVP3Vz(-9X3cd3s~AB{R*NVP^&j!hYpaQeOd
zET<#*Bm}q0iACs12y@>YoibKn`wFpuDCriH6cP2XhbfL#Of3`U=26-O;;zGODdTC|
zo}I$o-*Xb7o;0{pj9kS6_loz{9uaZ+NeWQ%SX+D69MJGta5_ph4W0TFX421apYN=g
z+Aj1pY`;-bTvHV3e$$=asP@AMzd`DeVN#c%4s?^;va*?Ydbt)Y{|Tp-LB&X~ZEgC4
zU%MszZ|!D%(x$;ui}<RHBNXqq&0_js85?aoNr)c-;Xw`4#?KqM@bd>iU6zHm+^@z$
z>Sdv+r=e^<8%jqUen^~-KqL+LZA)F2cUV?_s}b}0)Lqb$Q>P=pJt*0|#~YMth_+Z^
z+cko5uL)4(I81JB>;;#HfL{CKW*?7j^EK+T2|1W?23DM%&54N%s!JHTlV6Sq8Qm8*
z+171roRR!>8}%~hZ2y#$BF)Drju0v~wOg%OXbkRV^xZmw;chMu*LN0DiBPZTd&8Lp
z7uXCsp&(W`q`6|Sc1tPrTOkEvzcv%;0YiK!I%AB##J%R%M03t7<Ti@-&1cKyaF&oO
zGlQFOCG|*X{`@o{^osMG0KM*a%i9&hBO0U1c)4aL$Kq8o(Ue{aT^SqG*SNH0d(K)a
z__S<yBYJEPcVc=y?V6*DDrH6w&oGH4%q<I7is`rc<jbgg0|JP|1hEi5EX$@!V(OdU
zCB{Mb3mLa`Y=9DGw}zD+KUcRkFR8xqa5Y!XqC;&i!@?S*r&oyZ<>q)vHQ~OJq5MA9
zdC)UUF)avGEMMa%{F$?k{Nk=hLalgLLCX~nZS1(FmXN3d-0;28?f2nVl{KuN^98CG
z#5O0I-7)!mLZx8rk8-Pu)VYSHD#_!>b;P+y;7RdXnhoR0bnIDwl1<aDtc0J!`jZBS
zjQU_7Lm9De)(+Dj8qxy$Sc4c80-n%43{vQ=Qfg*;fjQ+jaZY?y|AK?HhYShoeeWM|
zwN{R7EPeKu!}5Ed^WG-GCa>$RUp@le2|drOdixfEH%<fjZ8trj;@dI)Qp<Hpl~%u)
zsV6>P!4x>7_=Ry9K@W<nK(`Ok{Tb`cWj<{guQzJUe$5j>O_w8;6`UI|1T7WS$dgob
zjpX*+4hG+o++J08+0b$ds~VUw+m%NPd_GB+70juOulsI!`XRn<ERK0YDoqAkpl{tU
z_LF$jP61Csj2Rh|jbpsIsuN{L#>=udQiIiKF{_?2W^KQ2=_zx+E@gZwhHhXMDPgjG
zenh4A#2F>+Y|91wW}pmX+e1Q8|6+%Y=@17QF>rk<gkaTH8zz~bJMi+GgN9=W>ejDJ
zL4+E;_$qIyzoT*BuC-CvcJ$~5_eyV?%c47ONS7ap!~F<`)C6n%eKxKcq73Zke66>e
zVtu)-5|z%FDiW9Dw&oTD_vcKD_^T&OFy!zW13f69q163Y=cdg^jLVc&s`FI@TO<r<
zRPR6Kaq?v5loIceJ<R)1^sZpkKL<nPtpY#q8%q{hucVlpaq{o><E7VfeYJBpJs&?O
zi)G7>Wy^|Xd#cRxH1;O^gNxi?dc-X_(6)zh#j(<$MA*>Axp91Tcl0d>f#$MRQQ})e
zp5e)&s`|@qt}JJmErw%+xog*SqNRqYaHc2{Lj&zfcx+Dv1HT-$^!%vmEIfw$LPpJz
ziSw(L56R8&Q4&vfatnn=Ux!wc<4R@FmTtt0&YG%8u_n;FmXZbkD0qV<m#%93%UFrt
zev)Wa^TdVJg!;>GefG9*bZ2OnY!dr3tl~4VgZ6?x1-qr*P6-$r*jGDJ4I@>l&imCO
ziof-P&BGhNAe#HJ`sC(98ofn3Ie@S~TKUiQ<QO2U2VqyV!;VS7e|d#s91}$?xVJud
zn?#*g2m{uP>R?rJqHgTu^T|Rkz7u1LWWBjK{p#!UN}M2hj8A&lUZGUM+#Go6_qhWf
z`lIc2j33?XULAo3s-h;)L48grjMAt5AU2u5Sl@^8DbIlMh{S{p$X*EF4#}H|2d!M`
zxH$D+Qf2yIf#2DST@|B<EiS`Ca6fIjGpk0s{<A&d-Ze^bV}3?Vf-e*{^?u>aqR1@Y
z4}u8kmMq&@kq64k8oszu6a|Nr=5MI%f-BYQym*ci6}e_6Imm*J1W%7{2%ddcJYbJQ
zz+vay5Oo=zp9XrLF-PWAs6L;?iWp#GFJB|fNOq=p`^{PN>RQoTt0I13PVchJ;c4HN
zb^n(6+QWgfx<2n>myK!P;0H`suaVrziIqx!A)WqOGW~cz=VwRy0Na>A011`P^_R<R
zb=f$Qqno+hOXnfBvpY(0RWodAq_a~y5_Q48n^=)4E)=TP)mOp^6m0uPuo-OKH#oBz
zPLwp4SLk1La&L`ea<A`u95T?vQ2>5hM#*;D8>%|TLl}&Xx?YRHmF}Kj@zF`JO)o9(
zFHx?^ZMTsTpPog{ufot&ByDyRrYq}oVu`XsWZm&)eYeNm<BKM9D0_!>scx`P(2_rS
ztO2vV{FE?T$W(O1I3%VSoRQ?WB4TmA$XB7&uN4^fbRI2Q>@pZ8?st%k+V*&L9Bw<9
zc<u>7r}N^qPXj||=Qa1<*x#1>R*B!F(mPI2_T+IIS2HsGG9CX0F*;~FaeVj)D@JM8
z-bCh%0#>v2FU`S7u8UOkgh%vtjw}Fw0$QdPe;5xX^MjgeQEclW>4gHtW`<7MBcr*_
z^af!&EgcFHW~`Q!KCD=eEHI~nk8ru|rz6E5Qx3d(HGNplWy|Q5WST*luMiD<hEia|
zI`GCdHz6rTMuDgX+RGcdzIHq7a=!+j#BR-*=CQHKexXQXn2G2i5_1%k`&Nq&j&t!*
zi3R_!fj{!rd^y*oy)c6YOPuq;0gv<e7{%b;HAb5ykwRV>@s8&%Q(ZnLO-7#?Sbh=;
za8cV2NPTSj_2cv62L~T98*##f!}Tn5Yx{g^yJIjl<Gtb^tffSp6rbzI!^c)8g0er7
zh@5ZqbevB-gIE_rB;u)7$bqNpd{uGnw_nN0!KBVFo*qjg*zQHiGoub$PU9meFUR$$
z<_%DKt*lW3Z0UYV)3Ws`DbD4PK3wTp#-R!GDJm+@Y|e9#fN!B@8r9NR=koC-+8&m~
z*g<p^9kja<{jjApB%zUre0^>)6w5&JUjHX&FI)1bN6dMp_M^vUtS`-l0*Ug9)aZLs
zL-0-cCzFqoO^p)1=6q!nf328q@p!lG>NN2j9eUO7SD&vW`J^qmJ<W|*ty`yh#GB&2
zr)98nVP2e#MPNleXdDu9G5XP(L?3^0exua+$!(lyTB-e1M^b8`K+nOpGJ@+QtufRA
z#1*5#hbqQyUi8F!RB%B%COIbSR<p$StZ`*CY$jG0I8jbzf~Ujn$Uj)za#AElGHV^g
zSP@Y>&K+y24pXAh*5je^A}+2tO`)@riH;Le5YDII@fPjbvBIkF&leb(Y&a`TPFGh^
zvh{ce`Ae@i_gFSmmj8<TbrSTv`Cqank9oJ+eW%}BSfLt{YH!7$^y>_vHB#~JGdG=n
zZ52+<xPAmuyIY)H5_dV1FKP34cykwq9$`<o5%MX&(?Q?Bgfv*;tv^G24g>wD>#MsA
zjN4wvvC5-@7m}m42VNZ#?nJo_!$GG^m?|31C@eL;PD*sLW;&=CW8B!-ne7bMn7ec3
z+=i^acZikJ4U1G{ZXT-i>;n{1sB}RgX^%X}cMa=^LTBi8`aHzJ!b|2|W9H$7Vvdu<
zJwG`XD;a%>CygP~{i^cWnm9OkzZZA#A}E7f8(YaQ*B-K+)$r*dmGRS#7#`3YL4|sN
zv|TC-3tO|9yMm=#Oq7@7<9NLp;e+nlswu==>^KWkv-I@HZgnaocL@i-=(_<YN{St<
zNVmi$J2SB+lZ;kPO0vBAN*fgunpe{~Ykw^!Ep&G4vZ2N2$#3U2MW%i2MX&YmJT(+&
z#oZ}3ZD{~KAiOdzlNfBxD45{jE4SN|c=UzO(F_}#lC#vKxKHBSyh3FBTX|-9=F3H(
zD(tINY)42j{WWt;1~l`Jd`Q*u(CfMJ^N4coB-#U$bJSZ5cMWaHKeou*K54W{&ENtY
zfb|fq+^Y<~;$am&4wtS%;npD2TEP*e$Oh*uolszWO*s<ef8DlMew`2?239D}OU=_F
zXVCbLA(Z;1e`9C|=UFbN4kxdgMtUtb;nONpmDe8R*;S?>S(lknQ1T#PrWl2+NFd}u
zEqCMm_oO3?fY4*nY`KW0_#DOwlcv%n=Jd@)hFKaR-;B#|kfP!*=L4cgjbi4EjL+#K
z?_V-hP>{1#!+W`0ptZ42l2nEb9#`33`0DjsrHt9#`+{6aED!0Z=C9b17(_1qTwu;v
zhrIXVEzYTC^qnAeS$)W_E+?%NR_ecF{h_;hbc50IM6hy|^)Q5OE6J2LKz?UOeQj+&
zRhRq7+{7OJMISTVFC+V&lc0wI*LDo`o!(A`MAk05=@kyatvzytuWF{`rY|Mh-FA9<
zQPk>p28*Zx>3oz>$nj1&AM%~_I-GFgKqWN+?-TYS{<nsF0*yM4qM(mCn5c@!lqgh9
zw2Y6szg8>jrt7_#A1Z%e_B4+Ni&t*nQ9Cr$Gy02u43sq*L&v$Ik+&+Iw=T<SwZmVy
zWDDEKx0`b%-`y{uN%h)IpTeRgLYJ;2K5t6@5fUhsDR5^kH$Xc#Kq@;}hB-iuHOLkl
zguWuJB!d!7gMv@>ht;}4%R91poHymXWUEX`3Ll_0GsSX06MgYz%r~z|njvm~d@dsN
zn29{FpNmf<sX_Nk`ua$7;SaUYXQmEGC->+jvp9eDb-5f3-YN4)>=vM#o78;H1M;x7
zzAzQ*!wstLJU%poS&j-r_|s%vma%BUEZ=Q1)BMKr<=kB3ul~TFqqkYUi#e=eTHJt`
zGl`<Iu2dS20TWFmm0^4o>>s+wN-9rAA{QmyoM(qXd>D?zHC0My?-Bc*QA<zw`dAod
z!tg!&#?OU)LhLqQ$(y0nyl6bqcj?XUklwW<+B0Iu%2&EQtdP2L%(=0~#*?69cLg&@
z%}>+IG9rVEp|LJ9K+bzET_EVqW5M!IlnCy#DF!U8KIbl;J<=fUD6pkC!Dpg~#-*Z6
z5LIESGLKJ%kaAGLC%>v3Do_Z9KK=St=S708rp*D)FYnax2Rgbm9SP3Gq%s;M6A|^?
z`t#KX7FNW>ZZH+d8iae4V%;U*jo#mVc%R2yzPm;3G0LOI*C8=$X3m{n)r)75d8K<J
zQZw%Bta9FCW%JS>=opd|lz5Pcgv}pB)MQbx#RPz@n5Uymf65_eq`Mdc+E<RbPa$r<
z<}!b4d$paNlAVVVnhlR6Kn^^MbNhXlU@1~Kw%T}h2@yO&9TXUsKIo)Se~(#%9t2y4
z-eLrE*|1!tj;%0t?7i$*`Rvs>CdO^XPveMB<Gy(eEd@hzSax=a4Y(v>fpkBJ_oPoh
z<m$Dof6lB-9};WrQ}aEo_EaJ^v(qf7)KBF9__#NLDAw1&$u<Gc4tm@TZU4Ftf*le0
zN=%r`4c!CdeRT*^_T9(#W%@1dT_ZW*3%pe@A>XeLo+{0__=)zndAH|@rp5V`1XE@X
zbZ=yW%`O&ga2pUVQxv%|0gCx6zg!8ezuwjI7JF$9n{9i!J7!nOnBbh1jB!772Dcz0
z)PY~i>e8aP3g|2r>^0NgR8{jMvLjsk`^eZkLw70Y<3fTB$W6_?h2aPUAP-b&vq8m;
zhj4lp45=oOYK47ua-~8252Mh9>{N;P?~ZL}{{501A+CDtr_E>046hF52$QRRg|AsC
zp&(Rq@$NwKn(Hp|?K1s5u;Lzo_=-eeJgvx5tObRIg6hZ?#F#IVeIAd$yS2MX>=@a#
z)cl(7hM`p{(>3jou!)t1L3}tPi&$j?GNr<6T<z!nb@O$HBRLJ}tvaYEz0X9l)xtET
zEkBIcYkINw+dC279pfXg;gor9Ek<g7<rxPpMwLIs%;i6qXhB|LWk)~rhYD8Wn8XR&
z*%LCagx7Yl_fHg?)L!eywCE>aLMV6{C>QG6#KI|Tp~qZc<j-+K*k$CNVaz{F4uQU@
zoKL<qB@BNgu=KidwfTCiC@1x$_A8Lgg^xI*&+Wsm8CzfD7XEHsA<dc4VqVs~<mh}f
z!$ykJQ8^l>1lTCW*>pNZIaS5T@=%k7R7|2JSHN>eg;U|x!yoAHx#!OP#tA~;qdg;u
zP@g`13VZZ+oLL5Cu~0I5L#L;wtxp;y=;;x1nZ-RWEQiPvhcz|ZT9RQ8P6Ua;7p9xa
z&rj|WE5MMix#Uygfq1O`VXdq!x@*pV*fLl#H$d%o+3i|f27_WvWfc_^1booq&-UDC
zL%?hV<nj3W4K7p&ZhJXA3_P4&d*sy3S|lsx=2GGj5bQe(4z|tNH$5wn{G{&UCW(ch
zit<>S4-dx)3<|P4%%eE^;%_Y@u7Kr7v!a-u-vo|Jc+}Rzzd{;TAtRmR(p$+-uP=9(
zwP%a&&0BDspu)`$+S(tWCwILMR^S9~nR6#+G7TRFQdi4{hWU42;*E($mvR{m(7Bty
zjUo`%mA6qKPo@`*oSe|S72qq?s0j}YMt)m@rX>T_3!zESA@t9RiFqU9!ugux$^063
zUJ_VQwg1dWgo>VlzbZ$|Zb---#<?PJsf^2MIf^MbNFhxIwM;we<xA3!dUe&ZNxQp_
zk+fn|tgmqH-@mU}<NV3RKbrtKOu^OmxCEA8F%hG#Hn$x8%>OR&S=|T<E;-m@^SPvi
z$LHLWUALNaWv~zvK}t$$(48!l$ZtgzO(PO~Bh?jE;<z_vb3jAiO~|~O90p;6L1$e{
zHpQ7DBLvN;L#7}~8phr0iLo&gIj0U*iXtortdH7d?;l_Nq>c;AATSW^qh>K`XJ_Y7
z>GR8oNgJP&tJ5<xTd*sfSUMQ5X(mP@dc$kO!*wP~!2MV`FQAfuq1VM^O*H1`s5^_=
zEd?)IZqr7jYfvPXde^zW`_;jM^fN(Sh*rI)kn{RzSkzSkMs{{Q*j&qg>-KG)XWtUp
zBtqmaC4I+03{}|B!T)=w&$UXPO@-Y^T~s^mcK{--`$cUa&?{{g1;IR?g5_28r3>bf
zSjA?*#D#HAb_4ItH*Yuc(y#k<0|H6kHDRYD?12<hNE4?)6gjVHx3;#H4v#N68l4^Q
zb$t8Q`r`Tn1Ok>n79pWcFQ=#|HFG@n!-o%3gBCjvkdxj~hd6r<Q;tVT>6<Qqzv+Ar
zxmL$Gxwr`VlklHEf1YY3DJgkRUf#Ud8n*tqu6(L6C>f@Y?<}$$z9qUpWGqI*>BIwL
zPw{l4%J;?XGEiU=_kS34v&zGD24yp28BXT3^gPxJ_8Tt|PQw215V=fA85y*!pEkKn
zJXBFETwFH2^|iIs?schk0pii<48*>{RBXs%Jj7(M$Yn#U0e2zfx?f(qMsmL<#LE4V
zkr5*)4mts~;N%r%*s&Z@TPv!N#Q(jo+km@tnXlHQIS_lO*3BWp>PdxlTOju3YA)Ml
zlH{i^k0F%(yzs(s{&4vVnwV;?tQ!;}!{pIs_AM2e^)j;S*Heo)uQrBVzOflVclu72
zaIy@!leeR%r@c=}BC0P}$r#4qa58|fvdD{T@`O%{$f+c`WsXHy3;&HycoGGH-%Dv(
zIPWSiO{>cOIvi6102I^5#|PO!BQHPy`N8?t*4E*~#d!#v$2ipkN2bE=;mu!9Yz%*~
z!^~#y8%y3h(=KU?7Ne^U36HMhAor7#_-hyaJC4FMzdk()aa#F>g3#flc+IYbTBk>d
zxTmDlFmDXIxyi0vxiWTz+36C&m27XTiQFSlU5U*4jrzZ7+Jqo2L8d<wqEEwPaL|xi
zLLeTI<M}HzNkDcBMpyrkAo2KmLSN9XPZ|mu_aW5h;^FQ7T@Es0FfDrz+Fg?GI)z<<
z3?;L7;o1_M#|&S`;5z#^kafPBC7y`J)|&Wty*KNqk!zMX&ZUSx%iDA?xWslyC-mMe
zgN{I~f44Hr2Z2n#Q$jtg`5WuKY!U@6ZY+`lp+Bqdj1pIBS-?^q)A?e79RUE32P?YY
z?av}$WZZyiinA|M--G^@IS-9Y*U}LD`Lw}e`rVAmN<m2XlUHcydku^j?%j8qBd4Cw
z!$TzU`p}cgzk$*#_}aE|Sm<v1{Isi<2E*w#d7$3@b{AJ>X=%U1$&!-K@>=Y1mKfc9
z;~Z(|6{<)m#QS^G{U2bI2m1Wd)j!0&c;P?rLBnI6i-V)hA03z5cJj`>Y*o>%*309#
zuc7oXJ>lr&q{WQa-P+sRdz>J@=OzGxs>=hhUm>e%LvoEo@fvbU`c?iPydAHA0241S
zDOc?#s$3-H)ZD#%CQTyu;SYuN;ggdFkyLy*Y#IfDEmL5yUg3S~&8dX;2n3ULwA{Nm
zbO9KRUKc)oexs@8pdU+)FiVZ^AAis;>oqUqri!|E?_Og#8Cz^}a^%A#eiU1MoV^8!
ziz~Qre0-C^;?m}la7P`@9iRP@v@^WSyD@Ug%0&C?V-cp%SRp$*+v*%e@8{@f<ox`z
zo*r-}2*|M*R*ck$&3Ea#*Qa`qM+=shQSLzyUL>RBaq#VF{e9Jbp)0YW+jw0#rm9B#
zoBjfiOUhthRmsR2kyInZ!8v;rDTMQb7*Q8C9F8A;Dk=?!ZCphT3yRQD^ad6#Zp%)O
zM9jBu3XxZCfAM1XT^Qo*HRCn2wze)_d$Cb&6#+4s2o*&CTUuR5G_Lgr)Z~G>t8YwG
zn=A_JoCo-G6;qlgn*z3G<CWaY@#(~=<+Dj7&bMN=P9`pBSzo>X?&WiFGBJ~#pl4p@
z1!vj(FfSXV@VsF)Rz1Mh<G}%W+^03Ch<op%ZySybKB=WqWvhQ%Gwy%1B068NlUTFT
za_U6uFz6=sN~B7MAhQ>%WEc+|{16A0tHZq*(F2zO4zW2-oRKC={+YFki7#ONE|FIS
z2oReI4X5bRAp}9+p9OT9_`_U!Za4~W_1>jpxPALFq4?pu+<@s9T_bu?-=9f8dUV-&
z?e~EB%jCA{Y^iEGBgvt*RQKhZqT3xz8dmYKu|MYbOG|m7X&fmzxzUezl2+wz`@^PB
zNMFDl_4f8w&b@x}Zg53}#>I4K&DnCSn(Ve|cc4`IV()@=OyPwSMzfY*k)Y3LvDphH
z4ylcmsvW1l6V*PdOE+H#&)L1QG^+JUos@z?I=2si%O(De@8$&u2beF{YSePxy+c5}
zc$BNSSDUtbaBx>umE@)T^<8(dS$m;hAGHF&Ya#Itb38KCHG<{QzbdcAdB~aIv0p>=
zVE`veE&w(x*X%gGu^@}@chV$sF8=XDIWRcb*?a;v+e)&&f<U?&Zl%WhIH@iKC#c!t
z;#%#|sD>&e;*zDwe9;m;C+Jxo%iBQpqW(8so94fh@@;I-@En%iN^R=bl)fd%a`>sS
zI#JwbrP&+}vi2D-zbC?Nva2e&5O&p!XLRRhIVP<uqDSIFl$Q!0{Dd}{e?ra65DT$F
z8OG;32Q3bD3q|z1FT76nryBh(A)(0W*;%p8ggE<?ay*zZdelpo>S*)|=k2jq&wI2G
zjj`CoSTQTZsgICe2eIz|F{RFN{AFSyR*;n6B}@W(W@ZcoG&lHPLm2(do1IS#RRs(s
z7q0_oy2@{fwALSBa)*bm@HrpbY?YUj`#c_~X!RqqwS%v&E9^Q8BHg?A!`wc@-V9ky
zKp*}A0mS6w!3(J#>u<$8C!AJ?co6FrBy4PKcJNP@SMpg|S&q{E{g1(`bT0O07W-Uy
z+l2Hk41FY6ok+w)PzngpYS-BikX=W*%j-yIGi>>#)@^5UV<YB9nkNY#A0Lf-q)Mio
zTfKz+EY`Tsg%|9G&L}D>ipb0^X!Vahei_LjYi3^5LX;y3WzPRxDBGf=F!UQCSo!to
z(qw(GZRd;YsbPjc`}zuxD5XNz@#3nnDROefTXZbiia*IBe8XI>!(N%CKjg`g&$C^@
z>x<vRBikX}(0jb}-X@_HEeyz^-F8DV@jT%P-@cPB1mbc-0@{6%TrFng@0NQY>J{Dy
zYy{+siV78b7{;|tBMiupLA-|p?;B+MTF`XVR~GyAdSc^KW@J<g{S8Xqo;hbi<M_oq
zDk4}Z%3oY&X710gLfr`=<b6mP*9d=$8>Rewj?%#*`QLpk!+5F|KDBY4Zp?vb2*K&y
z{v+4Fp(|rN2(GE!UQX7eY7-zX6V-oHComOx$vk9SE;Qj8wsnl~AU?*1XU>_-N0N{J
zSM%K|5daq4MDUiMc~U&A`#HshGiBz?$gUXE+ME8D;^ZkM2|KYuAq9N*oAarvsun?a
zhMqGzpHrS^-N|8KNsD{#3W?k(`d)jlD425gA&AyR=T~FjaCwD5Fps`zlwCwdbN9yS
zwg?q%?eNuA%Wr8CbPp0Z+m82EP!KiFYt7%@+%9(8c}6W{kJgv-um#paY+T&bT;3Aw
zOHwU#SlmIaOh#1+xJ1k+*fBCigdAP>sHiB-N?QhiE-(>A<^%85txB~yBITG!NJxsH
zJ<7EkH;mz82w#b_B_-G6rCc8CQ9=0Oj7!4_&5QW>EojoTx0|kv*;z+}P`TUxl7AXD
z5Fr}zU2KWnk@F5kD!f8(Yqv+Ks&b?=^Imi5N2iFm7|nc%LI#eK9`T63fn)wF9FX1k
ztfb5>t!qw7TKbZ||KU_!A>ggLuT4GM3}{3WjA&C^?tho5qwK?I=B&E3`Bw|#MU#k9
z9IKk&Z@)kLs8xcoQFlO_qm)K~04l>_WMuT)5}bCi_nEuNvu8%In!)d$?F}08Cjogm
z?WRHOQNm)eP)oke09C&9C_k;0Hvd|ymy{mVxbk29`LmuwFTmeF_T|g|jIrf`4_kl-
z|N2V9;m=Q9SBu-V#l}ydU2lS(duQLsy?W%*q{8H{rbwp~6sP_}<AP!G7MFSL@d?-k
zC(9Pr%?U*}5ve}sZf3kxu#E1oT8Ytg!WpNVnRI7Zbl!&yNa``iqdbTl04b<>B7Hh|
zhxL`gsm?wDkiNJLs5DxmEnj*V78a(=LMmuG>1&#3W@W{(y}iwC^_y2oB%tZX`@v0n
zpl0oaa5A^$P!Wp5{I{k3%6tpp6=^pDH+Kng6v6`;N>?Pd{+MAQtO9Zl?ZCON1SUa2
zN<%|K*Y&D}->WFKFAgSr=m;fFxzA4*B$zlj@Si?izmMRf!pFmqb_r6{_3cuO?GbUw
zpn{AVBz7r1p8T`7We4>Fov<Y9YHVm|)B^Z``}xmnk(4|cV<#6gbQiuL0sqW?04s5-
z>I^Qu@g*;xttcec^Q|rRYQvC-pr<+MDXQ9E7MuqMXE<tBSR+9;W@DWtk~+N`tTA;`
z0)V}IK3JXRN#TLjnL9`O>CT?pZ4ig#dcybq&ZUeO4zAR;7PyP_3o=xMTz8}&<fN_d
zAic7T7asC=Zg<&~pZvypr5-&caMweG8aX5x;vwh^N7wAMHYP)tdX=BMR<R+Sl8Oe*
ziula~qm6f}OzoS`RsLFeXr2<7t@zzaG|*+xY>Qo#yDTvOVDRco@Cib0S6<~+O~Uap
zcDFtL{Tvs5eskRd6BmJKv57X?fHR-r@&d@qT)!A<8<#A@V-hT3`Sa5X<WDo7ZW!?P
zd#}<UiP84!Du)FlScBsP0o7OFQdf@J*;I7xi(PDm|9*mJTYvr|hPZq5arfT+FQ9m$
z#FWswc1sQo6H_{~*I;w93CW;qDS65$C|sD*V5?q;I2T&uxFm8A^h;g0jA~D}yNWc~
z4+k60gR&naFmiJf!J3dbJw4q#oQW|$+??9n*=b1?^Vo!Gr36T=`Pn3_LOS<@0U^Ut
zp#RKcs1=ZI`g6ey+QFfr&>&n2soXw@4X7W~Kba56eHdsq<7H%EKw(q=c*oxU7QfYR
zGz2A|Iq7=Cg*P6JFsYrLo$F>3CXdB0_SNyanq0yl;ZU)_Stlth>ffGQznh+`{27!C
zaY-zc-u~HF3$LL}6pX~W!Sl#|b+qd8RRL=mO-;&FuYE0~D}c6%8l!hJ|N0z#IXMg@
zhMqW`7odqwaff1o?dptpzC2cb>4F!Av%8f4!sB(BN0+-J>+K~6QZQ)5P{Y(m3d*0A
zT(S7|vB_hjE@Y`M_Y&e)fo?=%V);aZP>SM5{RY}MZ{B<g4v>?TP5=CvgdpS+JYi#u
z_ipBj2+^`LJ67jPw5Jvpg3|rbwSM70)=j*Z1(bQnl0Pdu+pQcO9i8Fk&3xG!;4?Fy
zD#rZ*jw&#>07TmyGL9)TEAcq6hErl!CmQH_M0fCBym(=IadvRfVW$jO=vpD`_fOKG
z5oX=O{<9?Vl;X^IDIIr12UBZ4h;24ray>s<Nbfa+aDb9uy61Qe2r$C8zhCWTLV|Hy
zI2k*Z7c~sVdnWyqO9;IBCM?}|U%Psd!NZ9rOy=jhVbcEsmt2Fxe*OBz2-*b1jGfZk
z(9z2szwpbPeR@?@Ro6^*0ce}GIm@+I7Cygch(lyrhyAn9vloiFEg7;AMKD*eD4CF&
zjM#xrl9;c?_I#2JBfzi#OhOFA>hCh#!iIBUZy-NT8bkfEnnW)Ksq2PB5(S0vP^RiH
zmaZTTNWaW}P9DbOTap0b`T4mk&=i$NkNVcnbU7)I^AA$h9nJ(M9v<Stx_v6|(-}G!
z<Nkg!xR^%2hIXt+B{hQEo&2u})!qltHdgI~^gIX`zY3F15{T7^JMQksj}I<@jfSV4
z@8*ut0I%m%P|}Ml&c>2L@JI&`QO#_u*&@+H=<#(3F*8&vZ|%(WZz2r7tqN{n{N?*G
z#q?RUE|wlVIs|^Ol^F`c{&8iM1{f;$mu0=t@ip=YM5gJ^??1-KXainAjFs(76t;Vy
z5&mFs)-3uDXfp_5KBjmixntCh7Vh5}?;1(iUpmdWJc0b3P+bM-FFBE22J>rC1Uvsc
z;~6cGd1CO4#cOQ{U*bMv`d3^1e@QrhJzFlVifb(n6nR2^8}AL})W0Xf0#p`4J)#aK
z%I}6CWqp&7iG+C>7XMv}%(B)1E#qgc`@K1mEX9cJzaQBz2{a@KkUo5Cf0C1z$5AiT
z8+$flQ-6eEUq#JyH+prLKK~KiaYaqPh@h>G;3*y}*WEuOmQoDP=;iCzj3OdecNTiu
zA$mY;KPI<YUS2M;ost5bZR~-H>RlLD>!<I{rM%^?gFq2U`S0yk&n+!mn}cxE`<7q{
z`#t`kUS^&-U~b4u6&D-pOU9;7FC=s&iQme+cOGcoAK}2TIWQF`rQkA*l6rdug)|mD
z^K~qU>Hm;jI~Ie1jkEh4bKs)#$1Z3++MOa&3`YZ54u3{pT3P~$uXb6SDhh)?>HE%(
z$VP3z>8a=G@nFNcT78Ge>^On%F(;IU4|_a7DRPNLt`)kF??FDNp1B&S9-V2qr5=nD
zCBu=>H*K=+V0;H}Pv;M+`R#o%|KCsz!Z$gYT6E{z?V&mkfm!?4ly%rXPx`GC*E#(%
zhr>XhmchsV$3psp|BszZ6X=vp{^+ht*$E(^G^P@y{TT;xIQCjgKMfNRnS2F5OlJBo
z>~?>xbF=M*gwob;2bZ${PSfaLRi|YZ6cB_E(#e6RrS&<rL-_tt1z^6R1!dEBfr-(%
zE#*PT8jLY6*a}gtSZ&^Bf&J2>|A49>_!_of`icq)z=?s{VT!iMSXfxZB_xDA@5^!f
zeFZOAy)GC53_9-Bs{x}CfN90X?F62?y>~-nVm8Jvy<2JakF8E7LTxXvPI!ASg&h4&
zvI7M&upY63@GKiaZV3INum}j`kTJqzT}TPUMNo|JuJV6uD=#YI&Kp=(A3<ueS)4BC
zY8-GfGlNDa_ihf#zu;eBIQR7xchdJn=&A{%6RBoo<m7xAF;pRhr_x<N90c=XxXkp2
zZ%`ovYc)B1Fz{}qcY*pI1gF+#H1|4ML~Ls6czXMjVk30*kD9%0DylA%n&Qi<Ae2G=
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

literal 0
HcmV?d00001

diff --git a/linear_error_vs_tau.csv b/linear_error_vs_tau.csv
new file mode 100644
index 000000000..6dcb3dfd0
--- /dev/null
+++ b/linear_error_vs_tau.csv
@@ -0,0 +1,6 @@
+tau,err_euler,err_rk2,err_rk4
+0.02,1.92875e-22,8.88178e-16,3.1012e-22
+0.01,1.92875e-22,3.67972e-21,7.78911e-24
+0.005,1.92772e-22,1.6854e-22,3.87259e-25
+0.0025,1.86518e-22,2.96555e-23,2.17789e-26
+0.00125,1.55116e-22,6.69366e-24,1.29188e-27
diff --git a/linear_error_vs_tau.png b/linear_error_vs_tau.png
new file mode 100644
index 0000000000000000000000000000000000000000..724d17c0bc85dfd50484b23ecc1a70d663fbc1f4
GIT binary patch
literal 25035
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
PK+)Z1pc%XMh{wMGY|NG<

literal 0
HcmV?d00001

diff --git a/local_pybind11/bin/pybind11-config b/local_pybind11/bin/pybind11-config
new file mode 100755
index 000000000..92a02d5cd
--- /dev/null
+++ b/local_pybind11/bin/pybind11-config
@@ -0,0 +1,7 @@
+#!/opt/venv/bin/python3
+import sys
+from pybind11.__main__ import main
+if __name__ == '__main__':
+    if sys.argv[0].endswith('.exe'):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())
diff --git a/local_pybind11/pybind11-3.0.1.dist-info/INSTALLER b/local_pybind11/pybind11-3.0.1.dist-info/INSTALLER
new file mode 100644
index 000000000..a1b589e38
--- /dev/null
+++ b/local_pybind11/pybind11-3.0.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/local_pybind11/pybind11-3.0.1.dist-info/METADATA b/local_pybind11/pybind11-3.0.1.dist-info/METADATA
new file mode 100644
index 000000000..528884b1c
--- /dev/null
+++ b/local_pybind11/pybind11-3.0.1.dist-info/METADATA
@@ -0,0 +1,252 @@
+Metadata-Version: 2.4
+Name: pybind11
+Version: 3.0.1
+Summary: Seamless operability between C++11 and Python
+Keywords: C++11,Python bindings
+Author-Email: Wenzel Jakob <wenzel.jakob@epfl.ch>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: C++
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Project-URL: Homepage, https://github.com/pybind/pybind11
+Project-URL: Documentation, https://pybind11.readthedocs.io/
+Project-URL: Bug Tracker, https://github.com/pybind/pybind11/issues
+Project-URL: Discussions, https://github.com/pybind/pybind11/discussions
+Project-URL: Changelog, https://pybind11.readthedocs.io/en/latest/changelog.html
+Project-URL: Chat, https://gitter.im/pybind/Lobby
+Requires-Python: >=3.8
+Provides-Extra: global
+Requires-Dist: pybind11-global==3.0.1; extra == "global"
+Description-Content-Type: text/x-rst
+
+.. figure:: https://github.com/pybind/pybind11/raw/master/docs/pybind11-logo.png
+   :alt: pybind11 logo
+
+**pybind11 (v3)  — Seamless interoperability between C++ and Python**
+
+|Latest Documentation Status| |Stable Documentation Status| |Gitter chat| |GitHub Discussions|
+
+|CI| |Build status| |SPEC 4 — Using and Creating Nightly Wheels|
+
+|Repology| |PyPI package| |Conda-forge| |Python Versions|
+
+`Setuptools example <https://github.com/pybind/python_example>`_
+• `Scikit-build example <https://github.com/pybind/scikit_build_example>`_
+• `CMake example <https://github.com/pybind/cmake_example>`_
+
+.. start
+
+
+**pybind11** is a lightweight header-only library that exposes C++ types
+in Python and vice versa, mainly to create Python bindings of existing
+C++ code. Its goals and syntax are similar to the excellent
+`Boost.Python <http://www.boost.org/doc/libs/1_58_0/libs/python/doc/>`_
+library by David Abrahams: to minimize boilerplate code in traditional
+extension modules by inferring type information using compile-time
+introspection.
+
+The main issue with Boost.Python—and the reason for creating such a
+similar project—is Boost. Boost is an enormously large and complex suite
+of utility libraries that works with almost every C++ compiler in
+existence. This compatibility has its cost: arcane template tricks and
+workarounds are necessary to support the oldest and buggiest of compiler
+specimens. Now that C++11-compatible compilers are widely available,
+this heavy machinery has become an excessively large and unnecessary
+dependency.
+
+Think of this library as a tiny self-contained version of Boost.Python
+with everything stripped away that isn't relevant for binding
+generation. Without comments, the core header files only require ~4K
+lines of code and depend on Python (CPython 3.8+, PyPy, or GraalPy) and the C++
+standard library. This compact implementation was possible thanks to some C++11
+language features (specifically: tuples, lambda functions and variadic
+templates). Since its creation, this library has grown beyond Boost.Python in
+many ways, leading to dramatically simpler binding code in many common
+situations.
+
+Tutorial and reference documentation is provided at
+`pybind11.readthedocs.io <https://pybind11.readthedocs.io/en/latest>`_.
+A PDF version of the manual is available
+`here <https://pybind11.readthedocs.io/_/downloads/en/latest/pdf/>`_.
+And the source code is always available at
+`github.com/pybind/pybind11 <https://github.com/pybind/pybind11>`_.
+
+
+Core features
+-------------
+
+
+pybind11 can map the following core C++ features to Python:
+
+- Functions accepting and returning custom data structures per value,
+  reference, or pointer
+- Instance methods and static methods
+- Overloaded functions
+- Instance attributes and static attributes
+- Arbitrary exception types
+- Enumerations
+- Callbacks
+- Iterators and ranges
+- Custom operators
+- Single and multiple inheritance
+- STL data structures
+- Smart pointers with reference counting like ``std::shared_ptr``
+- Internal references with correct reference counting
+- C++ classes with virtual (and pure virtual) methods can be extended
+  in Python
+- Integrated NumPy support (NumPy 2 requires pybind11 2.12+)
+
+Goodies
+-------
+
+In addition to the core functionality, pybind11 provides some extra
+goodies:
+
+- CPython 3.8+, PyPy3 7.3.17+, and GraalPy 24.1+ are supported with an
+  implementation-agnostic interface (see older versions for older CPython
+  and PyPy versions).
+
+- It is possible to bind C++11 lambda functions with captured
+  variables. The lambda capture data is stored inside the resulting
+  Python function object.
+
+- pybind11 uses C++11 move constructors and move assignment operators
+  whenever possible to efficiently transfer custom data types.
+
+- It's easy to expose the internal storage of custom data types through
+  Pythons' buffer protocols. This is handy e.g. for fast conversion
+  between C++ matrix classes like Eigen and NumPy without expensive
+  copy operations.
+
+- pybind11 can automatically vectorize functions so that they are
+  transparently applied to all entries of one or more NumPy array
+  arguments.
+
+- Python's slice-based access and assignment operations can be
+  supported with just a few lines of code.
+
+- Everything is contained in just a few header files; there is no need
+  to link against any additional libraries.
+
+- Binaries are generally smaller by a factor of at least 2 compared to
+  equivalent bindings generated by Boost.Python. A recent pybind11
+  conversion of PyRosetta, an enormous Boost.Python binding project,
+  `reported <https://graylab.jhu.edu/Sergey/2016.RosettaCon/PyRosetta-4.pdf>`_
+  a binary size reduction of **5.4x** and compile time reduction by
+  **5.8x**.
+
+- Function signatures are precomputed at compile time (using
+  ``constexpr``), leading to smaller binaries.
+
+- With little extra effort, C++ types can be pickled and unpickled
+  similar to regular Python objects.
+
+Supported compilers
+-------------------
+
+1. Clang/LLVM 3.3 or newer (for Apple Xcode's clang, this is 5.0.0 or
+   newer)
+2. GCC 4.8 or newer
+3. Microsoft Visual Studio 2022 or newer (2019 probably works, but was dropped in CI)
+4. Intel classic C++ compiler 18 or newer (ICC 20.2 tested in CI)
+5. Cygwin/GCC (previously tested on 2.5.1)
+6. NVCC (CUDA 11.0 tested in CI)
+7. NVIDIA PGI (20.9 tested in CI)
+
+Supported Platforms
+-------------------
+
+* Windows, Linux, macOS, and iOS
+* CPython 3.8+, Pyodide, PyPy, and GraalPy
+* C++11, C++14, C++17, C++20, and C++23
+
+About
+-----
+
+This project was created by `Wenzel
+Jakob <http://rgl.epfl.ch/people/wjakob>`_. Significant features and/or
+improvements to the code were contributed by
+Jonas Adler,
+Lori A. Burns,
+Sylvain Corlay,
+Eric Cousineau,
+Aaron Gokaslan,
+Ralf Grosse-Kunstleve,
+Trent Houliston,
+Axel Huebl,
+@hulucc,
+Yannick Jadoul,
+Sergey Lyskov,
+Johan Mabille,
+Tomasz Miąsko,
+Dean Moldovan,
+Ben Pritchard,
+Jason Rhinelander,
+Boris Schäling,
+Pim Schellart,
+Henry Schreiner,
+Ivan Smirnov,
+Dustin Spicuzza,
+Boris Staletic,
+Ethan Steinberg,
+Patrick Stewart,
+Ivor Wanders,
+and
+Xiaofei Wang.
+
+We thank Google for a generous financial contribution to the continuous
+integration infrastructure used by this project.
+
+
+Contributing
+~~~~~~~~~~~~
+
+See the `contributing
+guide <https://github.com/pybind/pybind11/blob/master/.github/CONTRIBUTING.md>`_
+for information on building and contributing to pybind11.
+
+License
+~~~~~~~
+
+pybind11 is provided under a BSD-style license that can be found in the
+`LICENSE <https://github.com/pybind/pybind11/blob/master/LICENSE>`_
+file. By using, distributing, or contributing to this project, you agree
+to the terms and conditions of this license.
+
+.. |Latest Documentation Status| image:: https://readthedocs.org/projects/pybind11/badge?version=latest
+   :target: http://pybind11.readthedocs.org/en/latest
+.. |Stable Documentation Status| image:: https://img.shields.io/badge/docs-stable-blue.svg
+   :target: http://pybind11.readthedocs.org/en/stable
+.. |Gitter chat| image:: https://img.shields.io/gitter/room/gitterHQ/gitter.svg
+   :target: https://gitter.im/pybind/Lobby
+.. |CI| image:: https://github.com/pybind/pybind11/workflows/CI/badge.svg
+   :target: https://github.com/pybind/pybind11/actions
+.. |Build status| image:: https://ci.appveyor.com/api/projects/status/riaj54pn4h08xy40?svg=true
+   :target: https://ci.appveyor.com/project/wjakob/pybind11
+.. |PyPI package| image:: https://img.shields.io/pypi/v/pybind11.svg
+   :target: https://pypi.org/project/pybind11/
+.. |Conda-forge| image:: https://img.shields.io/conda/vn/conda-forge/pybind11.svg
+   :target: https://github.com/conda-forge/pybind11-feedstock
+.. |Repology| image:: https://repology.org/badge/latest-versions/python:pybind11.svg
+   :target: https://repology.org/project/python:pybind11/versions
+.. |Python Versions| image:: https://img.shields.io/pypi/pyversions/pybind11.svg
+   :target: https://pypi.org/project/pybind11/
+.. |GitHub Discussions| image:: https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github
+   :target: https://github.com/pybind/pybind11/discussions
+.. |SPEC 4 — Using and Creating Nightly Wheels| image:: https://img.shields.io/badge/SPEC-4-green?labelColor=%23004811&color=%235CA038
+   :target: https://scientific-python.org/specs/spec-0004/
diff --git a/local_pybind11/pybind11-3.0.1.dist-info/RECORD b/local_pybind11/pybind11-3.0.1.dist-info/RECORD
new file mode 100644
index 000000000..305d3c37f
--- /dev/null
+++ b/local_pybind11/pybind11-3.0.1.dist-info/RECORD
@@ -0,0 +1,84 @@
+../../bin/pybind11-config,sha256=MQQCbAQzcC7SfjebYRmlCz8NhRqh-gwwJWzQj2n1MBs,194
+pybind11-3.0.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pybind11-3.0.1.dist-info/METADATA,sha256=NwyJdnf7PoRa1sahxbcAKDhGLm4T9yqfNQ1nsX_XgoY,9972
+pybind11-3.0.1.dist-info/RECORD,,
+pybind11-3.0.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pybind11-3.0.1.dist-info/WHEEL,sha256=RvrF-7uxi1luUPlepZTxlP8hTMhuH1uDO6xLazIetwc,96
+pybind11-3.0.1.dist-info/entry_points.txt,sha256=G0kSYXdF_FFpb9vCIdFK_2Z_sKueUB5ZRTh4VW7fRTg,156
+pybind11-3.0.1.dist-info/licenses/LICENSE,sha256=g5ZbhDuY9nDTqFvQQe1LNyyOxQ17SlmVqDrGl7pnXcs,1684
+pybind11/__init__.py,sha256=JAglzfa8wABNM94gpzQSos84wolF_mk1MrvmkLbZxr0,459
+pybind11/__main__.py,sha256=Om1TLSoVHDZcDB0B0M91N-LekUgaBT098Eb48CSW98A,2966
+pybind11/__pycache__/__init__.cpython-313.pyc,,
+pybind11/__pycache__/__main__.cpython-313.pyc,,
+pybind11/__pycache__/_version.cpython-313.pyc,,
+pybind11/__pycache__/commands.cpython-313.pyc,,
+pybind11/__pycache__/setup_helpers.cpython-313.pyc,,
+pybind11/_version.py,sha256=kMz5J0qOM6W-w5ZrgSqhSg12V6KhYkx5dorVIcuSABE,231
+pybind11/commands.py,sha256=V43hKb7VE_abYZvaO-TpJLOU65n6W3ZrdYHGF3G3qUs,1243
+pybind11/include/pybind11/attr.h,sha256=vebbnaWl9emUIhf2kxjBdVrpQ7dcrSh7TfEsyyPSd9Q,26223
+pybind11/include/pybind11/buffer_info.h,sha256=_FcQisqdpphfWXKeCGNv3Gq5ivy1z-qF3d1Noeteaok,7778
+pybind11/include/pybind11/cast.h,sha256=fTPbBo5s8y-xOEoF8Y91RvaDMSKEwz_-5VRvP4N2xsk,93239
+pybind11/include/pybind11/chrono.h,sha256=sAvp8lFFMjk21UR3z6xqwHljwLhLhmyeRKAVgCgOmuI,8613
+pybind11/include/pybind11/common.h,sha256=ATg9Bt1pwF8qnNuI086fprM4CUTdrZdk_g2HXE1Sf6A,120
+pybind11/include/pybind11/complex.h,sha256=AaDZ-rEmK4tFaue-K9P5y3TxxnaQF6JwZ_6LAzkdLQI,2096
+pybind11/include/pybind11/conduit/README.txt,sha256=iERT5lUz_gCvLUVaTdqpvpxWFSBQaeP6MN8g7fqfqkI,298
+pybind11/include/pybind11/conduit/pybind11_conduit_v1.h,sha256=Ga99mDEHaQoCUOU94CV6svOUyZ0rIEbL8M24RkP_3Pw,4153
+pybind11/include/pybind11/conduit/pybind11_platform_abi_id.h,sha256=VUZW4H7iy9vVUzgLdJ1992wl4NnN6sMCWdtZn1Yxd_Y,3991
+pybind11/include/pybind11/conduit/wrap_include_python_h.h,sha256=uGyR7aUeOB6EEZGfb19TZ8sycP7ebZ2w5xMaIBMibTM,2069
+pybind11/include/pybind11/critical_section.h,sha256=Yly5WXAyGP5y9y-X0DjyGAH2dtEqXuWnI-TrnWMHdYk,1610
+pybind11/include/pybind11/detail/class.h,sha256=VYVUcXMJTgynGn2KR1NS87btNzZs9I2TxQEQP9c2VHM,31236
+pybind11/include/pybind11/detail/common.h,sha256=OMhAeFejhkoaLmFByDfdH51k7MTcTTh6KxEzrY31pgw,59916
+pybind11/include/pybind11/detail/cpp_conduit.h,sha256=JzhMXFgLYUKlYWX-hcyfVQV6RrRQIOaQ5TnNgSDPBMQ,2553
+pybind11/include/pybind11/detail/descr.h,sha256=d308RZ93L0FLE7MKSGfX3JmTrCY8w_OvUhEGhEviGnQ,8061
+pybind11/include/pybind11/detail/dynamic_raw_ptr_cast_if_possible.h,sha256=1qWaNlH6-j9n5VoEF70zCOrNz6JpFLFu6gqdYtNFL34,1176
+pybind11/include/pybind11/detail/exception_translation.h,sha256=MsiLvxqQF6Cs86EWkmA9dU0FSc7SV7VOGPcTmNdHqwc,2593
+pybind11/include/pybind11/detail/function_record_pyobject.h,sha256=P6CKWg2kj4IHc0ZyCBYpN-yhj6ITibakJcS4GvYIJpI,7738
+pybind11/include/pybind11/detail/init.h,sha256=10bs-B1oL9qy49HTwdEaotv9nO_pSLMHheQUHZwZ-B8,23073
+pybind11/include/pybind11/detail/internals.h,sha256=YK6RUWZBdb0ChIQino7mkSXpA_DwJsylAq6o86BHMpo,32201
+pybind11/include/pybind11/detail/native_enum_data.h,sha256=Oz4rQR_JLUw4mmg3oMRjCoX9iGT0BC-RcG4gp9D3ksQ,7633
+pybind11/include/pybind11/detail/pybind11_namespace_macros.h,sha256=HUAuCahRetQ2cadpkUuL4rNpAuzxAWHBgCCCVG8F7eQ,3501
+pybind11/include/pybind11/detail/struct_smart_holder.h,sha256=5Kjp3yxcKYsrTJ7vyvn_4EK59BkSH38ozpFRv1PF8wE,15072
+pybind11/include/pybind11/detail/type_caster_base.h,sha256=I9E5F8FV7zvcovJM19T28rIHdoqMlhU2PtShIxEDwgc,66193
+pybind11/include/pybind11/detail/typeid.h,sha256=jw5pr9m72vkDsloT8vxl9wj17VJGcEdXDyziBlt89Js,1625
+pybind11/include/pybind11/detail/using_smart_holder.h,sha256=sD2hYVl5H4u8UImqmi5ST9oftDQUPkJ6yR3qR3leQkQ,540
+pybind11/include/pybind11/detail/value_and_holder.h,sha256=NFH60tNJk6LqS1WgRagiI8irkoh5ATqoV0EDV2QZeKE,3677
+pybind11/include/pybind11/eigen.h,sha256=-HmSA1kgwCQ-GHUt7PHtTEc-vxqw9xARpF8PHWJip28,316
+pybind11/include/pybind11/eigen/common.h,sha256=dIeqmK7IzW5K4k2larPnA1A863rDp38U9YbNIwiIyYk,378
+pybind11/include/pybind11/eigen/matrix.h,sha256=R3Pp9BwEpPKCQcl6AeOXQBgeRqKJVmQ340D7ggG1DcY,32590
+pybind11/include/pybind11/eigen/tensor.h,sha256=sRlIdsklN1-Xp8Bd4kaAF8e9Wzw13W-JBevvfp6pj4Y,18660
+pybind11/include/pybind11/embed.h,sha256=J58UlVLoyErtlBLhMh1SG3ddQZGHjwr1cUlErigrIQA,12636
+pybind11/include/pybind11/eval.h,sha256=XB81cxFtBgeTuCVbT947IgITQ1fnwrQQVwQHjngiarE,4862
+pybind11/include/pybind11/functional.h,sha256=6RnBoyINKpqT6tPf_Wy0Rg2ijqztgMnmjPvlju1EJUo,5344
+pybind11/include/pybind11/gil.h,sha256=bQbpSuQNafii_9WP9KU675waSFp_uVVPH54gMXzGob0,6743
+pybind11/include/pybind11/gil_safe_call_once.h,sha256=k3tJI8FZ6HAihw545nmMy5RQ1n4NOe6dMK1vpiotk1o,4054
+pybind11/include/pybind11/gil_simple.h,sha256=AuO9mC1devdjTnXOe0aJGsnJuSC3nerWnG17HVQQX9k,1185
+pybind11/include/pybind11/iostream.h,sha256=K5rPXoCYN325r1PptcJCIhPhgtRtTJQjMr7bvUIOwxk,8862
+pybind11/include/pybind11/native_enum.h,sha256=1lygzHNaQg9GIPSu7H72-fc1duWcTRWFYuTKweE_riU,2477
+pybind11/include/pybind11/numpy.h,sha256=-JB0miCYKBkLMcfm2AnHMYGRatOMJO3J_UJr5sfJ2BE,91577
+pybind11/include/pybind11/operators.h,sha256=224RoAXcv1la4NNY9rQ3aD_AeC8S9ZKx3HVK1O8B4MU,9103
+pybind11/include/pybind11/options.h,sha256=qXvmnj--9fZSp56NYefnB3W5V17ppHlY1Srgo3DNBpw,2734
+pybind11/include/pybind11/pybind11.h,sha256=XrPy7iJL_SKH449j6iGfNpFSX2nk19u2cQ3nwsQmwPo,160679
+pybind11/include/pybind11/pytypes.h,sha256=yZHlh8YGKS8MQ8G6tzYBpZ0TxQoiEOc9iy639J1K7aE,102198
+pybind11/include/pybind11/stl.h,sha256=6oO0ogJ7EGM5P5VG4dMsZjDKnr1wIuCRHcAhDkJZyc4,24742
+pybind11/include/pybind11/stl/filesystem.h,sha256=ttMpBWKQ_j6-y_TQ7Q0XdnX_9Peb-jXL4B0tbVJk18w,4073
+pybind11/include/pybind11/stl_bind.h,sha256=ZUNjJLmMTNH_HdgvyLWNpD9lmo6Ry-nJPKD2hh9a0Ks,29646
+pybind11/include/pybind11/subinterpreter.h,sha256=OsnO6BMz1FaC9y3C4WQ9lEjxaNUMJnX21ApoJFWkcOs,11467
+pybind11/include/pybind11/trampoline_self_life_support.h,sha256=-TX9w5TxI1XX3AG255lMLdiCyR-dZkM321wFsedynx8,2673
+pybind11/include/pybind11/type_caster_pyobject_ptr.h,sha256=H7pKBYTvUlibiJQEcKmeAkygSQwoCkuIyukNSDmVq-U,1929
+pybind11/include/pybind11/typing.h,sha256=8gMTwmNvXa-8_BNQ0PaR1K3mZrWJlpFXiVslVRC_Yo4,8891
+pybind11/include/pybind11/warnings.h,sha256=idcBNK5eEXxYBfPeVuycLxcgMrKuvRzQI33BapJ8G4g,2368
+pybind11/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pybind11/setup_helpers.py,sha256=7Igm9dlwT93mQHSYB1Nq07nEJNX2fmhdYAQM0WMOxvU,17488
+pybind11/share/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pybind11/share/__pycache__/__init__.cpython-313.pyc,,
+pybind11/share/cmake/pybind11/FindPythonLibsNew.cmake,sha256=xWqtRNU5ppQSNjGSmDY7KgIyKbegz768IkNfGaWx5DM,12772
+pybind11/share/cmake/pybind11/pybind11Common.cmake,sha256=nYcbd5mVglDFkf-RNbkEApL-XPE9Rbp_egI7lyrCY_E,15993
+pybind11/share/cmake/pybind11/pybind11Config.cmake,sha256=LzrsyS4YLDZ3P-5cz3SWEu3DtuW3m3lFij6nt5OfSOI,8376
+pybind11/share/cmake/pybind11/pybind11ConfigVersion.cmake,sha256=kzotpxbMTZxlq6vfVQ826UH0DL-028gE1aI8TInfC4k,1402
+pybind11/share/cmake/pybind11/pybind11GuessPythonExtSuffix.cmake,sha256=-kCn2M0PKzfkqnZLawu1A2_AzkTJxwjuBPb0ELSFBQI,3328
+pybind11/share/cmake/pybind11/pybind11NewTools.cmake,sha256=xj2sgwSkqt-g-2fzsKv9sdpuqjvZCcDxtnDDM7PtFvU,12952
+pybind11/share/cmake/pybind11/pybind11Targets.cmake,sha256=wNKPyP7nBhRwzKUhjngZ1MTwcjYzqqagFmpjLTerDMQ,4271
+pybind11/share/cmake/pybind11/pybind11Tools.cmake,sha256=ZFgc9b-32cODVG5M0zCPzJaxnE36ngtAh-zdh7F7FjA,7906
+pybind11/share/pkgconfig/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pybind11/share/pkgconfig/__pycache__/__init__.cpython-313.pyc,,
+pybind11/share/pkgconfig/pybind11.pc,sha256=aE8x6u70o5qEUfzutKq0PeTHz8gC7YM7H_Hp8aDDzTQ,170
diff --git a/local_pybind11/pybind11-3.0.1.dist-info/REQUESTED b/local_pybind11/pybind11-3.0.1.dist-info/REQUESTED
new file mode 100644
index 000000000..e69de29bb
diff --git a/local_pybind11/pybind11-3.0.1.dist-info/WHEEL b/local_pybind11/pybind11-3.0.1.dist-info/WHEEL
new file mode 100644
index 000000000..6f06dbc5c
--- /dev/null
+++ b/local_pybind11/pybind11-3.0.1.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.11.5
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/local_pybind11/pybind11-3.0.1.dist-info/entry_points.txt b/local_pybind11/pybind11-3.0.1.dist-info/entry_points.txt
new file mode 100644
index 000000000..f58bb807a
--- /dev/null
+++ b/local_pybind11/pybind11-3.0.1.dist-info/entry_points.txt
@@ -0,0 +1,9 @@
+[pipx.run]
+pybind11 = pybind11.__main__:main
+
+[pkg_config]
+pybind11 = pybind11.share.pkgconfig
+
+[console_scripts]
+pybind11-config = pybind11.__main__:main
+
diff --git a/local_pybind11/pybind11-3.0.1.dist-info/licenses/LICENSE b/local_pybind11/pybind11-3.0.1.dist-info/licenses/LICENSE
new file mode 100644
index 000000000..e466b0dfd
--- /dev/null
+++ b/local_pybind11/pybind11-3.0.1.dist-info/licenses/LICENSE
@@ -0,0 +1,29 @@
+Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>, 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.
+
+Please also refer to the file .github/CONTRIBUTING.md, which clarifies licensing of
+external contributions to this project including patches, pull requests, etc.
diff --git a/local_pybind11/pybind11/__init__.py b/local_pybind11/pybind11/__init__.py
new file mode 100644
index 000000000..e9d033c4b
--- /dev/null
+++ b/local_pybind11/pybind11/__init__.py
@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import sys
+
+if sys.version_info < (3, 8):  # noqa: UP036
+    msg = "pybind11 does not support Python < 3.8. v2.13 was the last release supporting Python 3.7."
+    raise ImportError(msg)
+
+
+from ._version import __version__, version_info
+from .commands import get_cmake_dir, get_include, get_pkgconfig_dir
+
+__all__ = (
+    "version_info",
+    "__version__",
+    "get_include",
+    "get_cmake_dir",
+    "get_pkgconfig_dir",
+)
diff --git a/local_pybind11/pybind11/__main__.py b/local_pybind11/pybind11/__main__.py
new file mode 100644
index 000000000..21c3cd9ab
--- /dev/null
+++ b/local_pybind11/pybind11/__main__.py
@@ -0,0 +1,97 @@
+# pylint: disable=missing-function-docstring
+from __future__ import annotations
+
+import argparse
+import functools
+import re
+import sys
+import sysconfig
+
+from ._version import __version__
+from .commands import get_cmake_dir, get_include, get_pkgconfig_dir
+
+# This is the conditional used for os.path being posixpath
+if "posix" in sys.builtin_module_names:
+    from shlex import quote
+elif "nt" in sys.builtin_module_names:
+    # See https://github.com/mesonbuild/meson/blob/db22551ed9d2dd7889abea01cc1c7bba02bf1c75/mesonbuild/utils/universal.py#L1092-L1121
+    # and the original documents:
+    # https://docs.microsoft.com/en-us/cpp/c-language/parsing-c-command-line-arguments and
+    # https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/
+    UNSAFE = re.compile("[ \t\n\r]")
+
+    def quote(s: str) -> str:
+        if s and not UNSAFE.search(s):
+            return s
+
+        # Paths cannot contain a '"' on Windows, so we don't need to worry
+        # about nuanced counting here.
+        return f'"{s}\\"' if s.endswith("\\") else f'"{s}"'
+else:
+
+    def quote(s: str) -> str:
+        return s
+
+
+def print_includes() -> None:
+    dirs = [
+        sysconfig.get_path("include"),
+        sysconfig.get_path("platinclude"),
+        get_include(),
+    ]
+
+    # Make unique but preserve order
+    unique_dirs = []
+    for d in dirs:
+        if d and d not in unique_dirs:
+            unique_dirs.append(d)
+
+    print(" ".join(quote(f"-I{d}") for d in unique_dirs))
+
+
+def main() -> None:
+    make_parser = functools.partial(argparse.ArgumentParser, allow_abbrev=False)
+    if sys.version_info >= (3, 14):
+        make_parser = functools.partial(make_parser, color=True, suggest_on_error=True)
+    parser = make_parser()
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=__version__,
+        help="Print the version and exit.",
+    )
+    parser.add_argument(
+        "--includes",
+        action="store_true",
+        help="Include flags for both pybind11 and Python headers.",
+    )
+    parser.add_argument(
+        "--cmakedir",
+        action="store_true",
+        help="Print the CMake module directory, ideal for setting -Dpybind11_ROOT in CMake.",
+    )
+    parser.add_argument(
+        "--pkgconfigdir",
+        action="store_true",
+        help="Print the pkgconfig directory, ideal for setting $PKG_CONFIG_PATH.",
+    )
+    parser.add_argument(
+        "--extension-suffix",
+        action="store_true",
+        help="Print the extension for a Python module",
+    )
+    args = parser.parse_args()
+    if not sys.argv[1:]:
+        parser.print_help()
+    if args.includes:
+        print_includes()
+    if args.cmakedir:
+        print(quote(get_cmake_dir()))
+    if args.pkgconfigdir:
+        print(quote(get_pkgconfig_dir()))
+    if args.extension_suffix:
+        print(sysconfig.get_config_var("EXT_SUFFIX"))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/local_pybind11/pybind11/__pycache__/__init__.cpython-313.pyc b/local_pybind11/pybind11/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..50fea84fd043d451b93d5664ddd48598be81f8d7
GIT binary patch
literal 643
zcmYLFzi-n(6h8YB+p(Jg3Jev)DVv8ngs7sFiX~#ekr2WYQlyg;UtFvHrFZ9|bb|k&
z3x5QE3ky{T;3Nc6r)-rnuyU8k;tk)uclW;UzV|l$zKc}!@gVzZAatvXHt;SnHbNzz
zQG_C6ib4YnqH}X<f;ltaS#A6OGr}kL5sH;^)Pc^dJ3zC}ky6*ejHnw~Q!BK=4l!V*
z)s5__6ZW7Ny5NQ$c<Ro9z0~x3YfbSD>BVJPiCAP+$=~?qT3cH?3NGK*t9e!?qY+6e
z#);}8ys7I71bMp>XH`i~$v8L;$i>rOG$tQnPQ)1_dCUa?ma~|%mXMWc%NYmHg0*(+
zo6@87f&o`wQ!4k`G%J^tk7Yk)f-Z{qoY5o$>FF{n7kQH~c~2MhdAg{|WtQr9zYE$l
z*c$ZWp{K!9;P<6V>9P?GFiJrWC^290EkWXfr_y^}=(%12R3M$!)K*M7i>fH%GT}SL
zt+tkxHl=Z%Q~CvMREgyAP!#pB&gw%EgEDwHdY+1APLGCpHXqj8m8oO5(;-#EWP;M5
zUP<S)sFEgUFX53A(#zp56x?CMFn*!IEpq>0>pR}R#`{;x8~pf(%RWwix(}}wH}1i=
Z&cR;`8Bczr$u*kXbu7>PWWxi+{|7<_tLp#&

literal 0
HcmV?d00001

diff --git a/local_pybind11/pybind11/__pycache__/__main__.cpython-313.pyc b/local_pybind11/pybind11/__pycache__/__main__.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8a33a739dc05e0d772ee5cde5d0334e640603e90
GIT binary patch
literal 3941
zcmahMO>+}Rwr4aWjWm*M$)DH;24e$Ct?W2Juz@87CI+nXM>IG~AyZRhX)I47k3`Ri
z7}ciAwN+bjHmTsPg^l;L9QF`$;+Vt!fIT7vE2VKIhineqoPs^<ZC|%EGIscAd%9ou
zd;R*oejokxEEEbLXdzF(`BxdCpXkJGo;tuiYvmBSgH)t)2{g%JPN6WL;4#le5B9K8
zzycdZEV9vyy{bnQ623_ZOR&eIiV6Q@00$;zEKde;5Z1i&VzS3QaC<xjpzcHT9A6?l
z*@9aXG!s{)*HCvOG%qBTZ5}Svk5vD0(111^QCrkN5Bf;JEi)p(avfG%)gXhS0EHOT
zHs7v>PhJ5zB;efEkB-+_AO&UlEFX(JrSlj^WZkmzj_#Ow%btEp52A~jcEi9ntZ7=z
zLqb`@(bCKM$A*?MF_G!iw9>g^#vl<oDSVtw=dDFE%kW|$Z<{OkI3ivz<{g9ZmQ(Vk
z6n`LeE#1(B2}3OeANTA_0PdhUbc8K~%zX%@8Zbi1h9#Q|0L&rxPTV~io~{nSmlR*5
ztivj|n_l;VefT*P2Fo7x47e~);g~Q@xOu|$m-zX9(BC^Zt)88DpLlIU$LS>^8CJ&r
z#B`QGN6xmXP6`<vc9sjn1+x%$bPSgg9~sL!#Rcv7aL!y9F5GmM@)isWrj;2P8P>FA
z-Gtj6D%`~2xrlXL0NCTut)d^~;O!5;zV_#9cSoungXNCFT3h?t#VrZ#+yD2gf4lmP
zP~96Z?~SiV)<@P4uB&UM2hyqgAKbrwKmA?g{wPeI0UNaAx~Z7#x<PYx-JmEpeGlO_
znAerS9RP02qfi9+G00PEX<d_WC%|d=nvJqzJSE_M=S8D|Id(U2<)#^4Fz?GLdDmd6
zra4^~9`;yh7+KsLYC{(X5VH6={zW&K3L<pnz$uW3I>i*IH^(KZ8oSzD^9%(|9YRP(
z3QGB1BGr?mhS}9rp$E9NHN(l3(j6hZP)wXAJ~uw(LJoqf5iFdt!y;6(qci}{0B{ga
zr$GQZfy5S<0{QDrg%iW*Xj9r7=#B^ygRQ8<S?+{qk&E#qK7MH$(|j1?2|x5U;W9S8
zT18=2CH~V{!!lM1_zXEvz^2s<VSDIwE}zzO_L-q3$p~z;Aqvq`u>FJR=(mZx*KZ%+
zcxOZ3P&c~2esBG~ZxjEs1t9oC?_MtEC4T#+T~7f-Vi`eqmN30@;?)ZUh!-NVLy7QF
z-n1a51jr;dk&Bjjy~xsvjrY?-!J9zjhRoreg5nq;!QjZwLAQ$jBSorG&qJwaW2_<#
zZZ>DXtw^y=sqKr<mQM(JSI=*SQCr7q;z=m7#{DP<*GASOk0XP%U{^J`uN>UBasA)H
z1HXtU9DOb!F|c;<){)PTl%u2f5|!v^B{2F}82h#7Q{9;7_d)+=&ri|2Vl7EyW>-@=
zl^^3Rl!9bkZ%OvBxwHDHdQScmk|PA+o1$k9sRI0oV-P8GXgm2s%y7xjPOfyOdR1R4
z?5?Yl>K_vn8Z|GY4XCmjR6}E)S5kz5qUE&|tw0fZEkzV4+L{y*SGMiZ%?1|#!mUNO
z@h+sct4L@*Etyu94QQU*)m(m{6`!PuZdY?Nj1HDb?QxMicD<w&Xzrp<+Fo~8in=;$
zsRJ(La&j|?J2H9tU8?QzjhqKv+ShW1ytlhGIV(G4c9&7|t=&5i_?X(^O6-m_7eY4d
zoSuM^BB<wb`A;-`VF4RAV*FDY=TE82U50cert`TxCarccn>B1lgSx}OIFC#Ic)U@F
z5MKi*_0H1lr8rB5(pXY-E29`IrZYqzYduYi8T>ZzCc=`DE0hB9cq0SbBw#yvY-kQH
z8l|I`>UmjN%;{NMS<GW)A@3|H?kmms&a#(VSu*qtlte=@9@FHA-+_)YW@QoNveMMH
zSmRSrDk;nPOfhFDfHTr?=FQ(IX2#HS>=@f{;8Dmb@$>FkT5@LQvSL~a+dNbX$K%ba
zin2eq&Az$*dfo%Gi3{5J%=E;i3)<}2%NK`A(RkcgaSV$Vc5%D7xM;4F4sY{q;+TlK
z($KuF2c`*(1m3@LSySgGCN5oxbrSz#(E`=-Ih*(jI(AGwM<ghI0JaShK8v%(Wy5l2
z=@b(WJP{=5)|IBUm<OlGWHi{o$S{2lNq}vpi#8FUzX2=kwW5|Jl50oy6cEY1eN3Ib
zUbxWoN`lQhg1f^KU21Krr`1)*G^j|JzE+Lm^@fhYfn-+bGBGgmHbyFnz4LJrXa$Ea
z0Fz_z*$ePqucFOpZ#8=GVf5fXE>;Ill?P7!Yp@)hT}^EI0##pE+1IskqT=h{?A%}N
zJp8cp@Hg^z#~vg<EO-8HP5wUA{l&G_iJB0o3SDKPt0uM8TDmt|duyS$w){x!{soDm
zcPofQ*(GSNwE*_qmXBctzy^MWoqq+ko9+GJ71%z8eRl^o7_G{EWx1~+?^`{;DTi;3
zem=T>cKzH}r)yHUD(xvtdmc%>HJ|+1r=NYgDRn-Qx|@^Gm&Wa>zsyv^1COLZSgrcH
z;eS(t^+)Z4mG;Ax@R3JSjA8n!zCMaEtKmZr!-wwvz7jt6SUSGtLDF9K5EIEQpJM`U
zr&jdX4%iACP7z!960AU&PEv$0owtlw2MK7}ViB;0reT_T@Cn+{%t&}_;4wO5{vf%(
zeCqBfrSr?nkX~#|{fbpIb$4oCD4IElVXYn>nx!urHWBTmoUy_jk@#S1!OR&Lo*cyd
z6;o%S!c$@p1b*}(rck{?lTO!poxzs@LCZh81l^X0<G7zu|4*pp32J?U{7+B-fS=KU
zAJKRjjc<98Ag`t2vdZB@70;m`gx;FyUsJ20!E$J@A`XI6gj;W2{nOPAxe^*!o%pZd
p6;D5pa$@AU6yi=kS7O||TUR(F1lLLx&z|oE>5mg|*+LJK?f(#XKdt}(

literal 0
HcmV?d00001

diff --git a/local_pybind11/pybind11/__pycache__/_version.cpython-313.pyc b/local_pybind11/pybind11/__pycache__/_version.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c2c5f74dbbf50d6c979b86aecdaad64a6da14fe4
GIT binary patch
literal 779
zcmZXR&ubGw6vyA}?B@5H{)k#?v1^;l9-3_^#ae0`4}vHbbZLdOuq1X9SJK^OW)f`i
zP<s+Z=)s`i#iRWX{4=Z-)S;d{NN<IBP*1*18x@?x`?c@A{my4Px}E|&Ivw-Aq5m2s
zy%ReQNT-ZJ8*H%24Y*DiF~E-7$}rqlnPO8$SJg4F)nQnrx6{4hzuwlS$#FIa(<kL#
zg~jSIGjSMIO(N43-w#AZc!AIFp3HOyRJ0U;bmlQ=!+BWw^K}V&yYg@WR+Mf(nmAN6
z00WkQE2EHy8eFEMP$Ro!(NrY$d?8cIl}6LO%2>eg=Y;cUsUc@9u^w8X7fy%@tGi;N
zc&RR$RcG32cvUOh5cdKfUDfl~ibcz5xs0RWLbxI0jtCsw%p#_dW}Zj01xE_i`VX=L
zJH@B1$NG<h^yv-|t^ZTD?@8i_V)Tn=uyH%3!?Vl?eMLs-rZ!cWEENBvFdk8u!RB$i
zTN`gT2-o@meDV(w(j(G>wr0T10f01i*Wn_q5r$Ndbyp&SPzsYQffXKsGYpnQCzEq^
z*LNR;Y@X?uN80!hnnS$HyIkqLx$yeR^E)qZy(sULG5N_={J1?dj1UWprrKR7DHlw}
zm@Ash-%KJE<Dr2iGcHq(Q)^<`bsUDT3SBKS?etJOj?_dmY`9Y6VZ#$LbHW(e)`DH=
z;0zoqP0XzaYt4o`&mw)%`*8~mLM7x2jD3%(r2ps?WY27+KWB4$xzd|+AI;f4bN21j
S2XkRRSK7~(9%a~BocRqytfg!K

literal 0
HcmV?d00001

diff --git a/local_pybind11/pybind11/__pycache__/commands.cpython-313.pyc b/local_pybind11/pybind11/__pycache__/commands.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c26b59eb068fde30953bef58a070ebf0d49063e
GIT binary patch
literal 2200
zcmb`J&2Jk;6u@Uc;<eX=(2$0Zk7h_Bf=L<^p-@Vrawu)phUVZUSg290^?GA(YVVqv
zHNjTZCZ}+$50zyJ$ra+zN;yP`Ly!Ckj(kWp1SwKa+>lZ@^JeX}6G#<_Fw(wxGxO%n
z$NSB*54yWm1f^RVvwoEkdchlh>1ry%!4IH3LK@P91$0v&0_M87AQEv|j0Jr2P8|z%
zbYFXgW!N9@)XRZ6q1p0lqG$n4(WF7NDz6G8s0B5d>m&qPm#3*|F%tTnPm2gFtlPHZ
z>aOM3bkS%z^IY;HNeBrC!_fN(-S#@Uh>2~rt;AXv(Cz@`cKf)RFxQ%63;)4S+v%|@
zA9I17mHlfuv;*;k9UODbOM>s`z1CiIIM0$WftJJx6cI~AjhSwN*x1dOIIp`I>^e=o
zn6&KF>@2oyBU?zBIAsyja2-;d!C!!F#-h-$3_Xj-3e+THs!q~{oN2q*qPSo~Uuqib
zb_(b8B2Jo^m^tSgGc}_!rR6dbV4_2r%$H^Is$<zq`s_xGDX^5S=S&tbzlBw3L}D^u
zg1v6p)YY?DGnMe>gsD>?hUqmZL>ys^*~d{gmyhPH{CO94WV+{PFQ(l>GBFp;TFGd>
z=w=)ns^;mUhLg*|Ch1JR$iiTqXzh)>0q%nE(Jw))qn9e`AE?C3@yc>}`N#3c#m3p$
z^~Js3zRF~IvNBzs{+`s<s%y0e)dyR&G5X>5SB>6J*BACiMr-kEymqI0=gH#k$fcc;
zOW$3t%b));1mXZZBZCXSaPB;Ee+K2W<Z7ZO&B1f$#Xjj39K+%gI+h(YfixLjLz}h^
zW2O-4DqTF0s4KVhyC%*#sY3QJRx0bF8J(D{%gBKN3;IDSUH3H%FCKtwK``yBUJ?Mn
zzAgZxDNe9%7$&72$j#MOtgK0&1_-}lqHw{3OZc$~KM4!p$mJd4UM0jK5s~$IdjJ}a
z04L>Wn(~BzG3nv6x;ZjUQ-GEXLSHX@^g0NDCWwa5)h<*o)aI-6Thf#GcKTVVF?6#o
z59}$S&9#lS&HEeo>;3QVDpNbk)bpP4dT@MS)z+`<sb?P=4Rx?C50W$B>j)+7{Pq)!
zoSu?7{&JxF&x}Z~WJE4~bRr}9yJ^F*SFH4*yrYsgVVf+}9xE-J28^~F?7>0$!8t^J
zpxytE=##g>;7Ih(@aT8UIRWRuhJW-b2#)|f<|T%E)q7i4w%>X-)fl~2mxqtUe`Z&S
z?kLgcJ(Km|<h~mJcl;y5wTMh!1D{MzI!=}ah?lmRL|wp@U>G6qfQW>dnn<h^Ag7y&
z1mU6WFwYb{NqOcZ{Qm$8f+0K$F!P=P&v+ie-XWeM54<Mk!TIKEy-eN(BmP@UKLPQF
zBnZN9XzT?F?FWLJ>5cTJv*A2UR?_8k#VI?FGmZXeBk;kx^jAO;ZV4~@Lc-9W10X!#
Fe*-ql*J}U(

literal 0
HcmV?d00001

diff --git a/local_pybind11/pybind11/__pycache__/setup_helpers.cpython-313.pyc b/local_pybind11/pybind11/__pycache__/setup_helpers.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..15e60b4807c5102a1624ef8429e10ec22bd7ab99
GIT binary patch
literal 21400
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

literal 0
HcmV?d00001

diff --git a/local_pybind11/pybind11/_version.py b/local_pybind11/pybind11/_version.py
new file mode 100644
index 000000000..c9998204d
--- /dev/null
+++ b/local_pybind11/pybind11/_version.py
@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+
+def _to_int(s: str) -> int | str:
+    try:
+        return int(s)
+    except ValueError:
+        return s
+
+
+__version__ = "3.0.1"
+version_info = tuple(_to_int(s) for s in __version__.split("."))
diff --git a/local_pybind11/pybind11/commands.py b/local_pybind11/pybind11/commands.py
new file mode 100644
index 000000000..d535b6cca
--- /dev/null
+++ b/local_pybind11/pybind11/commands.py
@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import os
+
+DIR = os.path.abspath(os.path.dirname(__file__))
+
+
+def get_include(user: bool = False) -> str:  # noqa: ARG001
+    """
+    Return the path to the pybind11 include directory. The historical "user"
+    argument is unused, and may be removed.
+    """
+    installed_path = os.path.join(DIR, "include")
+    source_path = os.path.join(os.path.dirname(DIR), "include")
+    return installed_path if os.path.exists(installed_path) else source_path
+
+
+def get_cmake_dir() -> str:
+    """
+    Return the path to the pybind11 CMake module directory.
+    """
+    cmake_installed_path = os.path.join(DIR, "share", "cmake", "pybind11")
+    if os.path.exists(cmake_installed_path):
+        return cmake_installed_path
+
+    msg = "pybind11 not installed, installation required to access the CMake files"
+    raise ImportError(msg)
+
+
+def get_pkgconfig_dir() -> str:
+    """
+    Return the path to the pybind11 pkgconfig directory.
+    """
+    pkgconfig_installed_path = os.path.join(DIR, "share", "pkgconfig")
+    if os.path.exists(pkgconfig_installed_path):
+        return pkgconfig_installed_path
+
+    msg = "pybind11 not installed, installation required to access the pkgconfig files"
+    raise ImportError(msg)
diff --git a/local_pybind11/pybind11/include/pybind11/attr.h b/local_pybind11/pybind11/include/pybind11/attr.h
new file mode 100644
index 000000000..9b631fa48
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/attr.h
@@ -0,0 +1,722 @@
+/*
+    pybind11/attr.h: Infrastructure for processing custom
+    type and function attributes
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "detail/common.h"
+#include "cast.h"
+#include "trampoline_self_life_support.h"
+
+#include <functional>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+/// \addtogroup annotations
+/// @{
+
+/// Annotation for methods
+struct is_method {
+    handle class_;
+    explicit is_method(const handle &c) : class_(c) {}
+};
+
+/// Annotation for setters
+struct is_setter {};
+
+/// Annotation for operators
+struct is_operator {};
+
+/// Annotation for classes that cannot be subclassed
+struct is_final {};
+
+/// Annotation for parent scope
+struct scope {
+    handle value;
+    explicit scope(const handle &s) : value(s) {}
+};
+
+/// Annotation for documentation
+struct doc {
+    const char *value;
+    explicit doc(const char *value) : value(value) {}
+};
+
+/// Annotation for function names
+struct name {
+    const char *value;
+    explicit name(const char *value) : value(value) {}
+};
+
+/// Annotation indicating that a function is an overload associated with a given "sibling"
+struct sibling {
+    handle value;
+    explicit sibling(const handle &value) : value(value.ptr()) {}
+};
+
+/// Annotation indicating that a class derives from another given type
+template <typename T>
+struct base {
+
+    PYBIND11_DEPRECATED(
+        "base<T>() was deprecated in favor of specifying 'T' as a template argument to class_")
+    base() = default;
+};
+
+/// Keep patient alive while nurse lives
+template <size_t Nurse, size_t Patient>
+struct keep_alive {};
+
+/// Annotation indicating that a class is involved in a multiple inheritance relationship
+struct multiple_inheritance {};
+
+/// Annotation which enables dynamic attributes, i.e. adds `__dict__` to a class
+struct dynamic_attr {};
+
+/// Annotation which enables the buffer protocol for a type
+struct buffer_protocol {};
+
+/// Annotation which enables releasing the GIL before calling the C++ destructor of wrapped
+/// instances (pybind/pybind11#1446).
+struct release_gil_before_calling_cpp_dtor {};
+
+/// Annotation which requests that a special metaclass is created for a type
+struct metaclass {
+    handle value;
+
+    PYBIND11_DEPRECATED("py::metaclass() is no longer required. It's turned on by default now.")
+    metaclass() = default;
+
+    /// Override pybind11's default metaclass
+    explicit metaclass(handle value) : value(value) {}
+};
+
+/// Specifies a custom callback with signature `void (PyHeapTypeObject*)` that
+/// may be used to customize the Python type.
+///
+/// The callback is invoked immediately before `PyType_Ready`.
+///
+/// Note: This is an advanced interface, and uses of it may require changes to
+/// work with later versions of pybind11.  You may wish to consult the
+/// implementation of `make_new_python_type` in `detail/classes.h` to understand
+/// the context in which the callback will be run.
+struct custom_type_setup {
+    using callback = std::function<void(PyHeapTypeObject *heap_type)>;
+
+    explicit custom_type_setup(callback value) : value(std::move(value)) {}
+
+    callback value;
+};
+
+/// Annotation that marks a class as local to the module:
+struct module_local {
+    const bool value;
+    constexpr explicit module_local(bool v = true) : value(v) {}
+};
+
+/// Annotation to mark enums as an arithmetic type
+struct arithmetic {};
+
+/// Mark a function for addition at the beginning of the existing overload chain instead of the end
+struct prepend {};
+
+/** \rst
+    A call policy which places one or more guard variables (``Ts...``) around the function call.
+
+    For example, this definition:
+
+    .. code-block:: cpp
+
+        m.def("foo", foo, py::call_guard<T>());
+
+    is equivalent to the following pseudocode:
+
+    .. code-block:: cpp
+
+        m.def("foo", [](args...) {
+            T scope_guard;
+            return foo(args...); // forwarded arguments
+        });
+ \endrst */
+template <typename... Ts>
+struct call_guard;
+
+template <>
+struct call_guard<> {
+    using type = detail::void_type;
+};
+
+template <typename T>
+struct call_guard<T> {
+    static_assert(std::is_default_constructible<T>::value,
+                  "The guard type must be default constructible");
+
+    using type = T;
+};
+
+template <typename T, typename... Ts>
+struct call_guard<T, Ts...> {
+    struct type {
+        T guard{}; // Compose multiple guard types with left-to-right default-constructor order
+        typename call_guard<Ts...>::type next{};
+    };
+};
+
+/// @} annotations
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+/* Forward declarations */
+enum op_id : int;
+enum op_type : int;
+struct undefined_t;
+template <op_id id, op_type ot, typename L = undefined_t, typename R = undefined_t>
+struct op_;
+void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret);
+
+/// Internal data structure which holds metadata about a keyword argument
+struct argument_record {
+    const char *name;  ///< Argument name
+    const char *descr; ///< Human-readable version of the argument value
+    handle value;      ///< Associated Python object
+    bool convert : 1;  ///< True if the argument is allowed to convert when loading
+    bool none : 1;     ///< True if None is allowed when loading
+
+    argument_record(const char *name, const char *descr, handle value, bool convert, bool none)
+        : name(name), descr(descr), value(value), convert(convert), none(none) {}
+};
+
+/// Internal data structure which holds metadata about a bound function (signature, overloads,
+/// etc.)
+#define PYBIND11_DETAIL_FUNCTION_RECORD_ABI_ID "v1" // PLEASE UPDATE if the struct is changed.
+struct function_record {
+    function_record()
+        : is_constructor(false), is_new_style_constructor(false), is_stateless(false),
+          is_operator(false), is_method(false), is_setter(false), has_args(false),
+          has_kwargs(false), prepend(false) {}
+
+    /// Function name
+    char *name = nullptr; /* why no C++ strings? They generate heavier code.. */
+
+    // User-specified documentation string
+    char *doc = nullptr;
+
+    /// Human-readable version of the function signature
+    char *signature = nullptr;
+
+    /// List of registered keyword arguments
+    std::vector<argument_record> args;
+
+    /// Pointer to lambda function which converts arguments and performs the actual call
+    handle (*impl)(function_call &) = nullptr;
+
+    /// Storage for the wrapped function pointer and captured data, if any
+    void *data[3] = {};
+
+    /// Pointer to custom destructor for 'data' (if needed)
+    void (*free_data)(function_record *ptr) = nullptr;
+
+    /// Return value policy associated with this function
+    return_value_policy policy = return_value_policy::automatic;
+
+    /// True if name == '__init__'
+    bool is_constructor : 1;
+
+    /// True if this is a new-style `__init__` defined in `detail/init.h`
+    bool is_new_style_constructor : 1;
+
+    /// True if this is a stateless function pointer
+    bool is_stateless : 1;
+
+    /// True if this is an operator (__add__), etc.
+    bool is_operator : 1;
+
+    /// True if this is a method
+    bool is_method : 1;
+
+    /// True if this is a setter
+    bool is_setter : 1;
+
+    /// True if the function has a '*args' argument
+    bool has_args : 1;
+
+    /// True if the function has a '**kwargs' argument
+    bool has_kwargs : 1;
+
+    /// True if this function is to be inserted at the beginning of the overload resolution chain
+    bool prepend : 1;
+
+    /// Number of arguments (including py::args and/or py::kwargs, if present)
+    std::uint16_t nargs;
+
+    /// Number of leading positional arguments, which are terminated by a py::args or py::kwargs
+    /// argument or by a py::kw_only annotation.
+    std::uint16_t nargs_pos = 0;
+
+    /// Number of leading arguments (counted in `nargs`) that are positional-only
+    std::uint16_t nargs_pos_only = 0;
+
+    /// Python method object
+    PyMethodDef *def = nullptr;
+
+    /// Python handle to the parent scope (a class or a module)
+    handle scope;
+
+    /// Python handle to the sibling function representing an overload chain
+    handle sibling;
+
+    /// Pointer to next overload
+    function_record *next = nullptr;
+};
+// The main purpose of this macro is to make it easy to pin-point the critically related code
+// sections.
+#define PYBIND11_ENSURE_PRECONDITION_FOR_FUNCTIONAL_H_PERFORMANCE_OPTIMIZATIONS(...)              \
+    static_assert(                                                                                \
+        __VA_ARGS__,                                                                              \
+        "Violation of precondition for pybind11/functional.h performance optimizations!")
+
+/// Special data structure which (temporarily) holds metadata about a bound class
+struct type_record {
+    PYBIND11_NOINLINE type_record()
+        : multiple_inheritance(false), dynamic_attr(false), buffer_protocol(false),
+          module_local(false), is_final(false), release_gil_before_calling_cpp_dtor(false) {}
+
+    /// Handle to the parent scope
+    handle scope;
+
+    /// Name of the class
+    const char *name = nullptr;
+
+    // Pointer to RTTI type_info data structure
+    const std::type_info *type = nullptr;
+
+    /// How large is the underlying C++ type?
+    size_t type_size = 0;
+
+    /// What is the alignment of the underlying C++ type?
+    size_t type_align = 0;
+
+    /// How large is the type's holder?
+    size_t holder_size = 0;
+
+    /// The global operator new can be overridden with a class-specific variant
+    void *(*operator_new)(size_t) = nullptr;
+
+    /// Function pointer to class_<..>::init_instance
+    void (*init_instance)(instance *, const void *) = nullptr;
+
+    /// Function pointer to class_<..>::dealloc
+    void (*dealloc)(detail::value_and_holder &) = nullptr;
+
+    /// Function pointer for casting alias class (aka trampoline) pointer to
+    /// trampoline_self_life_support pointer. Sidesteps cross-DSO RTTI issues
+    /// on platforms like macOS (see PR #5728 for details).
+    get_trampoline_self_life_support_fn get_trampoline_self_life_support
+        = [](void *) -> trampoline_self_life_support * { return nullptr; };
+
+    /// List of base classes of the newly created type
+    list bases;
+
+    /// Optional docstring
+    const char *doc = nullptr;
+
+    /// Custom metaclass (optional)
+    handle metaclass;
+
+    /// Custom type setup.
+    custom_type_setup::callback custom_type_setup_callback;
+
+    /// Multiple inheritance marker
+    bool multiple_inheritance : 1;
+
+    /// Does the class manage a __dict__?
+    bool dynamic_attr : 1;
+
+    /// Does the class implement the buffer protocol?
+    bool buffer_protocol : 1;
+
+    /// Is the class definition local to the module shared object?
+    bool module_local : 1;
+
+    /// Is the class inheritable from python classes?
+    bool is_final : 1;
+
+    /// Solves pybind/pybind11#1446
+    bool release_gil_before_calling_cpp_dtor : 1;
+
+    holder_enum_t holder_enum_v = holder_enum_t::undefined;
+
+    PYBIND11_NOINLINE void add_base(const std::type_info &base, void *(*caster)(void *) ) {
+        auto *base_info = detail::get_type_info(base, false);
+        if (!base_info) {
+            std::string tname(base.name());
+            detail::clean_type_id(tname);
+            pybind11_fail("generic_type: type \"" + std::string(name)
+                          + "\" referenced unknown base type \"" + tname + "\"");
+        }
+
+        // SMART_HOLDER_BAKEIN_FOLLOW_ON: Refine holder compatibility checks.
+        bool this_has_unique_ptr_holder = (holder_enum_v == holder_enum_t::std_unique_ptr);
+        bool base_has_unique_ptr_holder
+            = (base_info->holder_enum_v == holder_enum_t::std_unique_ptr);
+        if (this_has_unique_ptr_holder != base_has_unique_ptr_holder) {
+            std::string tname(base.name());
+            detail::clean_type_id(tname);
+            pybind11_fail("generic_type: type \"" + std::string(name) + "\" "
+                          + (this_has_unique_ptr_holder ? "does not have" : "has")
+                          + " a non-default holder type while its base \"" + tname + "\" "
+                          + (base_has_unique_ptr_holder ? "does not" : "does"));
+        }
+
+        bases.append((PyObject *) base_info->type);
+
+#ifdef PYBIND11_BACKWARD_COMPATIBILITY_TP_DICTOFFSET
+        dynamic_attr |= base_info->type->tp_dictoffset != 0;
+#else
+        dynamic_attr |= (base_info->type->tp_flags & Py_TPFLAGS_MANAGED_DICT) != 0;
+#endif
+
+        if (caster) {
+            base_info->implicit_casts.emplace_back(type, caster);
+        }
+    }
+};
+
+inline function_call::function_call(const function_record &f, handle p) : func(f), parent(p) {
+    args.reserve(f.nargs);
+    args_convert.reserve(f.nargs);
+}
+
+/// Tag for a new-style `__init__` defined in `detail/init.h`
+struct is_new_style_constructor {};
+
+/**
+ * Partial template specializations to process custom attributes provided to
+ * cpp_function_ and class_. These are either used to initialize the respective
+ * fields in the type_record and function_record data structures or executed at
+ * runtime to deal with custom call policies (e.g. keep_alive).
+ */
+template <typename T, typename SFINAE = void>
+struct process_attribute;
+
+template <typename T>
+struct process_attribute_default {
+    /// Default implementation: do nothing
+    static void init(const T &, function_record *) {}
+    static void init(const T &, type_record *) {}
+    static void precall(function_call &) {}
+    static void postcall(function_call &, handle) {}
+};
+
+/// Process an attribute specifying the function's name
+template <>
+struct process_attribute<name> : process_attribute_default<name> {
+    static void init(const name &n, function_record *r) { r->name = const_cast<char *>(n.value); }
+};
+
+/// Process an attribute specifying the function's docstring
+template <>
+struct process_attribute<doc> : process_attribute_default<doc> {
+    static void init(const doc &n, function_record *r) { r->doc = const_cast<char *>(n.value); }
+};
+
+/// Process an attribute specifying the function's docstring (provided as a C-style string)
+template <>
+struct process_attribute<const char *> : process_attribute_default<const char *> {
+    static void init(const char *d, function_record *r) { r->doc = const_cast<char *>(d); }
+    static void init(const char *d, type_record *r) { r->doc = d; }
+};
+template <>
+struct process_attribute<char *> : process_attribute<const char *> {};
+
+/// Process an attribute indicating the function's return value policy
+template <>
+struct process_attribute<return_value_policy> : process_attribute_default<return_value_policy> {
+    static void init(const return_value_policy &p, function_record *r) { r->policy = p; }
+};
+
+/// Process an attribute which indicates that this is an overloaded function associated with a
+/// given sibling
+template <>
+struct process_attribute<sibling> : process_attribute_default<sibling> {
+    static void init(const sibling &s, function_record *r) { r->sibling = s.value; }
+};
+
+/// Process an attribute which indicates that this function is a method
+template <>
+struct process_attribute<is_method> : process_attribute_default<is_method> {
+    static void init(const is_method &s, function_record *r) {
+        r->is_method = true;
+        r->scope = s.class_;
+    }
+};
+
+/// Process an attribute which indicates that this function is a setter
+template <>
+struct process_attribute<is_setter> : process_attribute_default<is_setter> {
+    static void init(const is_setter &, function_record *r) { r->is_setter = true; }
+};
+
+/// Process an attribute which indicates the parent scope of a method
+template <>
+struct process_attribute<scope> : process_attribute_default<scope> {
+    static void init(const scope &s, function_record *r) { r->scope = s.value; }
+};
+
+/// Process an attribute which indicates that this function is an operator
+template <>
+struct process_attribute<is_operator> : process_attribute_default<is_operator> {
+    static void init(const is_operator &, function_record *r) { r->is_operator = true; }
+};
+
+template <>
+struct process_attribute<is_new_style_constructor>
+    : process_attribute_default<is_new_style_constructor> {
+    static void init(const is_new_style_constructor &, function_record *r) {
+        r->is_new_style_constructor = true;
+    }
+};
+
+inline void check_kw_only_arg(const arg &a, function_record *r) {
+    if (r->args.size() > r->nargs_pos && (!a.name || a.name[0] == '\0')) {
+        pybind11_fail("arg(): cannot specify an unnamed argument after a kw_only() annotation or "
+                      "args() argument");
+    }
+}
+
+inline void append_self_arg_if_needed(function_record *r) {
+    if (r->is_method && r->args.empty()) {
+        r->args.emplace_back("self", nullptr, handle(), /*convert=*/true, /*none=*/false);
+    }
+}
+
+/// Process a keyword argument attribute (*without* a default value)
+template <>
+struct process_attribute<arg> : process_attribute_default<arg> {
+    static void init(const arg &a, function_record *r) {
+        append_self_arg_if_needed(r);
+        r->args.emplace_back(a.name, nullptr, handle(), !a.flag_noconvert, a.flag_none);
+
+        check_kw_only_arg(a, r);
+    }
+};
+
+/// Process a keyword argument attribute (*with* a default value)
+template <>
+struct process_attribute<arg_v> : process_attribute_default<arg_v> {
+    static void init(const arg_v &a, function_record *r) {
+        if (r->is_method && r->args.empty()) {
+            r->args.emplace_back(
+                "self", /*descr=*/nullptr, /*parent=*/handle(), /*convert=*/true, /*none=*/false);
+        }
+
+        if (!a.value) {
+#if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+            std::string descr("'");
+            if (a.name) {
+                descr += std::string(a.name) + ": ";
+            }
+            descr += a.type + "'";
+            if (r->is_method) {
+                if (r->name) {
+                    descr += " in method '" + (std::string) str(r->scope) + "."
+                             + (std::string) r->name + "'";
+                } else {
+                    descr += " in method of '" + (std::string) str(r->scope) + "'";
+                }
+            } else if (r->name) {
+                descr += " in function '" + (std::string) r->name + "'";
+            }
+            pybind11_fail("arg(): could not convert default argument " + descr
+                          + " into a Python object (type not registered yet?)");
+#else
+            pybind11_fail("arg(): could not convert default argument "
+                          "into a Python object (type not registered yet?). "
+                          "#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for "
+                          "more information.");
+#endif
+        }
+        r->args.emplace_back(a.name, a.descr, a.value.inc_ref(), !a.flag_noconvert, a.flag_none);
+
+        check_kw_only_arg(a, r);
+    }
+};
+
+/// Process a keyword-only-arguments-follow pseudo argument
+template <>
+struct process_attribute<kw_only> : process_attribute_default<kw_only> {
+    static void init(const kw_only &, function_record *r) {
+        append_self_arg_if_needed(r);
+        if (r->has_args && r->nargs_pos != static_cast<std::uint16_t>(r->args.size())) {
+            pybind11_fail("Mismatched args() and kw_only(): they must occur at the same relative "
+                          "argument location (or omit kw_only() entirely)");
+        }
+        r->nargs_pos = static_cast<std::uint16_t>(r->args.size());
+    }
+};
+
+/// Process a positional-only-argument maker
+template <>
+struct process_attribute<pos_only> : process_attribute_default<pos_only> {
+    static void init(const pos_only &, function_record *r) {
+        append_self_arg_if_needed(r);
+        r->nargs_pos_only = static_cast<std::uint16_t>(r->args.size());
+        if (r->nargs_pos_only > r->nargs_pos) {
+            pybind11_fail("pos_only(): cannot follow a py::args() argument");
+        }
+        // It also can't follow a kw_only, but a static_assert in pybind11.h checks that
+    }
+};
+
+/// Process a parent class attribute.  Single inheritance only (class_ itself already guarantees
+/// that)
+template <typename T>
+struct process_attribute<T, enable_if_t<is_pyobject<T>::value>>
+    : process_attribute_default<handle> {
+    static void init(const handle &h, type_record *r) { r->bases.append(h); }
+};
+
+/// Process a parent class attribute (deprecated, does not support multiple inheritance)
+template <typename T>
+struct process_attribute<base<T>> : process_attribute_default<base<T>> {
+    static void init(const base<T> &, type_record *r) { r->add_base(typeid(T), nullptr); }
+};
+
+/// Process a multiple inheritance attribute
+template <>
+struct process_attribute<multiple_inheritance> : process_attribute_default<multiple_inheritance> {
+    static void init(const multiple_inheritance &, type_record *r) {
+        r->multiple_inheritance = true;
+    }
+};
+
+template <>
+struct process_attribute<dynamic_attr> : process_attribute_default<dynamic_attr> {
+    static void init(const dynamic_attr &, type_record *r) { r->dynamic_attr = true; }
+};
+
+template <>
+struct process_attribute<custom_type_setup> {
+    static void init(const custom_type_setup &value, type_record *r) {
+        r->custom_type_setup_callback = value.value;
+    }
+};
+
+template <>
+struct process_attribute<is_final> : process_attribute_default<is_final> {
+    static void init(const is_final &, type_record *r) { r->is_final = true; }
+};
+
+template <>
+struct process_attribute<buffer_protocol> : process_attribute_default<buffer_protocol> {
+    static void init(const buffer_protocol &, type_record *r) { r->buffer_protocol = true; }
+};
+
+template <>
+struct process_attribute<metaclass> : process_attribute_default<metaclass> {
+    static void init(const metaclass &m, type_record *r) { r->metaclass = m.value; }
+};
+
+template <>
+struct process_attribute<module_local> : process_attribute_default<module_local> {
+    static void init(const module_local &l, type_record *r) { r->module_local = l.value; }
+};
+
+template <>
+struct process_attribute<release_gil_before_calling_cpp_dtor>
+    : process_attribute_default<release_gil_before_calling_cpp_dtor> {
+    static void init(const release_gil_before_calling_cpp_dtor &, type_record *r) {
+        r->release_gil_before_calling_cpp_dtor = true;
+    }
+};
+
+/// Process a 'prepend' attribute, putting this at the beginning of the overload chain
+template <>
+struct process_attribute<prepend> : process_attribute_default<prepend> {
+    static void init(const prepend &, function_record *r) { r->prepend = true; }
+};
+
+/// Process an 'arithmetic' attribute for enums (does nothing here)
+template <>
+struct process_attribute<arithmetic> : process_attribute_default<arithmetic> {};
+
+template <typename... Ts>
+struct process_attribute<call_guard<Ts...>> : process_attribute_default<call_guard<Ts...>> {};
+
+/**
+ * Process a keep_alive call policy -- invokes keep_alive_impl during the
+ * pre-call handler if both Nurse, Patient != 0 and use the post-call handler
+ * otherwise
+ */
+template <size_t Nurse, size_t Patient>
+struct process_attribute<keep_alive<Nurse, Patient>>
+    : public process_attribute_default<keep_alive<Nurse, Patient>> {
+    template <size_t N = Nurse, size_t P = Patient, enable_if_t<N != 0 && P != 0, int> = 0>
+    static void precall(function_call &call) {
+        keep_alive_impl(Nurse, Patient, call, handle());
+    }
+    template <size_t N = Nurse, size_t P = Patient, enable_if_t<N != 0 && P != 0, int> = 0>
+    static void postcall(function_call &, handle) {}
+    template <size_t N = Nurse, size_t P = Patient, enable_if_t<N == 0 || P == 0, int> = 0>
+    static void precall(function_call &) {}
+    template <size_t N = Nurse, size_t P = Patient, enable_if_t<N == 0 || P == 0, int> = 0>
+    static void postcall(function_call &call, handle ret) {
+        keep_alive_impl(Nurse, Patient, call, ret);
+    }
+};
+
+/// Recursively iterate over variadic template arguments
+template <typename... Args>
+struct process_attributes {
+    static void init(const Args &...args, function_record *r) {
+        PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(r);
+        PYBIND11_WORKAROUND_INCORRECT_GCC_UNUSED_BUT_SET_PARAMETER(r);
+        using expander = int[];
+        (void) expander{
+            0, ((void) process_attribute<typename std::decay<Args>::type>::init(args, r), 0)...};
+    }
+    static void init(const Args &...args, type_record *r) {
+        PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(r);
+        PYBIND11_WORKAROUND_INCORRECT_GCC_UNUSED_BUT_SET_PARAMETER(r);
+        using expander = int[];
+        (void) expander{0,
+                        (process_attribute<typename std::decay<Args>::type>::init(args, r), 0)...};
+    }
+    static void precall(function_call &call) {
+        PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(call);
+        using expander = int[];
+        (void) expander{0,
+                        (process_attribute<typename std::decay<Args>::type>::precall(call), 0)...};
+    }
+    static void postcall(function_call &call, handle fn_ret) {
+        PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(call, fn_ret);
+        PYBIND11_WORKAROUND_INCORRECT_GCC_UNUSED_BUT_SET_PARAMETER(fn_ret);
+        using expander = int[];
+        (void) expander{
+            0, (process_attribute<typename std::decay<Args>::type>::postcall(call, fn_ret), 0)...};
+    }
+};
+
+template <typename T>
+using is_call_guard = is_instantiation<call_guard, T>;
+
+/// Extract the ``type`` from the first `call_guard` in `Extras...` (or `void_type` if none found)
+template <typename... Extra>
+using extract_guard_t = typename exactly_one_t<is_call_guard, call_guard<>, Extra...>::type;
+
+/// Check the number of named arguments at compile time
+template <typename... Extra,
+          size_t named = constexpr_sum(std::is_base_of<arg, Extra>::value...),
+          size_t self = constexpr_sum(std::is_same<is_method, Extra>::value...)>
+constexpr bool expected_num_args(size_t nargs, bool has_args, bool has_kwargs) {
+    PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(nargs, has_args, has_kwargs);
+    return named == 0 || (self + named + size_t(has_args) + size_t(has_kwargs)) == nargs;
+}
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/buffer_info.h b/local_pybind11/pybind11/include/pybind11/buffer_info.h
new file mode 100644
index 000000000..75aec0ba3
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/buffer_info.h
@@ -0,0 +1,208 @@
+/*
+    pybind11/buffer_info.h: Python buffer object interface
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "detail/common.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+// Default, C-style strides
+inline std::vector<ssize_t> c_strides(const std::vector<ssize_t> &shape, ssize_t itemsize) {
+    auto ndim = shape.size();
+    std::vector<ssize_t> strides(ndim, itemsize);
+    if (ndim > 0) {
+        for (size_t i = ndim - 1; i > 0; --i) {
+            strides[i - 1] = strides[i] * shape[i];
+        }
+    }
+    return strides;
+}
+
+// F-style strides; default when constructing an array_t with `ExtraFlags & f_style`
+inline std::vector<ssize_t> f_strides(const std::vector<ssize_t> &shape, ssize_t itemsize) {
+    auto ndim = shape.size();
+    std::vector<ssize_t> strides(ndim, itemsize);
+    for (size_t i = 1; i < ndim; ++i) {
+        strides[i] = strides[i - 1] * shape[i - 1];
+    }
+    return strides;
+}
+
+template <typename T, typename SFINAE = void>
+struct compare_buffer_info;
+
+PYBIND11_NAMESPACE_END(detail)
+
+/// Information record describing a Python buffer object
+struct buffer_info {
+    void *ptr = nullptr;          // Pointer to the underlying storage
+    ssize_t itemsize = 0;         // Size of individual items in bytes
+    ssize_t size = 0;             // Total number of entries
+    std::string format;           // For homogeneous buffers, this should be set to
+                                  // format_descriptor<T>::format()
+    ssize_t ndim = 0;             // Number of dimensions
+    std::vector<ssize_t> shape;   // Shape of the tensor (1 entry per dimension)
+    std::vector<ssize_t> strides; // Number of bytes between adjacent entries
+                                  // (for each per dimension)
+    bool readonly = false;        // flag to indicate if the underlying storage may be written to
+
+    buffer_info() = default;
+
+    buffer_info(void *ptr,
+                ssize_t itemsize,
+                const std::string &format,
+                ssize_t ndim,
+                detail::any_container<ssize_t> shape_in,
+                detail::any_container<ssize_t> strides_in,
+                bool readonly = false)
+        : ptr(ptr), itemsize(itemsize), size(1), format(format), ndim(ndim),
+          shape(std::move(shape_in)), strides(std::move(strides_in)), readonly(readonly) {
+        if (ndim != (ssize_t) shape.size() || ndim != (ssize_t) strides.size()) {
+            pybind11_fail("buffer_info: ndim doesn't match shape and/or strides length");
+        }
+        for (size_t i = 0; i < (size_t) ndim; ++i) {
+            size *= shape[i];
+        }
+    }
+
+    template <typename T>
+    buffer_info(T *ptr,
+                detail::any_container<ssize_t> shape_in,
+                detail::any_container<ssize_t> strides_in,
+                bool readonly = false)
+        : buffer_info(private_ctr_tag(),
+                      ptr,
+                      sizeof(T),
+                      format_descriptor<T>::format(),
+                      static_cast<ssize_t>(shape_in->size()),
+                      std::move(shape_in),
+                      std::move(strides_in),
+                      readonly) {}
+
+    buffer_info(void *ptr,
+                ssize_t itemsize,
+                const std::string &format,
+                ssize_t size,
+                bool readonly = false)
+        : buffer_info(ptr, itemsize, format, 1, {size}, {itemsize}, readonly) {}
+
+    template <typename T>
+    buffer_info(T *ptr, ssize_t size, bool readonly = false)
+        : buffer_info(ptr, sizeof(T), format_descriptor<T>::format(), size, readonly) {}
+
+    template <typename T>
+    buffer_info(const T *ptr, ssize_t size, bool readonly = true)
+        : buffer_info(
+              const_cast<T *>(ptr), sizeof(T), format_descriptor<T>::format(), size, readonly) {}
+
+    explicit buffer_info(Py_buffer *view, bool ownview = true)
+        : buffer_info(
+              view->buf,
+              view->itemsize,
+              view->format,
+              view->ndim,
+              {view->shape, view->shape + view->ndim},
+              /* Though buffer::request() requests PyBUF_STRIDES, ctypes objects
+               * ignore this flag and return a view with NULL strides.
+               * When strides are NULL, build them manually.  */
+              view->strides
+                  ? std::vector<ssize_t>(view->strides, view->strides + view->ndim)
+                  : detail::c_strides({view->shape, view->shape + view->ndim}, view->itemsize),
+              (view->readonly != 0)) {
+        // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
+        this->m_view = view;
+        // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
+        this->ownview = ownview;
+    }
+
+    buffer_info(const buffer_info &) = delete;
+    buffer_info &operator=(const buffer_info &) = delete;
+
+    buffer_info(buffer_info &&other) noexcept { (*this) = std::move(other); }
+
+    buffer_info &operator=(buffer_info &&rhs) noexcept {
+        ptr = rhs.ptr;
+        itemsize = rhs.itemsize;
+        size = rhs.size;
+        format = std::move(rhs.format);
+        ndim = rhs.ndim;
+        shape = std::move(rhs.shape);
+        strides = std::move(rhs.strides);
+        std::swap(m_view, rhs.m_view);
+        std::swap(ownview, rhs.ownview);
+        readonly = rhs.readonly;
+        return *this;
+    }
+
+    ~buffer_info() {
+        if (m_view && ownview) {
+            PyBuffer_Release(m_view);
+            delete m_view;
+        }
+    }
+
+    Py_buffer *view() const { return m_view; }
+    Py_buffer *&view() { return m_view; }
+
+    /* True if the buffer item type is equivalent to `T`. */
+    // To define "equivalent" by example:
+    // `buffer_info::item_type_is_equivalent_to<int>(b)` and
+    // `buffer_info::item_type_is_equivalent_to<long>(b)` may both be true
+    // on some platforms, but `int` and `unsigned` will never be equivalent.
+    // For the ground truth, please inspect `detail::compare_buffer_info<>`.
+    template <typename T>
+    bool item_type_is_equivalent_to() const {
+        return detail::compare_buffer_info<T>::compare(*this);
+    }
+
+private:
+    struct private_ctr_tag {};
+
+    buffer_info(private_ctr_tag,
+                void *ptr,
+                ssize_t itemsize,
+                const std::string &format,
+                ssize_t ndim,
+                detail::any_container<ssize_t> &&shape_in,
+                detail::any_container<ssize_t> &&strides_in,
+                bool readonly)
+        : buffer_info(
+              ptr, itemsize, format, ndim, std::move(shape_in), std::move(strides_in), readonly) {}
+
+    Py_buffer *m_view = nullptr;
+    bool ownview = false;
+};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+template <typename T, typename SFINAE>
+struct compare_buffer_info {
+    static bool compare(const buffer_info &b) {
+        // NOLINTNEXTLINE(bugprone-sizeof-expression) Needed for `PyObject *`
+        return b.format == format_descriptor<T>::format() && b.itemsize == (ssize_t) sizeof(T);
+    }
+};
+
+template <typename T>
+struct compare_buffer_info<T, detail::enable_if_t<std::is_integral<T>::value>> {
+    static bool compare(const buffer_info &b) {
+        return (size_t) b.itemsize == sizeof(T)
+               && (b.format == format_descriptor<T>::value
+                   || ((sizeof(T) == sizeof(long))
+                       && b.format == (std::is_unsigned<T>::value ? "L" : "l"))
+                   || ((sizeof(T) == sizeof(size_t))
+                       && b.format == (std::is_unsigned<T>::value ? "N" : "n")));
+    }
+};
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/cast.h b/local_pybind11/pybind11/include/pybind11/cast.h
new file mode 100644
index 000000000..c635791fe
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/cast.h
@@ -0,0 +1,2361 @@
+/*
+    pybind11/cast.h: Partial template specializations to cast between
+    C++ and Python types
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "detail/common.h"
+#include "detail/descr.h"
+#include "detail/native_enum_data.h"
+#include "detail/type_caster_base.h"
+#include "detail/typeid.h"
+#include "pytypes.h"
+
+#include <array>
+#include <cstring>
+#include <functional>
+#include <iosfwd>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+PYBIND11_WARNING_DISABLE_MSVC(4127)
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+template <typename type, typename SFINAE = void>
+class type_caster : public type_caster_base<type> {};
+template <typename type>
+using make_caster = type_caster<intrinsic_t<type>>;
+
+// Shortcut for calling a caster's `cast_op_type` cast operator for casting a type_caster to a T
+template <typename T>
+typename make_caster<T>::template cast_op_type<T> cast_op(make_caster<T> &caster) {
+    using result_t = typename make_caster<T>::template cast_op_type<T>; // See PR #4893
+    return caster.operator result_t();
+}
+template <typename T>
+typename make_caster<T>::template cast_op_type<typename std::add_rvalue_reference<T>::type>
+cast_op(make_caster<T> &&caster) {
+    using result_t = typename make_caster<T>::template cast_op_type<
+        typename std::add_rvalue_reference<T>::type>; // See PR #4893
+    return std::move(caster).operator result_t();
+}
+
+template <typename EnumType>
+class type_caster_enum_type {
+private:
+    using Underlying = typename std::underlying_type<EnumType>::type;
+
+public:
+    static constexpr auto name = const_name<EnumType>();
+
+    template <typename SrcType>
+    static handle cast(SrcType &&src, return_value_policy, handle parent) {
+        handle native_enum
+            = global_internals_native_enum_type_map_get_item(std::type_index(typeid(EnumType)));
+        if (native_enum) {
+            return native_enum(static_cast<Underlying>(src)).release();
+        }
+        return type_caster_base<EnumType>::cast(
+            std::forward<SrcType>(src),
+            // Fixes https://github.com/pybind/pybind11/pull/3643#issuecomment-1022987818:
+            return_value_policy::copy,
+            parent);
+    }
+
+    template <typename SrcType>
+    static handle cast(SrcType *src, return_value_policy policy, handle parent) {
+        return cast(*src, policy, parent);
+    }
+
+    bool load(handle src, bool convert) {
+        handle native_enum
+            = global_internals_native_enum_type_map_get_item(std::type_index(typeid(EnumType)));
+        if (native_enum) {
+            if (!isinstance(src, native_enum)) {
+                return false;
+            }
+            type_caster<Underlying> underlying_caster;
+            if (!underlying_caster.load(src.attr("value"), convert)) {
+                pybind11_fail("native_enum internal consistency failure.");
+            }
+            value = static_cast<EnumType>(static_cast<Underlying>(underlying_caster));
+            return true;
+        }
+        if (!pybind11_enum_) {
+            pybind11_enum_.reset(new type_caster_base<EnumType>());
+        }
+        return pybind11_enum_->load(src, convert);
+    }
+
+    template <typename T>
+    using cast_op_type = detail::cast_op_type<T>;
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator EnumType *() {
+        if (!pybind11_enum_) {
+            return &value;
+        }
+        return pybind11_enum_->operator EnumType *();
+    }
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator EnumType &() {
+        if (!pybind11_enum_) {
+            return value;
+        }
+        return pybind11_enum_->operator EnumType &();
+    }
+
+private:
+    std::unique_ptr<type_caster_base<EnumType>> pybind11_enum_;
+    EnumType value;
+};
+
+template <typename EnumType, typename SFINAE = void>
+struct type_caster_enum_type_enabled : std::true_type {};
+
+template <typename T>
+struct type_uses_type_caster_enum_type {
+    static constexpr bool value
+        = std::is_enum<T>::value && type_caster_enum_type_enabled<T>::value;
+};
+
+template <typename EnumType>
+class type_caster<EnumType, detail::enable_if_t<type_uses_type_caster_enum_type<EnumType>::value>>
+    : public type_caster_enum_type<EnumType> {};
+
+template <typename T, detail::enable_if_t<std::is_enum<T>::value, int> = 0>
+bool isinstance_native_enum_impl(handle obj, const std::type_info &tp) {
+    handle native_enum = global_internals_native_enum_type_map_get_item(tp);
+    if (!native_enum) {
+        return false;
+    }
+    return isinstance(obj, native_enum);
+}
+
+template <typename T, detail::enable_if_t<!std::is_enum<T>::value, int> = 0>
+bool isinstance_native_enum_impl(handle, const std::type_info &) {
+    return false;
+}
+
+template <typename T>
+bool isinstance_native_enum(handle obj, const std::type_info &tp) {
+    return isinstance_native_enum_impl<intrinsic_t<T>>(obj, tp);
+}
+
+template <typename type>
+class type_caster<std::reference_wrapper<type>> {
+private:
+    using caster_t = make_caster<type>;
+    caster_t subcaster;
+    using reference_t = type &;
+    using subcaster_cast_op_type = typename caster_t::template cast_op_type<reference_t>;
+
+    static_assert(
+        std::is_same<typename std::remove_const<type>::type &, subcaster_cast_op_type>::value
+            || std::is_same<reference_t, subcaster_cast_op_type>::value,
+        "std::reference_wrapper<T> caster requires T to have a caster with an "
+        "`operator T &()` or `operator const T &()`");
+
+public:
+    bool load(handle src, bool convert) { return subcaster.load(src, convert); }
+    static constexpr auto name = caster_t::name;
+    static handle
+    cast(const std::reference_wrapper<type> &src, return_value_policy policy, handle parent) {
+        // It is definitely wrong to take ownership of this pointer, so mask that rvp
+        if (policy == return_value_policy::take_ownership
+            || policy == return_value_policy::automatic) {
+            policy = return_value_policy::automatic_reference;
+        }
+        return caster_t::cast(&src.get(), policy, parent);
+    }
+    template <typename T>
+    using cast_op_type = std::reference_wrapper<type>;
+    explicit operator std::reference_wrapper<type>() { return cast_op<type &>(subcaster); }
+};
+
+#define PYBIND11_TYPE_CASTER(type, py_name)                                                       \
+protected:                                                                                        \
+    type value;                                                                                   \
+                                                                                                  \
+public:                                                                                           \
+    static constexpr auto name = py_name;                                                         \
+    template <typename T_,                                                                        \
+              ::pybind11::detail::enable_if_t<                                                    \
+                  std::is_same<type, ::pybind11::detail::remove_cv_t<T_>>::value,                 \
+                  int>                                                                            \
+              = 0>                                                                                \
+    static ::pybind11::handle cast(                                                               \
+        T_ *src, ::pybind11::return_value_policy policy, ::pybind11::handle parent) {             \
+        if (!src)                                                                                 \
+            return ::pybind11::none().release();                                                  \
+        if (policy == ::pybind11::return_value_policy::take_ownership) {                          \
+            auto h = cast(std::move(*src), policy, parent);                                       \
+            delete src;                                                                           \
+            return h;                                                                             \
+        }                                                                                         \
+        return cast(*src, policy, parent);                                                        \
+    }                                                                                             \
+    operator type *() { return &value; }               /* NOLINT(bugprone-macro-parentheses) */   \
+    operator type &() { return value; }                /* NOLINT(bugprone-macro-parentheses) */   \
+    operator type &&() && { return std::move(value); } /* NOLINT(bugprone-macro-parentheses) */   \
+    template <typename T_>                                                                        \
+    using cast_op_type = ::pybind11::detail::movable_cast_op_type<T_>
+
+template <typename CharT>
+using is_std_char_type = any_of<std::is_same<CharT, char>, /* std::string */
+#if defined(PYBIND11_HAS_U8STRING)
+                                std::is_same<CharT, char8_t>, /* std::u8string */
+#endif
+                                std::is_same<CharT, char16_t>, /* std::u16string */
+                                std::is_same<CharT, char32_t>, /* std::u32string */
+                                std::is_same<CharT, wchar_t>   /* std::wstring */
+                                >;
+
+template <typename T>
+struct type_caster<T, enable_if_t<std::is_arithmetic<T>::value && !is_std_char_type<T>::value>> {
+    using _py_type_0 = conditional_t<sizeof(T) <= sizeof(long), long, long long>;
+    using _py_type_1 = conditional_t<std::is_signed<T>::value,
+                                     _py_type_0,
+                                     typename std::make_unsigned<_py_type_0>::type>;
+    using py_type = conditional_t<std::is_floating_point<T>::value, double, _py_type_1>;
+
+public:
+    bool load(handle src, bool convert) {
+        py_type py_value;
+
+        if (!src) {
+            return false;
+        }
+
+#if !defined(PYPY_VERSION)
+        auto index_check = [](PyObject *o) { return PyIndex_Check(o); };
+#else
+        // In PyPy 7.3.3, `PyIndex_Check` is implemented by calling `__index__`,
+        // while CPython only considers the existence of `nb_index`/`__index__`.
+        auto index_check = [](PyObject *o) { return hasattr(o, "__index__"); };
+#endif
+
+        if (std::is_floating_point<T>::value) {
+            if (convert || PyFloat_Check(src.ptr())) {
+                py_value = (py_type) PyFloat_AsDouble(src.ptr());
+            } else {
+                return false;
+            }
+        } else if (PyFloat_Check(src.ptr())
+                   || (!convert && !PYBIND11_LONG_CHECK(src.ptr()) && !index_check(src.ptr()))) {
+            return false;
+        } else {
+            handle src_or_index = src;
+            // PyPy: 7.3.7's 3.8 does not implement PyLong_*'s __index__ calls.
+#if defined(PYPY_VERSION)
+            object index;
+            if (!PYBIND11_LONG_CHECK(src.ptr())) { // So: index_check(src.ptr())
+                index = reinterpret_steal<object>(PyNumber_Index(src.ptr()));
+                if (!index) {
+                    PyErr_Clear();
+                    if (!convert)
+                        return false;
+                } else {
+                    src_or_index = index;
+                }
+            }
+#endif
+            if (std::is_unsigned<py_type>::value) {
+                py_value = as_unsigned<py_type>(src_or_index.ptr());
+            } else { // signed integer:
+                py_value = sizeof(T) <= sizeof(long)
+                               ? (py_type) PyLong_AsLong(src_or_index.ptr())
+                               : (py_type) PYBIND11_LONG_AS_LONGLONG(src_or_index.ptr());
+            }
+        }
+
+        // Python API reported an error
+        bool py_err = py_value == (py_type) -1 && PyErr_Occurred();
+
+        // Check to see if the conversion is valid (integers should match exactly)
+        // Signed/unsigned checks happen elsewhere
+        if (py_err
+            || (std::is_integral<T>::value && sizeof(py_type) != sizeof(T)
+                && py_value != (py_type) (T) py_value)) {
+            PyErr_Clear();
+            if (py_err && convert && (PyNumber_Check(src.ptr()) != 0)) {
+                auto tmp = reinterpret_steal<object>(std::is_floating_point<T>::value
+                                                         ? PyNumber_Float(src.ptr())
+                                                         : PyNumber_Long(src.ptr()));
+                PyErr_Clear();
+                return load(tmp, false);
+            }
+            return false;
+        }
+
+        value = (T) py_value;
+        return true;
+    }
+
+    template <typename U = T>
+    static typename std::enable_if<std::is_floating_point<U>::value, handle>::type
+    cast(U src, return_value_policy /* policy */, handle /* parent */) {
+        return PyFloat_FromDouble((double) src);
+    }
+
+    template <typename U = T>
+    static typename std::enable_if<!std::is_floating_point<U>::value && std::is_signed<U>::value
+                                       && (sizeof(U) <= sizeof(long)),
+                                   handle>::type
+    cast(U src, return_value_policy /* policy */, handle /* parent */) {
+        return PYBIND11_LONG_FROM_SIGNED((long) src);
+    }
+
+    template <typename U = T>
+    static typename std::enable_if<!std::is_floating_point<U>::value && std::is_unsigned<U>::value
+                                       && (sizeof(U) <= sizeof(unsigned long)),
+                                   handle>::type
+    cast(U src, return_value_policy /* policy */, handle /* parent */) {
+        return PYBIND11_LONG_FROM_UNSIGNED((unsigned long) src);
+    }
+
+    template <typename U = T>
+    static typename std::enable_if<!std::is_floating_point<U>::value && std::is_signed<U>::value
+                                       && (sizeof(U) > sizeof(long)),
+                                   handle>::type
+    cast(U src, return_value_policy /* policy */, handle /* parent */) {
+        return PyLong_FromLongLong((long long) src);
+    }
+
+    template <typename U = T>
+    static typename std::enable_if<!std::is_floating_point<U>::value && std::is_unsigned<U>::value
+                                       && (sizeof(U) > sizeof(unsigned long)),
+                                   handle>::type
+    cast(U src, return_value_policy /* policy */, handle /* parent */) {
+        return PyLong_FromUnsignedLongLong((unsigned long long) src);
+    }
+
+    PYBIND11_TYPE_CASTER(T,
+                         io_name<std::is_integral<T>::value>(
+                             "typing.SupportsInt", "int", "typing.SupportsFloat", "float"));
+};
+
+template <typename T>
+struct void_caster {
+public:
+    bool load(handle src, bool) {
+        if (src && src.is_none()) {
+            return true;
+        }
+        return false;
+    }
+    static handle cast(T, return_value_policy /* policy */, handle /* parent */) {
+        return none().release();
+    }
+    PYBIND11_TYPE_CASTER(T, const_name("None"));
+};
+
+template <>
+class type_caster<void_type> : public void_caster<void_type> {};
+
+template <>
+class type_caster<void> : public type_caster<void_type> {
+public:
+    using type_caster<void_type>::cast;
+
+    bool load(handle h, bool) {
+        if (!h) {
+            return false;
+        }
+        if (h.is_none()) {
+            value = nullptr;
+            return true;
+        }
+
+        /* Check if this is a capsule */
+        if (isinstance<capsule>(h)) {
+            value = reinterpret_borrow<capsule>(h);
+            return true;
+        }
+
+        /* Check if this is a C++ type */
+        const auto &bases = all_type_info((PyTypeObject *) type::handle_of(h).ptr());
+        if (bases.size() == 1) { // Only allowing loading from a single-value type
+            value = values_and_holders(reinterpret_cast<instance *>(h.ptr())).begin()->value_ptr();
+            return true;
+        }
+
+        /* Fail */
+        return false;
+    }
+
+    static handle cast(const void *ptr, return_value_policy /* policy */, handle /* parent */) {
+        if (ptr) {
+            return capsule(ptr).release();
+        }
+        return none().release();
+    }
+
+    template <typename T>
+    using cast_op_type = void *&;
+    explicit operator void *&() { return value; }
+    static constexpr auto name = const_name(PYBIND11_CAPSULE_TYPE_TYPE_HINT);
+
+private:
+    void *value = nullptr;
+};
+
+template <>
+class type_caster<std::nullptr_t> : public void_caster<std::nullptr_t> {};
+
+template <>
+class type_caster<bool> {
+public:
+    bool load(handle src, bool convert) {
+        if (!src) {
+            return false;
+        }
+        if (src.ptr() == Py_True) {
+            value = true;
+            return true;
+        }
+        if (src.ptr() == Py_False) {
+            value = false;
+            return true;
+        }
+        if (convert || is_numpy_bool(src)) {
+            // (allow non-implicit conversion for numpy booleans), use strncmp
+            // since NumPy 1.x had an additional trailing underscore.
+
+            Py_ssize_t res = -1;
+            if (src.is_none()) {
+                res = 0; // None is implicitly converted to False
+            }
+#if defined(PYPY_VERSION)
+            // On PyPy, check that "__bool__" attr exists
+            else if (hasattr(src, PYBIND11_BOOL_ATTR)) {
+                res = PyObject_IsTrue(src.ptr());
+            }
+#else
+            // Alternate approach for CPython: this does the same as the above, but optimized
+            // using the CPython API so as to avoid an unneeded attribute lookup.
+            else if (auto *tp_as_number = Py_TYPE(src.ptr())->tp_as_number) {
+                if (PYBIND11_NB_BOOL(tp_as_number)) {
+                    res = (*PYBIND11_NB_BOOL(tp_as_number))(src.ptr());
+                }
+            }
+#endif
+            if (res == 0 || res == 1) {
+                value = (res != 0);
+                return true;
+            }
+            PyErr_Clear();
+        }
+        return false;
+    }
+    static handle cast(bool src, return_value_policy /* policy */, handle /* parent */) {
+        return handle(src ? Py_True : Py_False).inc_ref();
+    }
+    PYBIND11_TYPE_CASTER(bool, const_name("bool"));
+
+private:
+    // Test if an object is a NumPy boolean (without fetching the type).
+    static inline bool is_numpy_bool(handle object) {
+        const char *type_name = Py_TYPE(object.ptr())->tp_name;
+        // Name changed to `numpy.bool` in NumPy 2, `numpy.bool_` is needed for 1.x support
+        return std::strcmp("numpy.bool", type_name) == 0
+               || std::strcmp("numpy.bool_", type_name) == 0;
+    }
+};
+
+// Helper class for UTF-{8,16,32} C++ stl strings:
+template <typename StringType, bool IsView = false>
+struct string_caster {
+    using CharT = typename StringType::value_type;
+
+    // Simplify life by being able to assume standard char sizes (the standard only guarantees
+    // minimums, but Python requires exact sizes)
+    static_assert(!std::is_same<CharT, char>::value || sizeof(CharT) == 1,
+                  "Unsupported char size != 1");
+#if defined(PYBIND11_HAS_U8STRING)
+    static_assert(!std::is_same<CharT, char8_t>::value || sizeof(CharT) == 1,
+                  "Unsupported char8_t size != 1");
+#endif
+    static_assert(!std::is_same<CharT, char16_t>::value || sizeof(CharT) == 2,
+                  "Unsupported char16_t size != 2");
+    static_assert(!std::is_same<CharT, char32_t>::value || sizeof(CharT) == 4,
+                  "Unsupported char32_t size != 4");
+    // wchar_t can be either 16 bits (Windows) or 32 (everywhere else)
+    static_assert(!std::is_same<CharT, wchar_t>::value || sizeof(CharT) == 2 || sizeof(CharT) == 4,
+                  "Unsupported wchar_t size != 2/4");
+    static constexpr size_t UTF_N = 8 * sizeof(CharT);
+
+    bool load(handle src, bool) {
+        handle load_src = src;
+        if (!src) {
+            return false;
+        }
+        if (!PyUnicode_Check(load_src.ptr())) {
+            return load_raw(load_src);
+        }
+
+        // For UTF-8 we avoid the need for a temporary `bytes` object by using
+        // `PyUnicode_AsUTF8AndSize`.
+        if (UTF_N == 8) {
+            Py_ssize_t size = -1;
+            const auto *buffer
+                = reinterpret_cast<const CharT *>(PyUnicode_AsUTF8AndSize(load_src.ptr(), &size));
+            if (!buffer) {
+                PyErr_Clear();
+                return false;
+            }
+            value = StringType(buffer, static_cast<size_t>(size));
+            return true;
+        }
+
+        auto utfNbytes
+            = reinterpret_steal<object>(PyUnicode_AsEncodedString(load_src.ptr(),
+                                                                  UTF_N == 8    ? "utf-8"
+                                                                  : UTF_N == 16 ? "utf-16"
+                                                                                : "utf-32",
+                                                                  nullptr));
+        if (!utfNbytes) {
+            PyErr_Clear();
+            return false;
+        }
+
+        const auto *buffer
+            = reinterpret_cast<const CharT *>(PYBIND11_BYTES_AS_STRING(utfNbytes.ptr()));
+        size_t length = (size_t) PYBIND11_BYTES_SIZE(utfNbytes.ptr()) / sizeof(CharT);
+        // Skip BOM for UTF-16/32
+        if (UTF_N > 8) {
+            buffer++;
+            length--;
+        }
+        value = StringType(buffer, length);
+
+        // If we're loading a string_view we need to keep the encoded Python object alive:
+        if (IsView) {
+            loader_life_support::add_patient(utfNbytes);
+        }
+
+        return true;
+    }
+
+    static handle
+    cast(const StringType &src, return_value_policy /* policy */, handle /* parent */) {
+        const char *buffer = reinterpret_cast<const char *>(src.data());
+        auto nbytes = ssize_t(src.size() * sizeof(CharT));
+        handle s = decode_utfN(buffer, nbytes);
+        if (!s) {
+            throw error_already_set();
+        }
+        return s;
+    }
+
+    PYBIND11_TYPE_CASTER(StringType, const_name(PYBIND11_STRING_NAME));
+
+private:
+    static handle decode_utfN(const char *buffer, ssize_t nbytes) {
+#if !defined(PYPY_VERSION)
+        return UTF_N == 8    ? PyUnicode_DecodeUTF8(buffer, nbytes, nullptr)
+               : UTF_N == 16 ? PyUnicode_DecodeUTF16(buffer, nbytes, nullptr, nullptr)
+                             : PyUnicode_DecodeUTF32(buffer, nbytes, nullptr, nullptr);
+#else
+        // PyPy segfaults when on PyUnicode_DecodeUTF16 (and possibly on PyUnicode_DecodeUTF32 as
+        // well), so bypass the whole thing by just passing the encoding as a string value, which
+        // works properly:
+        return PyUnicode_Decode(buffer,
+                                nbytes,
+                                UTF_N == 8    ? "utf-8"
+                                : UTF_N == 16 ? "utf-16"
+                                              : "utf-32",
+                                nullptr);
+#endif
+    }
+
+    // When loading into a std::string or char*, accept a bytes/bytearray object as-is (i.e.
+    // without any encoding/decoding attempt).  For other C++ char sizes this is a no-op.
+    // which supports loading a unicode from a str, doesn't take this path.
+    template <typename C = CharT>
+    bool load_raw(enable_if_t<std::is_same<C, char>::value, handle> src) {
+        if (PYBIND11_BYTES_CHECK(src.ptr())) {
+            // We were passed raw bytes; accept it into a std::string or char*
+            // without any encoding attempt.
+            const char *bytes = PYBIND11_BYTES_AS_STRING(src.ptr());
+            if (!bytes) {
+                pybind11_fail("Unexpected PYBIND11_BYTES_AS_STRING() failure.");
+            }
+            value = StringType(bytes, (size_t) PYBIND11_BYTES_SIZE(src.ptr()));
+            return true;
+        }
+        if (PyByteArray_Check(src.ptr())) {
+            // We were passed a bytearray; accept it into a std::string or char*
+            // without any encoding attempt.
+            const char *bytearray = PyByteArray_AsString(src.ptr());
+            if (!bytearray) {
+                pybind11_fail("Unexpected PyByteArray_AsString() failure.");
+            }
+            value = StringType(bytearray, (size_t) PyByteArray_Size(src.ptr()));
+            return true;
+        }
+
+        return false;
+    }
+
+    template <typename C = CharT>
+    bool load_raw(enable_if_t<!std::is_same<C, char>::value, handle>) {
+        return false;
+    }
+};
+
+template <typename CharT, class Traits, class Allocator>
+struct type_caster<std::basic_string<CharT, Traits, Allocator>,
+                   enable_if_t<is_std_char_type<CharT>::value>>
+    : string_caster<std::basic_string<CharT, Traits, Allocator>> {};
+
+#ifdef PYBIND11_HAS_STRING_VIEW
+template <typename CharT, class Traits>
+struct type_caster<std::basic_string_view<CharT, Traits>,
+                   enable_if_t<is_std_char_type<CharT>::value>>
+    : string_caster<std::basic_string_view<CharT, Traits>, true> {};
+#endif
+
+// Type caster for C-style strings.  We basically use a std::string type caster, but also add the
+// ability to use None as a nullptr char* (which the string caster doesn't allow).
+template <typename CharT>
+struct type_caster<CharT, enable_if_t<is_std_char_type<CharT>::value>> {
+    using StringType = std::basic_string<CharT>;
+    using StringCaster = make_caster<StringType>;
+    StringCaster str_caster;
+    bool none = false;
+    CharT one_char = 0;
+
+public:
+    bool load(handle src, bool convert) {
+        if (!src) {
+            return false;
+        }
+        if (src.is_none()) {
+            // Defer accepting None to other overloads (if we aren't in convert mode):
+            if (!convert) {
+                return false;
+            }
+            none = true;
+            return true;
+        }
+        return str_caster.load(src, convert);
+    }
+
+    static handle cast(const CharT *src, return_value_policy policy, handle parent) {
+        if (src == nullptr) {
+            return pybind11::none().release();
+        }
+        return StringCaster::cast(StringType(src), policy, parent);
+    }
+
+    static handle cast(CharT src, return_value_policy policy, handle parent) {
+        if (std::is_same<char, CharT>::value) {
+            handle s = PyUnicode_DecodeLatin1((const char *) &src, 1, nullptr);
+            if (!s) {
+                throw error_already_set();
+            }
+            return s;
+        }
+        return StringCaster::cast(StringType(1, src), policy, parent);
+    }
+
+    explicit operator CharT *() {
+        return none ? nullptr : const_cast<CharT *>(static_cast<StringType &>(str_caster).c_str());
+    }
+    explicit operator CharT &() {
+        if (none) {
+            throw value_error("Cannot convert None to a character");
+        }
+
+        auto &value = static_cast<StringType &>(str_caster);
+        size_t str_len = value.size();
+        if (str_len == 0) {
+            throw value_error("Cannot convert empty string to a character");
+        }
+
+        // If we're in UTF-8 mode, we have two possible failures: one for a unicode character that
+        // is too high, and one for multiple unicode characters (caught later), so we need to
+        // figure out how long the first encoded character is in bytes to distinguish between these
+        // two errors.  We also allow want to allow unicode characters U+0080 through U+00FF, as
+        // those can fit into a single char value.
+        if (StringCaster::UTF_N == 8 && str_len > 1 && str_len <= 4) {
+            auto v0 = static_cast<unsigned char>(value[0]);
+            // low bits only: 0-127
+            // 0b110xxxxx - start of 2-byte sequence
+            // 0b1110xxxx - start of 3-byte sequence
+            // 0b11110xxx - start of 4-byte sequence
+            size_t char0_bytes = (v0 & 0x80) == 0      ? 1
+                                 : (v0 & 0xE0) == 0xC0 ? 2
+                                 : (v0 & 0xF0) == 0xE0 ? 3
+                                                       : 4;
+
+            if (char0_bytes == str_len) {
+                // If we have a 128-255 value, we can decode it into a single char:
+                if (char0_bytes == 2 && (v0 & 0xFC) == 0xC0) { // 0x110000xx 0x10xxxxxx
+                    one_char = static_cast<CharT>(((v0 & 3) << 6)
+                                                  + (static_cast<unsigned char>(value[1]) & 0x3F));
+                    return one_char;
+                }
+                // Otherwise we have a single character, but it's > U+00FF
+                throw value_error("Character code point not in range(0x100)");
+            }
+        }
+
+        // UTF-16 is much easier: we can only have a surrogate pair for values above U+FFFF, thus a
+        // surrogate pair with total length 2 instantly indicates a range error (but not a "your
+        // string was too long" error).
+        else if (StringCaster::UTF_N == 16 && str_len == 2) {
+            one_char = static_cast<CharT>(value[0]);
+            if (one_char >= 0xD800 && one_char < 0xE000) {
+                throw value_error("Character code point not in range(0x10000)");
+            }
+        }
+
+        if (str_len != 1) {
+            throw value_error("Expected a character, but multi-character string found");
+        }
+
+        one_char = value[0];
+        return one_char;
+    }
+
+    static constexpr auto name = const_name(PYBIND11_STRING_NAME);
+    template <typename _T>
+    using cast_op_type = pybind11::detail::cast_op_type<_T>;
+};
+
+// Base implementation for std::tuple and std::pair
+template <template <typename...> class Tuple, typename... Ts>
+class tuple_caster {
+    using type = Tuple<Ts...>;
+    static constexpr auto size = sizeof...(Ts);
+    using indices = make_index_sequence<size>;
+
+public:
+    bool load(handle src, bool convert) {
+        if (!isinstance<sequence>(src)) {
+            return false;
+        }
+        const auto seq = reinterpret_borrow<sequence>(src);
+        if (seq.size() != size) {
+            return false;
+        }
+        return load_impl(seq, convert, indices{});
+    }
+
+    template <typename T>
+    static handle cast(T &&src, return_value_policy policy, handle parent) {
+        return cast_impl(std::forward<T>(src), policy, parent, indices{});
+    }
+
+    // copied from the PYBIND11_TYPE_CASTER macro
+    template <typename T>
+    static handle cast(T *src, return_value_policy policy, handle parent) {
+        if (!src) {
+            return none().release();
+        }
+        if (policy == return_value_policy::take_ownership) {
+            auto h = cast(std::move(*src), policy, parent);
+            delete src;
+            return h;
+        }
+        return cast(*src, policy, parent);
+    }
+
+    static constexpr auto name = const_name("tuple[")
+                                 + ::pybind11::detail::concat(make_caster<Ts>::name...)
+                                 + const_name("]");
+
+    template <typename T>
+    using cast_op_type = type;
+
+    explicit operator type() & { return implicit_cast(indices{}); }
+    explicit operator type() && { return std::move(*this).implicit_cast(indices{}); }
+
+protected:
+    template <size_t... Is>
+    type implicit_cast(index_sequence<Is...>) & {
+        return type(cast_op<Ts>(std::get<Is>(subcasters))...);
+    }
+    template <size_t... Is>
+    type implicit_cast(index_sequence<Is...>) && {
+        return type(cast_op<Ts>(std::move(std::get<Is>(subcasters)))...);
+    }
+
+    static constexpr bool load_impl(const sequence &, bool, index_sequence<>) { return true; }
+
+    template <size_t... Is>
+    bool load_impl(const sequence &seq, bool convert, index_sequence<Is...>) {
+#ifdef __cpp_fold_expressions
+        if ((... || !std::get<Is>(subcasters).load(seq[Is], convert))) {
+            return false;
+        }
+#else
+        for (bool r : {std::get<Is>(subcasters).load(seq[Is], convert)...}) {
+            if (!r) {
+                return false;
+            }
+        }
+#endif
+        return true;
+    }
+
+    /* Implementation: Convert a C++ tuple into a Python tuple */
+    template <typename T, size_t... Is>
+    static handle
+    cast_impl(T &&src, return_value_policy policy, handle parent, index_sequence<Is...>) {
+        PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(src, policy, parent);
+        PYBIND11_WORKAROUND_INCORRECT_GCC_UNUSED_BUT_SET_PARAMETER(policy, parent);
+
+        std::array<object, size> entries{{reinterpret_steal<object>(
+            // NOLINTNEXTLINE(bugprone-use-after-move)
+            make_caster<Ts>::cast(std::get<Is>(std::forward<T>(src)), policy, parent))...}};
+        for (const auto &entry : entries) {
+            if (!entry) {
+                return handle();
+            }
+        }
+        tuple result(size);
+        int counter = 0;
+        for (auto &entry : entries) {
+            PyTuple_SET_ITEM(result.ptr(), counter++, entry.release().ptr());
+        }
+        return result.release();
+    }
+
+    Tuple<make_caster<Ts>...> subcasters;
+};
+
+template <typename T1, typename T2>
+class type_caster<std::pair<T1, T2>> : public tuple_caster<std::pair, T1, T2> {};
+
+template <typename... Ts>
+class type_caster<std::tuple<Ts...>> : public tuple_caster<std::tuple, Ts...> {};
+
+template <>
+class type_caster<std::tuple<>> : public tuple_caster<std::tuple> {
+public:
+    // PEP 484 specifies this syntax for an empty tuple
+    static constexpr auto name = const_name("tuple[()]");
+};
+
+/// Helper class which abstracts away certain actions. Users can provide specializations for
+/// custom holders, but it's only necessary if the type has a non-standard interface.
+template <typename T>
+struct holder_helper {
+    static auto get(const T &p) -> decltype(p.get()) { return p.get(); }
+};
+
+// SMART_HOLDER_BAKEIN_FOLLOW_ON: Rewrite comment, with reference to shared_ptr specialization.
+/// Type caster for holder types like std::shared_ptr, etc.
+/// The SFINAE hook is provided to help work around the current lack of support
+/// for smart-pointer interoperability. Please consider it an implementation
+/// detail that may change in the future, as formal support for smart-pointer
+/// interoperability is added into pybind11.
+template <typename type, typename holder_type, typename SFINAE = void>
+struct copyable_holder_caster : public type_caster_base<type> {
+public:
+    using base = type_caster_base<type>;
+    static_assert(std::is_base_of<base, type_caster<type>>::value,
+                  "Holder classes are only supported for custom types");
+    using base::base;
+    using base::cast;
+    using base::typeinfo;
+    using base::value;
+
+    bool load(handle src, bool convert) {
+        return base::template load_impl<copyable_holder_caster<type, holder_type>>(src, convert);
+    }
+
+    explicit operator type *() { return this->value; }
+    // static_cast works around compiler error with MSVC 17 and CUDA 10.2
+    // see issue #2180
+    explicit operator type &() { return *(static_cast<type *>(this->value)); }
+    explicit operator holder_type *() { return std::addressof(holder); }
+    explicit operator holder_type &() { return holder; }
+
+    static handle cast(const holder_type &src, return_value_policy, handle) {
+        const auto *ptr = holder_helper<holder_type>::get(src);
+        return type_caster_base<type>::cast_holder(ptr, &src);
+    }
+
+protected:
+    friend class type_caster_generic;
+    void check_holder_compat() {
+        // SMART_HOLDER_BAKEIN_FOLLOW_ON: Refine holder compatibility checks.
+        bool inst_has_unique_ptr_holder
+            = (typeinfo->holder_enum_v == holder_enum_t::std_unique_ptr);
+        if (inst_has_unique_ptr_holder) {
+            throw cast_error("Unable to load a custom holder type from a default-holder instance");
+        }
+    }
+
+    void load_value(value_and_holder &&v_h) {
+        if (v_h.holder_constructed()) {
+            value = v_h.value_ptr();
+            holder = v_h.template holder<holder_type>();
+            return;
+        }
+        throw cast_error("Unable to cast from non-held to held instance (T& to Holder<T>) "
+#if !defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+                         "(#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for "
+                         "type information)");
+#else
+                         "of type '"
+                         + type_id<holder_type>() + "''");
+#endif
+    }
+
+    template <typename T = holder_type,
+              detail::enable_if_t<!std::is_constructible<T, const T &, type *>::value, int> = 0>
+    bool try_implicit_casts(handle, bool) {
+        return false;
+    }
+
+    template <typename T = holder_type,
+              detail::enable_if_t<std::is_constructible<T, const T &, type *>::value, int> = 0>
+    bool try_implicit_casts(handle src, bool convert) {
+        for (auto &cast : typeinfo->implicit_casts) {
+            copyable_holder_caster sub_caster(*cast.first);
+            if (sub_caster.load(src, convert)) {
+                value = cast.second(sub_caster.value);
+                holder = holder_type(sub_caster.holder, (type *) value);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static bool try_direct_conversions(handle) { return false; }
+
+    holder_type holder;
+};
+
+template <typename, typename SFINAE = void>
+struct copyable_holder_caster_shared_ptr_with_smart_holder_support_enabled : std::true_type {};
+
+// SMART_HOLDER_BAKEIN_FOLLOW_ON: Refactor copyable_holder_caster to reduce code duplication.
+template <typename type>
+struct copyable_holder_caster<
+    type,
+    std::shared_ptr<type>,
+    enable_if_t<copyable_holder_caster_shared_ptr_with_smart_holder_support_enabled<type>::value>>
+    : public type_caster_base<type> {
+public:
+    using base = type_caster_base<type>;
+    static_assert(std::is_base_of<base, type_caster<type>>::value,
+                  "Holder classes are only supported for custom types");
+    using base::base;
+    using base::cast;
+    using base::typeinfo;
+    using base::value;
+
+    bool load(handle src, bool convert) {
+        if (base::template load_impl<copyable_holder_caster<type, std::shared_ptr<type>>>(
+                src, convert)) {
+            sh_load_helper.maybe_set_python_instance_is_alias(src);
+            return true;
+        }
+        return false;
+    }
+
+    explicit operator std::shared_ptr<type> *() {
+        if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
+            pybind11_fail("Passing `std::shared_ptr<T> *` from Python to C++ is not supported "
+                          "(inherently unsafe).");
+        }
+        return std::addressof(shared_ptr_storage);
+    }
+
+    explicit operator std::shared_ptr<type> &() {
+        if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
+            shared_ptr_storage = sh_load_helper.load_as_shared_ptr(typeinfo, value);
+        }
+        return shared_ptr_storage;
+    }
+
+    std::weak_ptr<type> potentially_slicing_weak_ptr() {
+        if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
+            // Reusing shared_ptr code to minimize code complexity.
+            shared_ptr_storage
+                = sh_load_helper.load_as_shared_ptr(typeinfo,
+                                                    value,
+                                                    /*responsible_parent=*/nullptr,
+                                                    /*force_potentially_slicing_shared_ptr=*/true);
+        }
+        return shared_ptr_storage;
+    }
+
+    static handle
+    cast(const std::shared_ptr<type> &src, return_value_policy policy, handle parent) {
+        const auto *ptr = src.get();
+        auto st = type_caster_base<type>::src_and_type(ptr);
+        if (st.second == nullptr) {
+            return handle(); // no type info: error will be set already
+        }
+        if (st.second->holder_enum_v == detail::holder_enum_t::smart_holder) {
+            return smart_holder_type_caster_support::smart_holder_from_shared_ptr(
+                src, policy, parent, st);
+        }
+        return type_caster_base<type>::cast_holder(ptr, &src);
+    }
+
+    // This function will succeed even if the `responsible_parent` does not own the
+    // wrapped C++ object directly.
+    // It is the responsibility of the caller to ensure that the `responsible_parent`
+    // has a `keep_alive` relationship with the owner of the wrapped C++ object, or
+    // that the wrapped C++ object lives for the duration of the process.
+    static std::shared_ptr<type> shared_ptr_with_responsible_parent(handle responsible_parent) {
+        copyable_holder_caster loader;
+        loader.load(responsible_parent, /*convert=*/false);
+        assert(loader.typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder);
+        return loader.sh_load_helper.load_as_shared_ptr(
+            loader.typeinfo, loader.value, responsible_parent);
+    }
+
+protected:
+    friend class type_caster_generic;
+    void check_holder_compat() {
+        // SMART_HOLDER_BAKEIN_FOLLOW_ON: Refine holder compatibility checks.
+        bool inst_has_unique_ptr_holder
+            = (typeinfo->holder_enum_v == holder_enum_t::std_unique_ptr);
+        if (inst_has_unique_ptr_holder) {
+            throw cast_error("Unable to load a custom holder type from a default-holder instance");
+        }
+    }
+
+    void load_value(value_and_holder &&v_h) {
+        if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
+            sh_load_helper.loaded_v_h = v_h;
+            sh_load_helper.was_populated = true;
+            value = sh_load_helper.get_void_ptr_or_nullptr();
+            return;
+        }
+        if (v_h.holder_constructed()) {
+            value = v_h.value_ptr();
+            shared_ptr_storage = v_h.template holder<std::shared_ptr<type>>();
+            return;
+        }
+        throw cast_error("Unable to cast from non-held to held instance (T& to Holder<T>) "
+#if !defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+                         "(#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for "
+                         "type information)");
+#else
+                         "of type '"
+                         + type_id<std::shared_ptr<type>>() + "''");
+#endif
+    }
+
+    template <typename T = std::shared_ptr<type>,
+              detail::enable_if_t<!std::is_constructible<T, const T &, type *>::value, int> = 0>
+    bool try_implicit_casts(handle, bool) {
+        return false;
+    }
+
+    template <typename T = std::shared_ptr<type>,
+              detail::enable_if_t<std::is_constructible<T, const T &, type *>::value, int> = 0>
+    bool try_implicit_casts(handle src, bool convert) {
+        for (auto &cast : typeinfo->implicit_casts) {
+            copyable_holder_caster sub_caster(*cast.first);
+            if (sub_caster.load(src, convert)) {
+                value = cast.second(sub_caster.value);
+                if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
+                    sh_load_helper.loaded_v_h = sub_caster.sh_load_helper.loaded_v_h;
+                } else {
+                    shared_ptr_storage
+                        = std::shared_ptr<type>(sub_caster.shared_ptr_storage, (type *) value);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static bool try_direct_conversions(handle) { return false; }
+
+    smart_holder_type_caster_support::load_helper<remove_cv_t<type>> sh_load_helper; // Const2Mutbl
+    std::shared_ptr<type> shared_ptr_storage;
+};
+
+/// Specialize for the common std::shared_ptr, so users don't need to
+template <typename T>
+class type_caster<std::shared_ptr<T>> : public copyable_holder_caster<T, std::shared_ptr<T>> {};
+
+PYBIND11_NAMESPACE_END(detail)
+
+/// Return a std::shared_ptr with the SAME CONTROL BLOCK as the std::shared_ptr owned by the
+/// class_ holder. For class_-wrapped types with trampolines, the returned std::shared_ptr
+/// does NOT keep any derived Python objects alive (see issue #1333).
+///
+/// For class_-wrapped types using std::shared_ptr as the holder, the following expressions
+/// produce equivalent results (see tests/test_potentially_slicing_weak_ptr.cpp,py):
+///
+///     - obj.cast<std::shared_ptr<T>>()
+///     - py::potentially_slicing_weak_ptr<T>(obj).lock()
+///
+/// For class_-wrapped types with trampolines and using py::smart_holder, obj.cast<>()
+/// produces a std::shared_ptr that keeps any derived Python objects alive for its own lifetime,
+/// but this is achieved by introducing a std::shared_ptr control block that is independent of
+/// the one owned by the py::smart_holder. This can lead to surprising std::weak_ptr behavior
+/// (see issue #5623). An easy solution is to use py::potentially_slicing_weak_ptr<>(obj),
+/// as exercised in tests/test_potentially_slicing_weak_ptr.cpp,py (look for
+/// "set_wp_potentially_slicing"). Note, however, that this reintroduces the inheritance
+/// slicing issue (see issue #1333). The ideal — but usually more involved — solution is to use
+/// a Python weakref to the derived Python object, instead of a C++ base-class std::weak_ptr.
+///
+/// It is not possible (at least no known approach exists at the time of this writing) to
+/// simultaneously achieve both desirable properties:
+///
+///     - the same std::shared_ptr control block as the class_ holder
+///     - automatic lifetime extension of any derived Python objects
+///
+/// The reason is that this would introduce a reference cycle that cannot be garbage collected:
+///
+///     - the derived Python object owns the class_ holder
+///     - the class_ holder owns the std::shared_ptr
+///     - the std::shared_ptr would own a reference to the derived Python object,
+///       completing the cycle
+template <typename T>
+std::weak_ptr<T> potentially_slicing_weak_ptr(handle obj) {
+    detail::make_caster<std::shared_ptr<T>> caster;
+    if (caster.load(obj, /*convert=*/true)) {
+        return caster.potentially_slicing_weak_ptr();
+    }
+    const char *obj_type_name = detail::obj_class_name(obj.ptr());
+    throw type_error("\"" + std::string(obj_type_name)
+                     + "\" object is not convertible to std::weak_ptr<T> (with T = " + type_id<T>()
+                     + ")");
+}
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+// SMART_HOLDER_BAKEIN_FOLLOW_ON: Rewrite comment, with reference to unique_ptr specialization.
+/// Type caster for holder types like std::unique_ptr.
+/// Please consider the SFINAE hook an implementation detail, as explained
+/// in the comment for the copyable_holder_caster.
+template <typename type, typename holder_type, typename SFINAE = void>
+struct move_only_holder_caster {
+    static_assert(std::is_base_of<type_caster_base<type>, type_caster<type>>::value,
+                  "Holder classes are only supported for custom types");
+
+    static handle cast(holder_type &&src, return_value_policy, handle) {
+        auto *ptr = holder_helper<holder_type>::get(src);
+        return type_caster_base<type>::cast_holder(ptr, std::addressof(src));
+    }
+    static constexpr auto name = type_caster_base<type>::name;
+};
+
+template <typename, typename SFINAE = void>
+struct move_only_holder_caster_unique_ptr_with_smart_holder_support_enabled : std::true_type {};
+
+// SMART_HOLDER_BAKEIN_FOLLOW_ON: Refactor move_only_holder_caster to reduce code duplication.
+template <typename type, typename deleter>
+struct move_only_holder_caster<
+    type,
+    std::unique_ptr<type, deleter>,
+    enable_if_t<move_only_holder_caster_unique_ptr_with_smart_holder_support_enabled<type>::value>>
+    : public type_caster_base<type> {
+public:
+    using base = type_caster_base<type>;
+    static_assert(std::is_base_of<base, type_caster<type>>::value,
+                  "Holder classes are only supported for custom types");
+    using base::base;
+    using base::cast;
+    using base::typeinfo;
+    using base::value;
+
+    static handle
+    cast(std::unique_ptr<type, deleter> &&src, return_value_policy policy, handle parent) {
+        auto *ptr = src.get();
+        auto st = type_caster_base<type>::src_and_type(ptr);
+        if (st.second == nullptr) {
+            return handle(); // no type info: error will be set already
+        }
+        if (st.second->holder_enum_v == detail::holder_enum_t::smart_holder) {
+            return smart_holder_type_caster_support::smart_holder_from_unique_ptr(
+                std::move(src), policy, parent, st);
+        }
+        return type_caster_generic::cast(st.first,
+                                         return_value_policy::take_ownership,
+                                         {},
+                                         st.second,
+                                         nullptr,
+                                         nullptr,
+                                         std::addressof(src));
+    }
+
+    static handle
+    cast(const std::unique_ptr<type, deleter> &src, return_value_policy policy, handle parent) {
+        if (!src) {
+            return none().release();
+        }
+        if (policy == return_value_policy::automatic) {
+            policy = return_value_policy::reference_internal;
+        }
+        if (policy != return_value_policy::reference_internal) {
+            throw cast_error("Invalid return_value_policy for const unique_ptr&");
+        }
+        return type_caster_base<type>::cast(src.get(), policy, parent);
+    }
+
+    bool load(handle src, bool convert) {
+        if (base::template load_impl<
+                move_only_holder_caster<type, std::unique_ptr<type, deleter>>>(src, convert)) {
+            sh_load_helper.maybe_set_python_instance_is_alias(src);
+            return true;
+        }
+        return false;
+    }
+
+    void load_value(value_and_holder &&v_h) {
+        if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
+            sh_load_helper.loaded_v_h = v_h;
+            sh_load_helper.loaded_v_h.type = typeinfo;
+            sh_load_helper.was_populated = true;
+            value = sh_load_helper.get_void_ptr_or_nullptr();
+            return;
+        }
+        pybind11_fail("Passing `std::unique_ptr<T>` from Python to C++ requires `py::class_<T, "
+                      "py::smart_holder>` (with T = "
+                      + clean_type_id(typeinfo->cpptype->name()) + ")");
+    }
+
+    template <typename T_>
+    using cast_op_type
+        = conditional_t<std::is_same<typename std::remove_volatile<T_>::type,
+                                     const std::unique_ptr<type, deleter> &>::value
+                            || std::is_same<typename std::remove_volatile<T_>::type,
+                                            const std::unique_ptr<const type, deleter> &>::value,
+                        const std::unique_ptr<type, deleter> &,
+                        std::unique_ptr<type, deleter>>;
+
+    explicit operator std::unique_ptr<type, deleter>() {
+        if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
+            return sh_load_helper.template load_as_unique_ptr<deleter>(typeinfo, value);
+        }
+        pybind11_fail("Expected to be UNREACHABLE: " __FILE__ ":" PYBIND11_TOSTRING(__LINE__));
+    }
+
+    explicit operator const std::unique_ptr<type, deleter> &() {
+        if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
+            // Get shared_ptr to ensure that the Python object is not disowned elsewhere.
+            shared_ptr_storage = sh_load_helper.load_as_shared_ptr(typeinfo, value);
+            // Build a temporary unique_ptr that is meant to never expire.
+            unique_ptr_storage = std::shared_ptr<std::unique_ptr<type, deleter>>(
+                new std::unique_ptr<type, deleter>{
+                    sh_load_helper.template load_as_const_unique_ptr<deleter>(
+                        typeinfo, shared_ptr_storage.get())},
+                [](std::unique_ptr<type, deleter> *ptr) {
+                    if (!ptr) {
+                        pybind11_fail("FATAL: `const std::unique_ptr<T, D> &` was disowned "
+                                      "(EXPECT UNDEFINED BEHAVIOR).");
+                    }
+                    (void) ptr->release();
+                    delete ptr;
+                });
+            return *unique_ptr_storage;
+        }
+        pybind11_fail("Expected to be UNREACHABLE: " __FILE__ ":" PYBIND11_TOSTRING(__LINE__));
+    }
+
+    bool try_implicit_casts(handle src, bool convert) {
+        for (auto &cast : typeinfo->implicit_casts) {
+            move_only_holder_caster sub_caster(*cast.first);
+            if (sub_caster.load(src, convert)) {
+                value = cast.second(sub_caster.value);
+                if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
+                    sh_load_helper.loaded_v_h = sub_caster.sh_load_helper.loaded_v_h;
+                } else {
+                    pybind11_fail("Expected to be UNREACHABLE: " __FILE__
+                                  ":" PYBIND11_TOSTRING(__LINE__));
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static bool try_direct_conversions(handle) { return false; }
+
+    smart_holder_type_caster_support::load_helper<remove_cv_t<type>> sh_load_helper; // Const2Mutbl
+    std::shared_ptr<type> shared_ptr_storage; // Serves as a pseudo lock.
+    std::shared_ptr<std::unique_ptr<type, deleter>> unique_ptr_storage;
+};
+
+template <typename type, typename deleter>
+class type_caster<std::unique_ptr<type, deleter>>
+    : public move_only_holder_caster<type, std::unique_ptr<type, deleter>> {};
+
+template <typename type, typename holder_type>
+using type_caster_holder = conditional_t<is_copy_constructible<holder_type>::value,
+                                         copyable_holder_caster<type, holder_type>,
+                                         move_only_holder_caster<type, holder_type>>;
+
+template <bool Value = false>
+struct always_construct_holder_value {
+    static constexpr bool value = Value;
+};
+
+template <typename T, bool Value = false>
+struct always_construct_holder : always_construct_holder_value<Value> {};
+
+/// Create a specialization for custom holder types (silently ignores std::shared_ptr)
+#define PYBIND11_DECLARE_HOLDER_TYPE(type, holder_type, ...)                                      \
+    PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)                                                  \
+    namespace detail {                                                                            \
+    template <typename type>                                                                      \
+    struct always_construct_holder<holder_type> : always_construct_holder_value<__VA_ARGS__> {};  \
+    template <typename type>                                                                      \
+    class type_caster<holder_type, enable_if_t<!is_shared_ptr<holder_type>::value>>               \
+        : public type_caster_holder<type, holder_type> {};                                        \
+    }                                                                                             \
+    PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
+
+// PYBIND11_DECLARE_HOLDER_TYPE holder types:
+template <typename base, typename holder>
+struct is_holder_type
+    : std::is_base_of<detail::type_caster_holder<base, holder>, detail::type_caster<holder>> {};
+
+// Specializations for always-supported holders:
+template <typename base, typename deleter>
+struct is_holder_type<base, std::unique_ptr<base, deleter>> : std::true_type {};
+
+template <typename base>
+struct is_holder_type<base, smart_holder> : std::true_type {};
+
+#ifdef PYBIND11_DISABLE_HANDLE_TYPE_NAME_DEFAULT_IMPLEMENTATION // See PR #4888
+
+// This leads to compilation errors if a specialization is missing.
+template <typename T>
+struct handle_type_name;
+
+#else
+
+template <typename T>
+struct handle_type_name {
+    static constexpr auto name = const_name<T>();
+};
+
+#endif
+
+template <>
+struct handle_type_name<object> {
+    static constexpr auto name = const_name("object");
+};
+template <>
+struct handle_type_name<list> {
+    static constexpr auto name = const_name("list");
+};
+template <>
+struct handle_type_name<dict> {
+    static constexpr auto name = const_name("dict");
+};
+template <>
+struct handle_type_name<anyset> {
+    static constexpr auto name = const_name("set | frozenset");
+};
+template <>
+struct handle_type_name<set> {
+    static constexpr auto name = const_name("set");
+};
+template <>
+struct handle_type_name<frozenset> {
+    static constexpr auto name = const_name("frozenset");
+};
+template <>
+struct handle_type_name<str> {
+    static constexpr auto name = const_name("str");
+};
+template <>
+struct handle_type_name<tuple> {
+    static constexpr auto name = const_name("tuple");
+};
+template <>
+struct handle_type_name<bool_> {
+    static constexpr auto name = const_name("bool");
+};
+template <>
+struct handle_type_name<bytes> {
+    static constexpr auto name = const_name(PYBIND11_BYTES_NAME);
+};
+template <>
+struct handle_type_name<buffer> {
+    static constexpr auto name = const_name(PYBIND11_BUFFER_TYPE_HINT);
+};
+template <>
+struct handle_type_name<int_> {
+    static constexpr auto name = io_name("typing.SupportsInt", "int");
+};
+template <>
+struct handle_type_name<iterable> {
+    static constexpr auto name = const_name("collections.abc.Iterable");
+};
+template <>
+struct handle_type_name<iterator> {
+    static constexpr auto name = const_name("collections.abc.Iterator");
+};
+template <>
+struct handle_type_name<float_> {
+    static constexpr auto name = io_name("typing.SupportsFloat", "float");
+};
+template <>
+struct handle_type_name<function> {
+    static constexpr auto name = const_name("collections.abc.Callable");
+};
+template <>
+struct handle_type_name<handle> {
+    static constexpr auto name = handle_type_name<object>::name;
+};
+template <>
+struct handle_type_name<none> {
+    static constexpr auto name = const_name("None");
+};
+template <>
+struct handle_type_name<sequence> {
+    static constexpr auto name = const_name("collections.abc.Sequence");
+};
+template <>
+struct handle_type_name<bytearray> {
+    static constexpr auto name = const_name("bytearray");
+};
+template <>
+struct handle_type_name<memoryview> {
+    static constexpr auto name = const_name("memoryview");
+};
+template <>
+struct handle_type_name<slice> {
+    static constexpr auto name = const_name("slice");
+};
+template <>
+struct handle_type_name<type> {
+    static constexpr auto name = const_name("type");
+};
+template <>
+struct handle_type_name<capsule> {
+    static constexpr auto name = const_name(PYBIND11_CAPSULE_TYPE_TYPE_HINT);
+};
+template <>
+struct handle_type_name<ellipsis> {
+    static constexpr auto name = const_name("ellipsis");
+};
+template <>
+struct handle_type_name<weakref> {
+    static constexpr auto name = const_name("weakref.ReferenceType");
+};
+template <>
+struct handle_type_name<args> {
+    static constexpr auto name = const_name("*args");
+};
+template <typename T>
+struct handle_type_name<Args<T>> {
+    static constexpr auto name = const_name("*args: ") + make_caster<T>::name;
+};
+template <>
+struct handle_type_name<kwargs> {
+    static constexpr auto name = const_name("**kwargs");
+};
+template <typename T>
+struct handle_type_name<KWArgs<T>> {
+    static constexpr auto name = const_name("**kwargs: ") + make_caster<T>::name;
+};
+template <>
+struct handle_type_name<obj_attr_accessor> {
+    static constexpr auto name = const_name<obj_attr_accessor>();
+};
+template <>
+struct handle_type_name<str_attr_accessor> {
+    static constexpr auto name = const_name<str_attr_accessor>();
+};
+template <>
+struct handle_type_name<item_accessor> {
+    static constexpr auto name = const_name<item_accessor>();
+};
+template <>
+struct handle_type_name<sequence_accessor> {
+    static constexpr auto name = const_name<sequence_accessor>();
+};
+template <>
+struct handle_type_name<list_accessor> {
+    static constexpr auto name = const_name<list_accessor>();
+};
+template <>
+struct handle_type_name<tuple_accessor> {
+    static constexpr auto name = const_name<tuple_accessor>();
+};
+
+template <typename type>
+struct pyobject_caster {
+    template <typename T = type, enable_if_t<std::is_same<T, handle>::value, int> = 0>
+    pyobject_caster() : value() {}
+
+    // `type` may not be default constructible (e.g. frozenset, anyset).  Initializing `value`
+    // to a nil handle is safe since it will only be accessed if `load` succeeds.
+    template <typename T = type, enable_if_t<std::is_base_of<object, T>::value, int> = 0>
+    pyobject_caster() : value(reinterpret_steal<type>(handle())) {}
+
+    template <typename T = type, enable_if_t<std::is_same<T, handle>::value, int> = 0>
+    bool load(handle src, bool /* convert */) {
+        value = src;
+        return static_cast<bool>(value);
+    }
+
+    template <typename T = type, enable_if_t<std::is_base_of<object, T>::value, int> = 0>
+    bool load(handle src, bool /* convert */) {
+        if (!isinstance<type>(src)) {
+            return false;
+        }
+        value = reinterpret_borrow<type>(src);
+        return true;
+    }
+
+    static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) {
+        return src.inc_ref();
+    }
+    PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name);
+};
+
+template <typename T>
+class type_caster<T, enable_if_t<is_pyobject<T>::value>> : public pyobject_caster<T> {};
+
+// Our conditions for enabling moving are quite restrictive:
+// At compile time:
+// - T needs to be a non-const, non-pointer, non-reference type
+// - type_caster<T>::operator T&() must exist
+// - the type must be move constructible (obviously)
+// At run-time:
+// - if the type is non-copy-constructible, the object must be the sole owner of the type (i.e. it
+//   must have ref_count() == 1)h
+// If any of the above are not satisfied, we fall back to copying.
+template <typename T>
+using move_is_plain_type
+    = satisfies_none_of<T, std::is_void, std::is_pointer, std::is_reference, std::is_const>;
+template <typename T, typename SFINAE = void>
+struct move_always : std::false_type {};
+template <typename T>
+struct move_always<
+    T,
+    enable_if_t<
+        all_of<move_is_plain_type<T>,
+               negation<is_copy_constructible<T>>,
+               is_move_constructible<T>,
+               std::is_same<decltype(std::declval<make_caster<T>>().operator T &()), T &>>::value>>
+    : std::true_type {};
+template <typename T, typename SFINAE = void>
+struct move_if_unreferenced : std::false_type {};
+template <typename T>
+struct move_if_unreferenced<
+    T,
+    enable_if_t<
+        all_of<move_is_plain_type<T>,
+               negation<move_always<T>>,
+               is_move_constructible<T>,
+               std::is_same<decltype(std::declval<make_caster<T>>().operator T &()), T &>>::value>>
+    : std::true_type {};
+template <typename T>
+using move_never = none_of<move_always<T>, move_if_unreferenced<T>>;
+
+// Detect whether returning a `type` from a cast on type's type_caster is going to result in a
+// reference or pointer to a local variable of the type_caster.  Basically, only
+// non-reference/pointer `type`s and reference/pointers from a type_caster_generic are safe;
+// everything else returns a reference/pointer to a local variable.
+template <typename type>
+using cast_is_temporary_value_reference
+    = bool_constant<(std::is_reference<type>::value || std::is_pointer<type>::value)
+                    && !std::is_base_of<type_caster_generic, make_caster<type>>::value
+                    && !std::is_same<intrinsic_t<type>, void>::value>;
+
+// When a value returned from a C++ function is being cast back to Python, we almost always want to
+// force `policy = move`, regardless of the return value policy the function/method was declared
+// with.
+template <typename Return, typename SFINAE = void>
+struct return_value_policy_override {
+    static return_value_policy policy(return_value_policy p) { return p; }
+};
+
+template <typename Return>
+struct return_value_policy_override<
+    Return,
+    detail::enable_if_t<std::is_base_of<type_caster_generic, make_caster<Return>>::value, void>> {
+    static return_value_policy policy(return_value_policy p) {
+        return !std::is_lvalue_reference<Return>::value && !std::is_pointer<Return>::value
+                   ? return_value_policy::move
+                   : p;
+    }
+};
+
+// Basic python -> C++ casting; throws if casting fails
+template <typename T, typename SFINAE>
+type_caster<T, SFINAE> &load_type(type_caster<T, SFINAE> &conv, const handle &handle) {
+    static_assert(!detail::is_pyobject<T>::value,
+                  "Internal error: type_caster should only be used for C++ types");
+    if (!conv.load(handle, true)) {
+#if !defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+        throw cast_error(
+            "Unable to cast Python instance of type "
+            + str(type::handle_of(handle)).cast<std::string>()
+            + " to C++ type '?' (#define "
+              "PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for details)");
+#else
+        throw cast_error("Unable to cast Python instance of type "
+                         + str(type::handle_of(handle)).cast<std::string>() + " to C++ type '"
+                         + type_id<T>() + "'");
+#endif
+    }
+    return conv;
+}
+// Wrapper around the above that also constructs and returns a type_caster
+template <typename T>
+make_caster<T> load_type(const handle &handle) {
+    make_caster<T> conv;
+    load_type(conv, handle);
+    return conv;
+}
+
+PYBIND11_NAMESPACE_END(detail)
+
+// pytype -> C++ type
+template <typename T,
+          detail::enable_if_t<!detail::is_pyobject<T>::value
+                                  && !detail::is_same_ignoring_cvref<T, PyObject *>::value,
+                              int>
+          = 0>
+T cast(const handle &handle) {
+    using namespace detail;
+    constexpr bool is_enum_cast = type_uses_type_caster_enum_type<intrinsic_t<T>>::value;
+    static_assert(!cast_is_temporary_value_reference<T>::value || is_enum_cast,
+                  "Unable to cast type to reference: value is local to type caster");
+#ifndef NDEBUG
+    if (is_enum_cast && cast_is_temporary_value_reference<T>::value) {
+        if (detail::global_internals_native_enum_type_map_contains(
+                std::type_index(typeid(intrinsic_t<T>)))) {
+            pybind11_fail("Unable to cast native enum type to reference");
+        }
+    }
+#endif
+    return cast_op<T>(load_type<T>(handle));
+}
+
+// pytype -> pytype (calls converting constructor)
+template <typename T, detail::enable_if_t<detail::is_pyobject<T>::value, int> = 0>
+T cast(const handle &handle) {
+    return T(reinterpret_borrow<object>(handle));
+}
+
+// Note that `cast<PyObject *>(obj)` increments the reference count of `obj`.
+// This is necessary for the case that `obj` is a temporary, and could
+// not possibly be different, given
+// 1. the established convention that the passed `handle` is borrowed, and
+// 2. we don't want to force all generic code using `cast<T>()` to special-case
+//    handling of `T` = `PyObject *` (to increment the reference count there).
+// It is the responsibility of the caller to ensure that the reference count
+// is decremented.
+template <typename T,
+          typename Handle,
+          detail::enable_if_t<detail::is_same_ignoring_cvref<T, PyObject *>::value
+                                  && detail::is_same_ignoring_cvref<Handle, handle>::value,
+                              int>
+          = 0>
+T cast(Handle &&handle) {
+    return handle.inc_ref().ptr();
+}
+// To optimize way an inc_ref/dec_ref cycle:
+template <typename T,
+          typename Object,
+          detail::enable_if_t<detail::is_same_ignoring_cvref<T, PyObject *>::value
+                                  && detail::is_same_ignoring_cvref<Object, object>::value,
+                              int>
+          = 0>
+T cast(Object &&obj) {
+    return obj.release().ptr();
+}
+
+// C++ type -> py::object
+template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0>
+object cast(T &&value,
+            return_value_policy policy = return_value_policy::automatic_reference,
+            handle parent = handle()) {
+    using no_ref_T = typename std::remove_reference<T>::type;
+    if (policy == return_value_policy::automatic) {
+        policy = std::is_pointer<no_ref_T>::value     ? return_value_policy::take_ownership
+                 : std::is_lvalue_reference<T>::value ? return_value_policy::copy
+                                                      : return_value_policy::move;
+    } else if (policy == return_value_policy::automatic_reference) {
+        policy = std::is_pointer<no_ref_T>::value     ? return_value_policy::reference
+                 : std::is_lvalue_reference<T>::value ? return_value_policy::copy
+                                                      : return_value_policy::move;
+    }
+    return reinterpret_steal<object>(
+        detail::make_caster<T>::cast(std::forward<T>(value), policy, parent));
+}
+
+template <typename T>
+T handle::cast() const {
+    return pybind11::cast<T>(*this);
+}
+template <>
+inline void handle::cast() const {
+    return;
+}
+
+template <typename T>
+detail::enable_if_t<!detail::move_never<T>::value, T> move(object &&obj) {
+    if (obj.ref_count() > 1) {
+#if !defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+        throw cast_error(
+            "Unable to cast Python " + str(type::handle_of(obj)).cast<std::string>()
+            + " instance to C++ rvalue: instance has multiple references"
+              " (#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for details)");
+#else
+        throw cast_error("Unable to move from Python "
+                         + str(type::handle_of(obj)).cast<std::string>() + " instance to C++ "
+                         + type_id<T>() + " instance: instance has multiple references");
+#endif
+    }
+
+    // Move into a temporary and return that, because the reference may be a local value of `conv`
+    T ret = std::move(detail::load_type<T>(obj).operator T &());
+    return ret;
+}
+
+// Calling cast() on an rvalue calls pybind11::cast with the object rvalue, which does:
+// - If we have to move (because T has no copy constructor), do it.  This will fail if the moved
+//   object has multiple references, but trying to copy will fail to compile.
+// - If both movable and copyable, check ref count: if 1, move; otherwise copy
+// - Otherwise (not movable), copy.
+template <typename T>
+detail::enable_if_t<!detail::is_pyobject<T>::value && detail::move_always<T>::value, T>
+cast(object &&object) {
+    return move<T>(std::move(object));
+}
+template <typename T>
+detail::enable_if_t<!detail::is_pyobject<T>::value && detail::move_if_unreferenced<T>::value, T>
+cast(object &&object) {
+    if (object.ref_count() > 1) {
+        return cast<T>(object);
+    }
+    return move<T>(std::move(object));
+}
+template <typename T>
+detail::enable_if_t<!detail::is_pyobject<T>::value && detail::move_never<T>::value, T>
+cast(object &&object) {
+    return cast<T>(object);
+}
+
+// pytype rvalue -> pytype (calls converting constructor)
+template <typename T>
+detail::enable_if_t<detail::is_pyobject<T>::value, T> cast(object &&object) {
+    return T(std::move(object));
+}
+
+template <typename T>
+T object::cast() const & {
+    return pybind11::cast<T>(*this);
+}
+template <typename T>
+T object::cast() && {
+    return pybind11::cast<T>(std::move(*this));
+}
+template <>
+inline void object::cast() const & {
+    return;
+}
+template <>
+inline void object::cast() && {
+    return;
+}
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+// forward declaration (definition in pybind11.h)
+template <typename T>
+std::string generate_type_signature();
+
+// Declared in pytypes.h:
+template <typename T, enable_if_t<!is_pyobject<T>::value, int>>
+object object_or_cast(T &&o) {
+    return pybind11::cast(std::forward<T>(o));
+}
+
+// Declared in pytypes.h:
+// Implemented here so that make_caster<T> can be used.
+template <typename D>
+template <typename T>
+str_attr_accessor object_api<D>::attr_with_type_hint(const char *key) const {
+#if !defined(__cpp_inline_variables)
+    static_assert(always_false<T>::value,
+                  "C++17 feature __cpp_inline_variables not available: "
+                  "https://en.cppreference.com/w/cpp/language/static#Static_data_members");
+#endif
+    object ann = annotations();
+    if (ann.contains(key)) {
+        throw std::runtime_error("__annotations__[\"" + std::string(key) + "\"] was set already.");
+    }
+
+    ann[key] = generate_type_signature<T>();
+    return {derived(), key};
+}
+
+template <typename D>
+template <typename T>
+obj_attr_accessor object_api<D>::attr_with_type_hint(handle key) const {
+    (void) attr_with_type_hint<T>(key.cast<std::string>().c_str());
+    return {derived(), reinterpret_borrow<object>(key)};
+}
+
+// Placeholder type for the unneeded (and dead code) static variable in the
+// PYBIND11_OVERRIDE_OVERRIDE macro
+struct override_unused {};
+template <typename ret_type>
+using override_caster_t = conditional_t<cast_is_temporary_value_reference<ret_type>::value,
+                                        make_caster<ret_type>,
+                                        override_unused>;
+
+// Trampoline use: for reference/pointer types to value-converted values, we do a value cast, then
+// store the result in the given variable.  For other types, this is a no-op.
+template <typename T>
+enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&o,
+                                                                     make_caster<T> &caster) {
+    return cast_op<T>(load_type(caster, o));
+}
+template <typename T>
+enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&,
+                                                                      override_unused &) {
+    pybind11_fail("Internal error: cast_ref fallback invoked");
+}
+
+// Trampoline use: Having a pybind11::cast with an invalid reference type is going to
+// static_assert, even though if it's in dead code, so we provide a "trampoline" to pybind11::cast
+// that only does anything in cases where pybind11::cast is valid.
+template <typename T>
+enable_if_t<cast_is_temporary_value_reference<T>::value
+                && !detail::is_same_ignoring_cvref<T, PyObject *>::value,
+            T>
+cast_safe(object &&) {
+    pybind11_fail("Internal error: cast_safe fallback invoked");
+}
+template <typename T>
+enable_if_t<std::is_void<T>::value, void> cast_safe(object &&) {}
+template <typename T>
+enable_if_t<detail::is_same_ignoring_cvref<T, PyObject *>::value, PyObject *>
+cast_safe(object &&o) {
+    return o.release().ptr();
+}
+template <typename T>
+enable_if_t<detail::none_of<cast_is_temporary_value_reference<T>,
+                            detail::is_same_ignoring_cvref<T, PyObject *>,
+                            std::is_void<T>>::value,
+            T>
+cast_safe(object &&o) {
+    return pybind11::cast<T>(std::move(o));
+}
+
+PYBIND11_NAMESPACE_END(detail)
+
+// The overloads could coexist, i.e. the #if is not strictly speaking needed,
+// but it is an easy minor optimization.
+#if !defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+inline cast_error cast_error_unable_to_convert_call_arg(const std::string &name) {
+    return cast_error("Unable to convert call argument '" + name
+                      + "' to Python object (#define "
+                        "PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for details)");
+}
+#else
+inline cast_error cast_error_unable_to_convert_call_arg(const std::string &name,
+                                                        const std::string &type) {
+    return cast_error("Unable to convert call argument '" + name + "' of type '" + type
+                      + "' to Python object");
+}
+#endif
+
+template <return_value_policy policy = return_value_policy::automatic_reference>
+tuple make_tuple() {
+    return tuple(0);
+}
+
+template <return_value_policy policy = return_value_policy::automatic_reference, typename... Args>
+tuple make_tuple(Args &&...args_) {
+    constexpr size_t size = sizeof...(Args);
+    std::array<object, size> args{{reinterpret_steal<object>(
+        detail::make_caster<Args>::cast(std::forward<Args>(args_), policy, nullptr))...}};
+    for (size_t i = 0; i < args.size(); i++) {
+        if (!args[i]) {
+#if !defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+            throw cast_error_unable_to_convert_call_arg(std::to_string(i));
+#else
+            std::array<std::string, size> argtypes{{type_id<Args>()...}};
+            throw cast_error_unable_to_convert_call_arg(std::to_string(i), argtypes[i]);
+#endif
+        }
+    }
+    tuple result(size);
+    int counter = 0;
+    for (auto &arg_value : args) {
+        PyTuple_SET_ITEM(result.ptr(), counter++, arg_value.release().ptr());
+    }
+    return result;
+}
+
+/// \ingroup annotations
+/// Annotation for arguments
+struct arg {
+    /// Constructs an argument with the name of the argument; if null or omitted, this is a
+    /// positional argument.
+    constexpr explicit arg(const char *name = nullptr)
+        : name(name), flag_noconvert(false), flag_none(true) {}
+    /// Assign a value to this argument
+    template <typename T>
+    arg_v operator=(T &&value) const;
+    /// Indicate that the type should not be converted in the type caster
+    arg &noconvert(bool flag = true) {
+        flag_noconvert = flag;
+        return *this;
+    }
+    /// Indicates that the argument should/shouldn't allow None (e.g. for nullable pointer args)
+    arg &none(bool flag = true) {
+        flag_none = flag;
+        return *this;
+    }
+
+    const char *name;        ///< If non-null, this is a named kwargs argument
+    bool flag_noconvert : 1; ///< If set, do not allow conversion (requires a supporting type
+                             ///< caster!)
+    bool flag_none : 1;      ///< If set (the default), allow None to be passed to this argument
+};
+
+/// \ingroup annotations
+/// Annotation for arguments with values
+struct arg_v : arg {
+private:
+    template <typename T>
+    arg_v(arg &&base, T &&x, const char *descr = nullptr)
+        : arg(base), value(reinterpret_steal<object>(detail::make_caster<T>::cast(
+                         std::forward<T>(x), return_value_policy::automatic, {}))),
+          descr(descr)
+#if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+          ,
+          type(type_id<T>())
+#endif
+    {
+        // Workaround! See:
+        // https://github.com/pybind/pybind11/issues/2336
+        // https://github.com/pybind/pybind11/pull/2685#issuecomment-731286700
+        if (PyErr_Occurred()) {
+            PyErr_Clear();
+        }
+    }
+
+public:
+    /// Direct construction with name, default, and description
+    template <typename T>
+    arg_v(const char *name, T &&x, const char *descr = nullptr)
+        : arg_v(arg(name), std::forward<T>(x), descr) {}
+
+    /// Called internally when invoking `py::arg("a") = value`
+    template <typename T>
+    arg_v(const arg &base, T &&x, const char *descr = nullptr)
+        : arg_v(arg(base), std::forward<T>(x), descr) {}
+
+    /// Same as `arg::noconvert()`, but returns *this as arg_v&, not arg&
+    arg_v &noconvert(bool flag = true) {
+        arg::noconvert(flag);
+        return *this;
+    }
+
+    /// Same as `arg::nonone()`, but returns *this as arg_v&, not arg&
+    arg_v &none(bool flag = true) {
+        arg::none(flag);
+        return *this;
+    }
+
+    /// The default value
+    object value;
+    /// The (optional) description of the default value
+    const char *descr;
+#if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+    /// The C++ type name of the default value (only available when compiled in debug mode)
+    std::string type;
+#endif
+};
+
+/// \ingroup annotations
+/// Annotation indicating that all following arguments are keyword-only; the is the equivalent of
+/// an unnamed '*' argument
+struct kw_only {};
+
+/// \ingroup annotations
+/// Annotation indicating that all previous arguments are positional-only; the is the equivalent of
+/// an unnamed '/' argument
+struct pos_only {};
+
+template <typename T>
+arg_v arg::operator=(T &&value) const {
+    return {*this, std::forward<T>(value)};
+}
+
+/// Alias for backward compatibility -- to be removed in version 2.0
+template <typename /*unused*/>
+using arg_t = arg_v;
+
+inline namespace literals {
+/** \rst
+    String literal version of `arg`
+ \endrst */
+constexpr arg
+#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ < 5
+operator"" _a // gcc 4.8.5 insists on having a space (hard error).
+#else
+operator""_a // clang 17 generates a deprecation warning if there is a space.
+#endif
+    (const char *name, size_t) {
+    return arg(name);
+}
+} // namespace literals
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+template <typename T>
+using is_kw_only = std::is_same<intrinsic_t<T>, kw_only>;
+template <typename T>
+using is_pos_only = std::is_same<intrinsic_t<T>, pos_only>;
+
+// forward declaration (definition in attr.h)
+struct function_record;
+
+/// Internal data associated with a single function call
+struct function_call {
+    function_call(const function_record &f, handle p); // Implementation in attr.h
+
+    /// The function data:
+    const function_record &func;
+
+    /// Arguments passed to the function:
+    std::vector<handle> args;
+
+    /// The `convert` value the arguments should be loaded with
+    std::vector<bool> args_convert;
+
+    /// Extra references for the optional `py::args` and/or `py::kwargs` arguments (which, if
+    /// present, are also in `args` but without a reference).
+    object args_ref, kwargs_ref;
+
+    /// The parent, if any
+    handle parent;
+
+    /// If this is a call to an initializer, this argument contains `self`
+    handle init_self;
+};
+
+// See PR #5396 for the discussion that led to this
+template <typename Base, typename Derived, typename = void>
+struct is_same_or_base_of : std::is_same<Base, Derived> {};
+
+// Only evaluate is_base_of if Derived is complete.
+// is_base_of raises a compiler error if Derived is incomplete.
+template <typename Base, typename Derived>
+struct is_same_or_base_of<Base, Derived, decltype(void(sizeof(Derived)))>
+    : any_of<std::is_same<Base, Derived>, std::is_base_of<Base, Derived>> {};
+
+/// Helper class which loads arguments for C++ functions called from Python
+template <typename... Args>
+class argument_loader {
+    using indices = make_index_sequence<sizeof...(Args)>;
+    template <typename Arg>
+    using argument_is_args = is_same_or_base_of<args, intrinsic_t<Arg>>;
+    template <typename Arg>
+    using argument_is_kwargs = is_same_or_base_of<kwargs, intrinsic_t<Arg>>;
+    // Get kwargs argument position, or -1 if not present:
+    static constexpr auto kwargs_pos = constexpr_last<argument_is_kwargs, Args...>();
+
+    static_assert(kwargs_pos == -1 || kwargs_pos == (int) sizeof...(Args) - 1,
+                  "py::kwargs is only permitted as the last argument of a function");
+
+public:
+    static constexpr bool has_kwargs = kwargs_pos != -1;
+
+    // py::args argument position; -1 if not present.
+    static constexpr int args_pos = constexpr_last<argument_is_args, Args...>();
+
+    static_assert(args_pos == -1 || args_pos == constexpr_first<argument_is_args, Args...>(),
+                  "py::args cannot be specified more than once");
+
+    static constexpr auto arg_names
+        = ::pybind11::detail::concat(type_descr(make_caster<Args>::name)...);
+
+    bool load_args(function_call &call) { return load_impl_sequence(call, indices{}); }
+
+    template <typename Return, typename Guard, typename Func>
+    // NOLINTNEXTLINE(readability-const-return-type)
+    enable_if_t<!std::is_void<Return>::value, Return> call(Func &&f) && {
+        return std::move(*this).template call_impl<remove_cv_t<Return>>(
+            std::forward<Func>(f), indices{}, Guard{});
+    }
+
+    template <typename Return, typename Guard, typename Func>
+    enable_if_t<std::is_void<Return>::value, void_type> call(Func &&f) && {
+        std::move(*this).template call_impl<remove_cv_t<Return>>(
+            std::forward<Func>(f), indices{}, Guard{});
+        return void_type();
+    }
+
+private:
+    static bool load_impl_sequence(function_call &, index_sequence<>) { return true; }
+
+    template <size_t... Is>
+    bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
+#ifdef __cpp_fold_expressions
+        if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is]))) {
+            return false;
+        }
+#else
+        for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...}) {
+            if (!r) {
+                return false;
+            }
+        }
+#endif
+        return true;
+    }
+
+    template <typename Return, typename Func, size_t... Is, typename Guard>
+    Return call_impl(Func &&f, index_sequence<Is...>, Guard &&) && {
+        return std::forward<Func>(f)(cast_op<Args>(std::move(std::get<Is>(argcasters)))...);
+    }
+
+    std::tuple<make_caster<Args>...> argcasters;
+};
+
+/// Helper class which collects only positional arguments for a Python function call.
+/// A fancier version below can collect any argument, but this one is optimal for simple calls.
+template <return_value_policy policy>
+class simple_collector {
+public:
+    template <typename... Ts>
+    explicit simple_collector(Ts &&...values)
+        : m_args(pybind11::make_tuple<policy>(std::forward<Ts>(values)...)) {}
+
+    const tuple &args() const & { return m_args; }
+    dict kwargs() const { return {}; }
+
+    tuple args() && { return std::move(m_args); }
+
+    /// Call a Python function and pass the collected arguments
+    object call(PyObject *ptr) const {
+        PyObject *result = PyObject_CallObject(ptr, m_args.ptr());
+        if (!result) {
+            throw error_already_set();
+        }
+        return reinterpret_steal<object>(result);
+    }
+
+private:
+    tuple m_args;
+};
+
+/// Helper class which collects positional, keyword, * and ** arguments for a Python function call
+template <return_value_policy policy>
+class unpacking_collector {
+public:
+    template <typename... Ts>
+    explicit unpacking_collector(Ts &&...values) {
+        // Tuples aren't (easily) resizable so a list is needed for collection,
+        // but the actual function call strictly requires a tuple.
+        auto args_list = list();
+        using expander = int[];
+        (void) expander{0, (process(args_list, std::forward<Ts>(values)), 0)...};
+
+        m_args = std::move(args_list);
+    }
+
+    const tuple &args() const & { return m_args; }
+    const dict &kwargs() const & { return m_kwargs; }
+
+    tuple args() && { return std::move(m_args); }
+    dict kwargs() && { return std::move(m_kwargs); }
+
+    /// Call a Python function and pass the collected arguments
+    object call(PyObject *ptr) const {
+        PyObject *result = PyObject_Call(ptr, m_args.ptr(), m_kwargs.ptr());
+        if (!result) {
+            throw error_already_set();
+        }
+        return reinterpret_steal<object>(result);
+    }
+
+private:
+    template <typename T>
+    void process(list &args_list, T &&x) {
+        auto o = reinterpret_steal<object>(
+            detail::make_caster<T>::cast(std::forward<T>(x), policy, {}));
+        if (!o) {
+#if !defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+            throw cast_error_unable_to_convert_call_arg(std::to_string(args_list.size()));
+#else
+            throw cast_error_unable_to_convert_call_arg(std::to_string(args_list.size()),
+                                                        type_id<T>());
+#endif
+        }
+        args_list.append(std::move(o));
+    }
+
+    void process(list &args_list, detail::args_proxy ap) {
+        for (auto a : ap) {
+            args_list.append(a);
+        }
+    }
+
+    void process(list & /*args_list*/, arg_v a) {
+        if (!a.name) {
+#if !defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+            nameless_argument_error();
+#else
+            nameless_argument_error(a.type);
+#endif
+        }
+        if (m_kwargs.contains(a.name)) {
+#if !defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+            multiple_values_error();
+#else
+            multiple_values_error(a.name);
+#endif
+        }
+        if (!a.value) {
+#if !defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+            throw cast_error_unable_to_convert_call_arg(a.name);
+#else
+            throw cast_error_unable_to_convert_call_arg(a.name, a.type);
+#endif
+        }
+        m_kwargs[a.name] = std::move(a.value);
+    }
+
+    void process(list & /*args_list*/, detail::kwargs_proxy kp) {
+        if (!kp) {
+            return;
+        }
+        for (auto k : reinterpret_borrow<dict>(kp)) {
+            if (m_kwargs.contains(k.first)) {
+#if !defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+                multiple_values_error();
+#else
+                multiple_values_error(str(k.first));
+#endif
+            }
+            m_kwargs[k.first] = k.second;
+        }
+    }
+
+    [[noreturn]] static void nameless_argument_error() {
+        throw type_error(
+            "Got kwargs without a name; only named arguments "
+            "may be passed via py::arg() to a python function call. "
+            "(#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for details)");
+    }
+    [[noreturn]] static void nameless_argument_error(const std::string &type) {
+        throw type_error("Got kwargs without a name of type '" + type
+                         + "'; only named "
+                           "arguments may be passed via py::arg() to a python function call. ");
+    }
+    [[noreturn]] static void multiple_values_error() {
+        throw type_error(
+            "Got multiple values for keyword argument "
+            "(#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for details)");
+    }
+
+    [[noreturn]] static void multiple_values_error(const std::string &name) {
+        throw type_error("Got multiple values for keyword argument '" + name + "'");
+    }
+
+private:
+    tuple m_args;
+    dict m_kwargs;
+};
+
+// [workaround(intel)] Separate function required here
+// We need to put this into a separate function because the Intel compiler
+// fails to compile enable_if_t<!all_of<is_positional<Args>...>::value>
+// (tested with ICC 2021.1 Beta 20200827).
+template <typename... Args>
+constexpr bool args_are_all_positional() {
+    return all_of<is_positional<Args>...>::value;
+}
+
+/// Collect only positional arguments for a Python function call
+template <return_value_policy policy,
+          typename... Args,
+          typename = enable_if_t<args_are_all_positional<Args...>()>>
+simple_collector<policy> collect_arguments(Args &&...args) {
+    return simple_collector<policy>(std::forward<Args>(args)...);
+}
+
+/// Collect all arguments, including keywords and unpacking (only instantiated when needed)
+template <return_value_policy policy,
+          typename... Args,
+          typename = enable_if_t<!args_are_all_positional<Args...>()>>
+unpacking_collector<policy> collect_arguments(Args &&...args) {
+    // Following argument order rules for generalized unpacking according to PEP 448
+    static_assert(constexpr_last<is_positional, Args...>()
+                          < constexpr_first<is_keyword_or_ds, Args...>()
+                      && constexpr_last<is_s_unpacking, Args...>()
+                             < constexpr_first<is_ds_unpacking, Args...>(),
+                  "Invalid function call: positional args must precede keywords and ** unpacking; "
+                  "* unpacking must precede ** unpacking");
+    return unpacking_collector<policy>(std::forward<Args>(args)...);
+}
+
+template <typename Derived>
+template <return_value_policy policy, typename... Args>
+object object_api<Derived>::operator()(Args &&...args) const {
+#ifndef NDEBUG
+    if (!PyGILState_Check()) {
+        pybind11_fail("pybind11::object_api<>::operator() PyGILState_Check() failure.");
+    }
+#endif
+    return detail::collect_arguments<policy>(std::forward<Args>(args)...).call(derived().ptr());
+}
+
+template <typename Derived>
+template <return_value_policy policy, typename... Args>
+object object_api<Derived>::call(Args &&...args) const {
+    return operator()<policy>(std::forward<Args>(args)...);
+}
+
+PYBIND11_NAMESPACE_END(detail)
+
+template <typename T>
+handle type::handle_of() {
+    static_assert(std::is_base_of<detail::type_caster_generic, detail::make_caster<T>>::value,
+                  "py::type::of<T> only supports the case where T is a registered C++ types.");
+
+    return detail::get_type_handle(typeid(T), true);
+}
+
+#define PYBIND11_MAKE_OPAQUE(...)                                                                 \
+    PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)                                                  \
+    namespace detail {                                                                            \
+    template <>                                                                                   \
+    class type_caster<__VA_ARGS__> : public type_caster_base<__VA_ARGS__> {};                     \
+    }                                                                                             \
+    PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
+
+/// Lets you pass a type containing a `,` through a macro parameter without needing a separate
+/// typedef, e.g.:
+/// `PYBIND11_OVERRIDE(PYBIND11_TYPE(ReturnType<A, B>), PYBIND11_TYPE(Parent<C, D>), f, arg)`
+#define PYBIND11_TYPE(...) __VA_ARGS__
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/chrono.h b/local_pybind11/pybind11/include/pybind11/chrono.h
new file mode 100644
index 000000000..d9bcc4bc4
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/chrono.h
@@ -0,0 +1,228 @@
+/*
+    pybind11/chrono.h: Transparent conversion between std::chrono and python's datetime
+
+    Copyright (c) 2016 Trent Houliston <trent@houliston.me> and
+                       Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "pybind11.h"
+
+#include <chrono>
+#include <cmath>
+#include <ctime>
+#include <datetime.h>
+#include <mutex>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+template <typename type>
+class duration_caster {
+public:
+    using rep = typename type::rep;
+    using period = typename type::period;
+
+    // signed 25 bits required by the standard.
+    using days = std::chrono::duration<int_least32_t, std::ratio<86400>>;
+
+    bool load(handle src, bool) {
+        using namespace std::chrono;
+
+        // Lazy initialise the PyDateTime import
+        if (!PyDateTimeAPI) {
+            PyDateTime_IMPORT;
+        }
+
+        if (!src) {
+            return false;
+        }
+        // If invoked with datetime.delta object
+        if (PyDelta_Check(src.ptr())) {
+            value = type(duration_cast<duration<rep, period>>(
+                days(PyDateTime_DELTA_GET_DAYS(src.ptr()))
+                + seconds(PyDateTime_DELTA_GET_SECONDS(src.ptr()))
+                + microseconds(PyDateTime_DELTA_GET_MICROSECONDS(src.ptr()))));
+            return true;
+        }
+        // If invoked with a float we assume it is seconds and convert
+        if (PyFloat_Check(src.ptr())) {
+            value = type(duration_cast<duration<rep, period>>(
+                duration<double>(PyFloat_AsDouble(src.ptr()))));
+            return true;
+        }
+        return false;
+    }
+
+    // If this is a duration just return it back
+    static const std::chrono::duration<rep, period> &
+    get_duration(const std::chrono::duration<rep, period> &src) {
+        return src;
+    }
+    static const std::chrono::duration<rep, period> &
+    get_duration(const std::chrono::duration<rep, period> &&)
+        = delete;
+
+    // If this is a time_point get the time_since_epoch
+    template <typename Clock>
+    static std::chrono::duration<rep, period>
+    get_duration(const std::chrono::time_point<Clock, std::chrono::duration<rep, period>> &src) {
+        return src.time_since_epoch();
+    }
+
+    static handle cast(const type &src, return_value_policy /* policy */, handle /* parent */) {
+        using namespace std::chrono;
+
+        // Use overloaded function to get our duration from our source
+        // Works out if it is a duration or time_point and get the duration
+        auto d = get_duration(src);
+
+        // Lazy initialise the PyDateTime import
+        if (!PyDateTimeAPI) {
+            PyDateTime_IMPORT;
+        }
+
+        // Declare these special duration types so the conversions happen with the correct
+        // primitive types (int)
+        using dd_t = duration<int, std::ratio<86400>>;
+        using ss_t = duration<int, std::ratio<1>>;
+        using us_t = duration<int, std::micro>;
+
+        auto dd = duration_cast<dd_t>(d);
+        auto subd = d - dd;
+        auto ss = duration_cast<ss_t>(subd);
+        auto us = duration_cast<us_t>(subd - ss);
+        return PyDelta_FromDSU(dd.count(), ss.count(), us.count());
+    }
+
+    PYBIND11_TYPE_CASTER(type, const_name("datetime.timedelta"));
+};
+
+inline std::tm *localtime_thread_safe(const std::time_t *time, std::tm *buf) {
+#if (defined(__STDC_LIB_EXT1__) && defined(__STDC_WANT_LIB_EXT1__)) || defined(_MSC_VER)
+    if (localtime_s(buf, time))
+        return nullptr;
+    return buf;
+#else
+    static std::mutex mtx;
+    std::lock_guard<std::mutex> lock(mtx);
+    std::tm *tm_ptr = std::localtime(time);
+    if (tm_ptr != nullptr) {
+        *buf = *tm_ptr;
+    }
+    return tm_ptr;
+#endif
+}
+
+// This is for casting times on the system clock into datetime.datetime instances
+template <typename Duration>
+class type_caster<std::chrono::time_point<std::chrono::system_clock, Duration>> {
+public:
+    using type = std::chrono::time_point<std::chrono::system_clock, Duration>;
+    bool load(handle src, bool) {
+        using namespace std::chrono;
+
+        // Lazy initialise the PyDateTime import
+        if (!PyDateTimeAPI) {
+            PyDateTime_IMPORT;
+        }
+
+        if (!src) {
+            return false;
+        }
+
+        std::tm cal;
+        microseconds msecs;
+
+        if (PyDateTime_Check(src.ptr())) {
+            cal.tm_sec = PyDateTime_DATE_GET_SECOND(src.ptr());
+            cal.tm_min = PyDateTime_DATE_GET_MINUTE(src.ptr());
+            cal.tm_hour = PyDateTime_DATE_GET_HOUR(src.ptr());
+            cal.tm_mday = PyDateTime_GET_DAY(src.ptr());
+            cal.tm_mon = PyDateTime_GET_MONTH(src.ptr()) - 1;
+            cal.tm_year = PyDateTime_GET_YEAR(src.ptr()) - 1900;
+            cal.tm_isdst = -1;
+            msecs = microseconds(PyDateTime_DATE_GET_MICROSECOND(src.ptr()));
+        } else if (PyDate_Check(src.ptr())) {
+            cal.tm_sec = 0;
+            cal.tm_min = 0;
+            cal.tm_hour = 0;
+            cal.tm_mday = PyDateTime_GET_DAY(src.ptr());
+            cal.tm_mon = PyDateTime_GET_MONTH(src.ptr()) - 1;
+            cal.tm_year = PyDateTime_GET_YEAR(src.ptr()) - 1900;
+            cal.tm_isdst = -1;
+            msecs = microseconds(0);
+        } else if (PyTime_Check(src.ptr())) {
+            cal.tm_sec = PyDateTime_TIME_GET_SECOND(src.ptr());
+            cal.tm_min = PyDateTime_TIME_GET_MINUTE(src.ptr());
+            cal.tm_hour = PyDateTime_TIME_GET_HOUR(src.ptr());
+            cal.tm_mday = 1;  // This date (day, month, year) = (1, 0, 70)
+            cal.tm_mon = 0;   // represents 1-Jan-1970, which is the first
+            cal.tm_year = 70; // earliest available date for Python's datetime
+            cal.tm_isdst = -1;
+            msecs = microseconds(PyDateTime_TIME_GET_MICROSECOND(src.ptr()));
+        } else {
+            return false;
+        }
+
+        value = time_point_cast<Duration>(system_clock::from_time_t(std::mktime(&cal)) + msecs);
+        return true;
+    }
+
+    static handle cast(const std::chrono::time_point<std::chrono::system_clock, Duration> &src,
+                       return_value_policy /* policy */,
+                       handle /* parent */) {
+        using namespace std::chrono;
+
+        // Lazy initialise the PyDateTime import
+        if (!PyDateTimeAPI) {
+            PyDateTime_IMPORT;
+        }
+
+        // Get out microseconds, and make sure they are positive, to avoid bug in eastern
+        // hemisphere time zones (cfr. https://github.com/pybind/pybind11/issues/2417)
+        using us_t = duration<int, std::micro>;
+        auto us = duration_cast<us_t>(src.time_since_epoch() % seconds(1));
+        if (us.count() < 0) {
+            us += duration_cast<us_t>(seconds(1));
+        }
+
+        // Subtract microseconds BEFORE `system_clock::to_time_t`, because:
+        // > If std::time_t has lower precision, it is implementation-defined whether the value is
+        // rounded or truncated. (https://en.cppreference.com/w/cpp/chrono/system_clock/to_time_t)
+        std::time_t tt
+            = system_clock::to_time_t(time_point_cast<system_clock::duration>(src - us));
+
+        std::tm localtime;
+        std::tm *localtime_ptr = localtime_thread_safe(&tt, &localtime);
+        if (!localtime_ptr) {
+            throw cast_error("Unable to represent system_clock in local time");
+        }
+        return PyDateTime_FromDateAndTime(localtime.tm_year + 1900,
+                                          localtime.tm_mon + 1,
+                                          localtime.tm_mday,
+                                          localtime.tm_hour,
+                                          localtime.tm_min,
+                                          localtime.tm_sec,
+                                          us.count());
+    }
+    PYBIND11_TYPE_CASTER(type, const_name("datetime.datetime"));
+};
+
+// Other clocks that are not the system clock are not measured as datetime.datetime objects
+// since they are not measured on calendar time. So instead we just make them timedeltas
+// Or if they have passed us a time as a float we convert that
+template <typename Clock, typename Duration>
+class type_caster<std::chrono::time_point<Clock, Duration>>
+    : public duration_caster<std::chrono::time_point<Clock, Duration>> {};
+
+template <typename Rep, typename Period>
+class type_caster<std::chrono::duration<Rep, Period>>
+    : public duration_caster<std::chrono::duration<Rep, Period>> {};
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/common.h b/local_pybind11/pybind11/include/pybind11/common.h
new file mode 100644
index 000000000..6c8a4f1e8
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/common.h
@@ -0,0 +1,2 @@
+#include "detail/common.h"
+#warning "Including 'common.h' is deprecated. It will be removed in v3.0. Use 'pybind11.h'."
diff --git a/local_pybind11/pybind11/include/pybind11/complex.h b/local_pybind11/pybind11/include/pybind11/complex.h
new file mode 100644
index 000000000..8a831c12c
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/complex.h
@@ -0,0 +1,74 @@
+/*
+    pybind11/complex.h: Complex number support
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "pybind11.h"
+
+#include <complex>
+
+/// glibc defines I as a macro which breaks things, e.g., boost template names
+#ifdef I
+#    undef I
+#endif
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+template <typename T>
+struct format_descriptor<std::complex<T>, detail::enable_if_t<std::is_floating_point<T>::value>> {
+    static constexpr const char c = format_descriptor<T>::c;
+    static constexpr const char value[3] = {'Z', c, '\0'};
+    static std::string format() { return std::string(value); }
+};
+
+#ifndef PYBIND11_CPP17
+
+template <typename T>
+constexpr const char
+    format_descriptor<std::complex<T>,
+                      detail::enable_if_t<std::is_floating_point<T>::value>>::value[3];
+
+#endif
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+template <typename T>
+struct is_fmt_numeric<std::complex<T>, detail::enable_if_t<std::is_floating_point<T>::value>> {
+    static constexpr bool value = true;
+    static constexpr int index = is_fmt_numeric<T>::index + 3;
+};
+
+template <typename T>
+class type_caster<std::complex<T>> {
+public:
+    bool load(handle src, bool convert) {
+        if (!src) {
+            return false;
+        }
+        if (!convert && !PyComplex_Check(src.ptr())) {
+            return false;
+        }
+        Py_complex result = PyComplex_AsCComplex(src.ptr());
+        if (result.real == -1.0 && PyErr_Occurred()) {
+            PyErr_Clear();
+            return false;
+        }
+        value = std::complex<T>((T) result.real, (T) result.imag);
+        return true;
+    }
+
+    static handle
+    cast(const std::complex<T> &src, return_value_policy /* policy */, handle /* parent */) {
+        return PyComplex_FromDoubles((double) src.real(), (double) src.imag());
+    }
+
+    PYBIND11_TYPE_CASTER(std::complex<T>, const_name("complex"));
+};
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/conduit/README.txt b/local_pybind11/pybind11/include/pybind11/conduit/README.txt
new file mode 100644
index 000000000..9a2c53ba4
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/conduit/README.txt
@@ -0,0 +1,15 @@
+NOTE
+----
+
+The C++ code here
+
+** only depends on <Python.h> **
+
+and nothing else.
+
+DO NOT ADD CODE WITH OTHER EXTERNAL DEPENDENCIES TO THIS DIRECTORY.
+
+Read on:
+
+pybind11_conduit_v1.h — Type-safe interoperability between different
+                        independent Python/C++ bindings systems.
diff --git a/local_pybind11/pybind11/include/pybind11/conduit/pybind11_conduit_v1.h b/local_pybind11/pybind11/include/pybind11/conduit/pybind11_conduit_v1.h
new file mode 100644
index 000000000..6d5d0efcb
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/conduit/pybind11_conduit_v1.h
@@ -0,0 +1,116 @@
+// Copyright (c) 2024 The pybind Community.
+
+/* The pybind11_conduit_v1 feature enables type-safe interoperability between
+
+* different independent Python/C++ bindings systems,
+
+* including pybind11 versions with different PYBIND11_INTERNALS_VERSION's.
+
+    * NOTE: The conduit feature
+            only covers    from-Python-to-C++ conversions, it
+            does not cover from-C++-to-Python conversions.
+            (For the latter, a different feature would have to be added.)
+
+The naming of the feature is a bit misleading:
+
+* The feature is in no way tied to pybind11 internals.
+
+* It just happens to originate from pybind11 and currently still lives there.
+
+* The only external dependency is <Python.h>.
+
+The implementation is a VERY light-weight dependency. It is designed to be
+compatible with any ISO C++11 (or higher) compiler, and does NOT require
+C++ Exception Handling to be enabled.
+
+Please see https://github.com/pybind/pybind11/pull/5296 for more background.
+
+The implementation involves a
+
+def _pybind11_conduit_v1_(
+    self,
+    pybind11_platform_abi_id: bytes,
+    cpp_type_info_capsule: capsule,
+    pointer_kind: bytes) -> capsule
+
+method that is meant to be added to Python objects wrapping C++ objects
+(e.g. pybind11::class_-wrapped types).
+
+The design of the _pybind11_conduit_v1_ feature provides two layers of
+protection against C++ ABI mismatches:
+
+* The first and most important layer is that the pybind11_platform_abi_id's
+  must match between extensions. — This will never be perfect, but is the same
+  pragmatic approach used in pybind11 since 2017
+  (https://github.com/pybind/pybind11/commit/96997a4b9d4ec3d389a570604394af5d5eee2557,
+  PYBIND11_INTERNALS_ID).
+
+* The second layer is that the typeid(std::type_info).name()'s must match
+  between extensions.
+
+The implementation below (which is shorter than this comment!), serves as a
+battle-tested specification. The main API is this one function:
+
+auto *cpp_pointer = pybind11_conduit_v1::get_type_pointer_ephemeral<YourType>(py_obj);
+
+It is meant to be a minimalistic reference implementation, intentionally
+without comprehensive error reporting. It is expected that major bindings
+systems will roll their own, compatible implementations, potentially with
+system-specific error reporting. The essential specifications all bindings
+systems need to agree on are merely:
+
+* PYBIND11_PLATFORM_ABI_ID (const char* literal).
+
+* The cpp_type_info capsule (see below: a void *ptr and a const char *name).
+
+* The cpp_conduit capsule (see below: a void *ptr and a const char *name).
+
+* "raw_pointer_ephemeral" means: the lifetime of the pointer is the lifetime
+  of the py_obj.
+
+*/
+
+// THIS MUST STAY AT THE TOP!
+#include "pybind11_platform_abi_id.h"
+
+#include <Python.h>
+#include <typeinfo>
+
+namespace pybind11_conduit_v1 {
+
+inline void *get_raw_pointer_ephemeral(PyObject *py_obj, const std::type_info *cpp_type_info) {
+    PyObject *cpp_type_info_capsule
+        = PyCapsule_New(const_cast<void *>(static_cast<const void *>(cpp_type_info)),
+                        typeid(std::type_info).name(),
+                        nullptr);
+    if (cpp_type_info_capsule == nullptr) {
+        return nullptr;
+    }
+    PyObject *cpp_conduit = PyObject_CallMethod(py_obj,
+                                                "_pybind11_conduit_v1_",
+                                                "yOy",
+                                                PYBIND11_PLATFORM_ABI_ID,
+                                                cpp_type_info_capsule,
+                                                "raw_pointer_ephemeral");
+    Py_DECREF(cpp_type_info_capsule);
+    if (cpp_conduit == nullptr) {
+        return nullptr;
+    }
+    void *raw_ptr = PyCapsule_GetPointer(cpp_conduit, cpp_type_info->name());
+    Py_DECREF(cpp_conduit);
+    if (PyErr_Occurred()) {
+        return nullptr;
+    }
+    return raw_ptr;
+}
+
+template <typename T>
+T *get_type_pointer_ephemeral(PyObject *py_obj) {
+    void *raw_ptr = get_raw_pointer_ephemeral(py_obj, &typeid(T));
+    if (raw_ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<T *>(raw_ptr);
+}
+
+} // namespace pybind11_conduit_v1
diff --git a/local_pybind11/pybind11/include/pybind11/conduit/pybind11_platform_abi_id.h b/local_pybind11/pybind11/include/pybind11/conduit/pybind11_platform_abi_id.h
new file mode 100644
index 000000000..d21fdc56d
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/conduit/pybind11_platform_abi_id.h
@@ -0,0 +1,87 @@
+#pragma once
+
+// Copyright (c) 2024 The pybind Community.
+
+// To maximize reusability:
+// DO NOT ADD CODE THAT REQUIRES C++ EXCEPTION HANDLING.
+
+#include "wrap_include_python_h.h"
+
+// Implementation details. DO NOT USE ELSEWHERE. (Unfortunately we cannot #undef them.)
+// This is duplicated here to maximize portability.
+#define PYBIND11_PLATFORM_ABI_ID_STRINGIFY(x) #x
+#define PYBIND11_PLATFORM_ABI_ID_TOSTRING(x) PYBIND11_PLATFORM_ABI_ID_STRINGIFY(x)
+
+#ifdef PYBIND11_COMPILER_TYPE
+//   // To maintain backward compatibility (see PR #5439).
+#    define PYBIND11_COMPILER_TYPE_LEADING_UNDERSCORE ""
+#else
+#    define PYBIND11_COMPILER_TYPE_LEADING_UNDERSCORE "_"
+#    if defined(__MINGW32__)
+#        define PYBIND11_COMPILER_TYPE "mingw"
+#    elif defined(__CYGWIN__)
+#        define PYBIND11_COMPILER_TYPE "gcc_cygwin"
+#    elif defined(_MSC_VER)
+#        define PYBIND11_COMPILER_TYPE "msvc"
+#    elif defined(__clang__) || defined(__GNUC__)
+#        define PYBIND11_COMPILER_TYPE "system" // Assumed compatible with system compiler.
+#    else
+#        error "Unknown PYBIND11_COMPILER_TYPE: PLEASE REVISE THIS CODE."
+#    endif
+#endif
+
+// PR #5439 made this macro obsolete. However, there are many manipulations of this macro in the
+// wild. Therefore, to maintain backward compatibility, it is kept around.
+#ifndef PYBIND11_STDLIB
+#    define PYBIND11_STDLIB ""
+#endif
+
+#ifndef PYBIND11_BUILD_ABI
+#    if defined(_MSC_VER)                 // See PR #4953.
+#        if defined(_MT) && defined(_DLL) // Corresponding to CL command line options /MD or /MDd.
+#            if (_MSC_VER) / 100 == 19
+#                define PYBIND11_BUILD_ABI "_md_mscver19"
+#            else
+#                error "Unknown major version for MSC_VER: PLEASE REVISE THIS CODE."
+#            endif
+#        elif defined(_MT) // Corresponding to CL command line options /MT or /MTd.
+#            define PYBIND11_BUILD_ABI "_mt_mscver" PYBIND11_PLATFORM_ABI_ID_TOSTRING(_MSC_VER)
+#        else
+#            if (_MSC_VER) / 100 == 19
+#                define PYBIND11_BUILD_ABI "_none_mscver19"
+#            else
+#                error "Unknown major version for MSC_VER: PLEASE REVISE THIS CODE."
+#            endif
+#        endif
+#    elif defined(_LIBCPP_ABI_VERSION) // https://libcxx.llvm.org/DesignDocs/ABIVersioning.html
+#        define PYBIND11_BUILD_ABI                                                                \
+            "_libcpp_abi" PYBIND11_PLATFORM_ABI_ID_TOSTRING(_LIBCPP_ABI_VERSION)
+#    elif defined(_GLIBCXX_USE_CXX11_ABI) // See PR #5439.
+#        if defined(__NVCOMPILER)
+//           // Assume that NVHPC is in the 1xxx ABI family.
+//           // THIS ASSUMPTION IS NOT FUTURE PROOF but apparently the best we can do.
+//           // Please let us know if there is a way to validate the assumption here.
+#        elif !defined(__GXX_ABI_VERSION)
+#            error                                                                                \
+                "Unknown platform or compiler (_GLIBCXX_USE_CXX11_ABI): PLEASE REVISE THIS CODE."
+#        endif
+#        if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION < 1002 || __GXX_ABI_VERSION >= 2000
+#            error "Unknown platform or compiler (__GXX_ABI_VERSION): PLEASE REVISE THIS CODE."
+#        endif
+#        define PYBIND11_BUILD_ABI                                                                \
+            "_libstdcpp_gxx_abi_1xxx_use_cxx11_abi_" PYBIND11_PLATFORM_ABI_ID_TOSTRING(           \
+                _GLIBCXX_USE_CXX11_ABI)
+#    else
+#        error "Unknown platform or compiler: PLEASE REVISE THIS CODE."
+#    endif
+#endif
+
+// On MSVC, debug and release builds are not ABI-compatible!
+#if defined(_MSC_VER) && defined(_DEBUG)
+#    define PYBIND11_BUILD_TYPE "_debug"
+#else
+#    define PYBIND11_BUILD_TYPE ""
+#endif
+
+#define PYBIND11_PLATFORM_ABI_ID                                                                  \
+    PYBIND11_COMPILER_TYPE PYBIND11_STDLIB PYBIND11_BUILD_ABI PYBIND11_BUILD_TYPE
diff --git a/local_pybind11/pybind11/include/pybind11/conduit/wrap_include_python_h.h b/local_pybind11/pybind11/include/pybind11/conduit/wrap_include_python_h.h
new file mode 100644
index 000000000..713dc4bb6
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/conduit/wrap_include_python_h.h
@@ -0,0 +1,72 @@
+#pragma once
+
+// Copyright (c) 2024 The pybind Community.
+
+// STRONG REQUIREMENT:
+//   This header is a wrapper around `#include <Python.h>`, therefore it
+//   MUST BE INCLUDED BEFORE ANY STANDARD HEADERS are included.
+// See also:
+//   https://docs.python.org/3/c-api/intro.html#include-files
+// Quoting from there:
+//   Note: Since Python may define some pre-processor definitions which affect
+//   the standard headers on some systems, you must include Python.h before
+//   any standard headers are included.
+
+// To maximize reusability:
+// DO NOT ADD CODE THAT REQUIRES C++ EXCEPTION HANDLING.
+
+// Disable linking to pythonX_d.lib on Windows in debug mode.
+#if defined(_MSC_VER) && defined(_DEBUG) && !defined(Py_DEBUG)
+// Workaround for a VS 2022 issue.
+// See https://github.com/pybind/pybind11/pull/3497 for full context.
+// NOTE: This workaround knowingly violates the Python.h include order
+//       requirement (see above).
+#    include <yvals.h>
+#    if _MSVC_STL_VERSION >= 143
+#        include <crtdefs.h>
+#    endif
+#    define PYBIND11_DEBUG_MARKER
+#    undef _DEBUG
+#endif
+
+// Don't let Python.h #define (v)snprintf as macro because they are implemented
+// properly in Visual Studio since 2015.
+#if defined(_MSC_VER)
+#    define HAVE_SNPRINTF 1
+#endif
+
+#if defined(_MSC_VER)
+#    pragma warning(push)
+#    pragma warning(disable : 4505)
+// C4505: 'PySlice_GetIndicesEx': unreferenced local function has been removed
+#endif
+
+#include <Python.h>
+#include <frameobject.h>
+#include <pythread.h>
+
+#if defined(_MSC_VER)
+#    pragma warning(pop)
+#endif
+
+#if defined(PYBIND11_DEBUG_MARKER)
+#    define _DEBUG 1
+#    undef PYBIND11_DEBUG_MARKER
+#endif
+
+// Python #defines overrides on all sorts of core functions, which
+// tends to wreak havok in C++ codebases that expect these to work
+// like regular functions (potentially with several overloads).
+#if defined(isalnum)
+#    undef isalnum
+#    undef isalpha
+#    undef islower
+#    undef isspace
+#    undef isupper
+#    undef tolower
+#    undef toupper
+#endif
+
+#if defined(copysign)
+#    undef copysign
+#endif
diff --git a/local_pybind11/pybind11/include/pybind11/critical_section.h b/local_pybind11/pybind11/include/pybind11/critical_section.h
new file mode 100644
index 000000000..2d2641204
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/critical_section.h
@@ -0,0 +1,56 @@
+// Copyright (c) 2016-2025 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#pragma once
+
+#include "pytypes.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+/// This does not do anything if there's a GIL. On free-threaded Python,
+/// it locks an object. This uses the CPython API, which has limits
+class scoped_critical_section {
+public:
+#ifdef Py_GIL_DISABLED
+    explicit scoped_critical_section(handle obj1, handle obj2 = handle{}) {
+        if (obj1) {
+            if (obj2) {
+                PyCriticalSection2_Begin(&section2, obj1.ptr(), obj2.ptr());
+                rank = 2;
+            } else {
+                PyCriticalSection_Begin(&section, obj1.ptr());
+                rank = 1;
+            }
+        } else if (obj2) {
+            PyCriticalSection_Begin(&section, obj2.ptr());
+            rank = 1;
+        }
+    }
+
+    ~scoped_critical_section() {
+        if (rank == 1) {
+            PyCriticalSection_End(&section);
+        } else if (rank == 2) {
+            PyCriticalSection2_End(&section2);
+        }
+    }
+#else
+    explicit scoped_critical_section(handle, handle = handle{}) {};
+    ~scoped_critical_section() = default;
+#endif
+
+    scoped_critical_section(const scoped_critical_section &) = delete;
+    scoped_critical_section &operator=(const scoped_critical_section &) = delete;
+
+private:
+#ifdef Py_GIL_DISABLED
+    int rank{0};
+    union {
+        PyCriticalSection section;
+        PyCriticalSection2 section2;
+    };
+#endif
+};
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/detail/class.h b/local_pybind11/pybind11/include/pybind11/detail/class.h
new file mode 100644
index 000000000..cd7e87f84
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/class.h
@@ -0,0 +1,823 @@
+/*
+    pybind11/detail/class.h: Python C API implementation details for py::class_
+
+    Copyright (c) 2017 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include <pybind11/attr.h>
+#include <pybind11/options.h>
+
+#include "exception_translation.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+#if !defined(PYPY_VERSION)
+#    define PYBIND11_BUILTIN_QUALNAME
+#    define PYBIND11_SET_OLDPY_QUALNAME(obj, nameobj)
+#else
+// In PyPy, we still set __qualname__ so that we can produce reliable function type
+// signatures; in CPython this macro expands to nothing:
+#    define PYBIND11_SET_OLDPY_QUALNAME(obj, nameobj)                                             \
+        setattr((PyObject *) obj, "__qualname__", nameobj)
+#endif
+
+inline std::string get_fully_qualified_tp_name(PyTypeObject *type) {
+#if !defined(PYPY_VERSION)
+    return type->tp_name;
+#else
+    auto module_name = handle((PyObject *) type).attr("__module__").cast<std::string>();
+    if (module_name == PYBIND11_BUILTINS_MODULE)
+        return type->tp_name;
+    else
+        return std::move(module_name) + "." + type->tp_name;
+#endif
+}
+
+inline PyTypeObject *type_incref(PyTypeObject *type) {
+    Py_INCREF(type);
+    return type;
+}
+
+#if !defined(PYPY_VERSION)
+
+/// `pybind11_static_property.__get__()`: Always pass the class instead of the instance.
+extern "C" inline PyObject *pybind11_static_get(PyObject *self, PyObject * /*ob*/, PyObject *cls) {
+    return PyProperty_Type.tp_descr_get(self, cls, cls);
+}
+
+/// `pybind11_static_property.__set__()`: Just like the above `__get__()`.
+extern "C" inline int pybind11_static_set(PyObject *self, PyObject *obj, PyObject *value) {
+    PyObject *cls = PyType_Check(obj) ? obj : (PyObject *) Py_TYPE(obj);
+    return PyProperty_Type.tp_descr_set(self, cls, value);
+}
+
+// Forward declaration to use in `make_static_property_type()`
+inline void enable_dynamic_attributes(PyHeapTypeObject *heap_type);
+
+/** A `static_property` is the same as a `property` but the `__get__()` and `__set__()`
+    methods are modified to always use the object type instead of a concrete instance.
+    Return value: New reference. */
+inline PyTypeObject *make_static_property_type() {
+    constexpr auto *name = "pybind11_static_property";
+    auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name));
+
+    /* Danger zone: from now (and until PyType_Ready), make sure to
+       issue no Python C API calls which could potentially invoke the
+       garbage collector (the GC will call type_traverse(), which will in
+       turn find the newly constructed type in an invalid state) */
+    auto *heap_type = (PyHeapTypeObject *) PyType_Type.tp_alloc(&PyType_Type, 0);
+    if (!heap_type) {
+        pybind11_fail("make_static_property_type(): error allocating type!");
+    }
+
+    heap_type->ht_name = name_obj.inc_ref().ptr();
+#    ifdef PYBIND11_BUILTIN_QUALNAME
+    heap_type->ht_qualname = name_obj.inc_ref().ptr();
+#    endif
+
+    auto *type = &heap_type->ht_type;
+    type->tp_name = name;
+    type->tp_base = type_incref(&PyProperty_Type);
+    type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
+    type->tp_descr_get = pybind11_static_get;
+    type->tp_descr_set = pybind11_static_set;
+
+#    if PY_VERSION_HEX >= 0x030C0000
+    // Since Python-3.12 property-derived types are required to
+    // have dynamic attributes (to set `__doc__`)
+    enable_dynamic_attributes(heap_type);
+#    endif
+
+    if (PyType_Ready(type) < 0) {
+        pybind11_fail("make_static_property_type(): failure in PyType_Ready()!");
+    }
+
+    setattr((PyObject *) type, "__module__", str(PYBIND11_DUMMY_MODULE_NAME));
+    PYBIND11_SET_OLDPY_QUALNAME(type, name_obj);
+
+    return type;
+}
+
+#else // PYPY
+
+/** PyPy has some issues with the above C API, so we evaluate Python code instead.
+    This function will only be called once so performance isn't really a concern.
+    Return value: New reference. */
+inline PyTypeObject *make_static_property_type() {
+    auto d = dict();
+    PyObject *result = PyRun_String(R"(\
+class pybind11_static_property(property):
+    def __get__(self, obj, cls):
+        return property.__get__(self, cls, cls)
+
+    def __set__(self, obj, value):
+        cls = obj if isinstance(obj, type) else type(obj)
+        property.__set__(self, cls, value)
+)",
+                                    Py_file_input,
+                                    d.ptr(),
+                                    d.ptr());
+    if (result == nullptr)
+        throw error_already_set();
+    Py_DECREF(result);
+    return (PyTypeObject *) d["pybind11_static_property"].cast<object>().release().ptr();
+}
+
+#endif // PYPY
+
+/** Types with static properties need to handle `Type.static_prop = x` in a specific way.
+    By default, Python replaces the `static_property` itself, but for wrapped C++ types
+    we need to call `static_property.__set__()` in order to propagate the new value to
+    the underlying C++ data structure. */
+extern "C" inline int pybind11_meta_setattro(PyObject *obj, PyObject *name, PyObject *value) {
+    // Use `_PyType_Lookup()` instead of `PyObject_GetAttr()` in order to get the raw
+    // descriptor (`property`) instead of calling `tp_descr_get` (`property.__get__()`).
+    PyObject *descr = _PyType_Lookup((PyTypeObject *) obj, name);
+
+    // The following assignment combinations are possible:
+    //   1. `Type.static_prop = value`             --> descr_set: `Type.static_prop.__set__(value)`
+    //   2. `Type.static_prop = other_static_prop` --> setattro:  replace existing `static_prop`
+    //   3. `Type.regular_attribute = value`       --> setattro:  regular attribute assignment
+    auto *const static_prop = (PyObject *) get_internals().static_property_type;
+    const auto call_descr_set = (descr != nullptr) && (value != nullptr)
+                                && (PyObject_IsInstance(descr, static_prop) != 0)
+                                && (PyObject_IsInstance(value, static_prop) == 0);
+    if (call_descr_set) {
+        // Call `static_property.__set__()` instead of replacing the `static_property`.
+#if !defined(PYPY_VERSION)
+        return Py_TYPE(descr)->tp_descr_set(descr, obj, value);
+#else
+        if (PyObject *result = PyObject_CallMethod(descr, "__set__", "OO", obj, value)) {
+            Py_DECREF(result);
+            return 0;
+        } else {
+            return -1;
+        }
+#endif
+    } else {
+        // Replace existing attribute.
+        return PyType_Type.tp_setattro(obj, name, value);
+    }
+}
+
+/**
+ * Python 3's PyInstanceMethod_Type hides itself via its tp_descr_get, which prevents aliasing
+ * methods via cls.attr("m2") = cls.attr("m1"): instead the tp_descr_get returns a plain function,
+ * when called on a class, or a PyMethod, when called on an instance.  Override that behaviour here
+ * to do a special case bypass for PyInstanceMethod_Types.
+ */
+extern "C" inline PyObject *pybind11_meta_getattro(PyObject *obj, PyObject *name) {
+    PyObject *descr = _PyType_Lookup((PyTypeObject *) obj, name);
+    if (descr && PyInstanceMethod_Check(descr)) {
+        Py_INCREF(descr);
+        return descr;
+    }
+    return PyType_Type.tp_getattro(obj, name);
+}
+
+/// metaclass `__call__` function that is used to create all pybind11 objects.
+extern "C" inline PyObject *pybind11_meta_call(PyObject *type, PyObject *args, PyObject *kwargs) {
+
+    // use the default metaclass call to create/initialize the object
+    PyObject *self = PyType_Type.tp_call(type, args, kwargs);
+    if (self == nullptr) {
+        return nullptr;
+    }
+
+    // Ensure that the base __init__ function(s) were called
+    values_and_holders vhs(self);
+    for (const auto &vh : vhs) {
+        if (!vh.holder_constructed() && !vhs.is_redundant_value_and_holder(vh)) {
+            PyErr_Format(PyExc_TypeError,
+                         "%.200s.__init__() must be called when overriding __init__",
+                         get_fully_qualified_tp_name(vh.type->type).c_str());
+            Py_DECREF(self);
+            return nullptr;
+        }
+    }
+
+    return self;
+}
+
+/// Cleanup the type-info for a pybind11-registered type.
+extern "C" inline void pybind11_meta_dealloc(PyObject *obj) {
+    with_internals([obj](internals &internals) {
+        auto *type = (PyTypeObject *) obj;
+
+        // A pybind11-registered type will:
+        // 1) be found in internals.registered_types_py
+        // 2) have exactly one associated `detail::type_info`
+        auto found_type = internals.registered_types_py.find(type);
+        if (found_type != internals.registered_types_py.end() && found_type->second.size() == 1
+            && found_type->second[0]->type == type) {
+
+            auto *tinfo = found_type->second[0];
+            auto tindex = std::type_index(*tinfo->cpptype);
+            internals.direct_conversions.erase(tindex);
+
+            if (tinfo->module_local) {
+                get_local_internals().registered_types_cpp.erase(tindex);
+            } else {
+                internals.registered_types_cpp.erase(tindex);
+            }
+            internals.registered_types_py.erase(tinfo->type);
+
+            // Actually just `std::erase_if`, but that's only available in C++20
+            auto &cache = internals.inactive_override_cache;
+            for (auto it = cache.begin(), last = cache.end(); it != last;) {
+                if (it->first == (PyObject *) tinfo->type) {
+                    it = cache.erase(it);
+                } else {
+                    ++it;
+                }
+            }
+
+            delete tinfo;
+        }
+    });
+
+    PyType_Type.tp_dealloc(obj);
+}
+
+/** This metaclass is assigned by default to all pybind11 types and is required in order
+    for static properties to function correctly. Users may override this using `py::metaclass`.
+    Return value: New reference. */
+inline PyTypeObject *make_default_metaclass() {
+    constexpr auto *name = "pybind11_type";
+    auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name));
+
+    /* Danger zone: from now (and until PyType_Ready), make sure to
+       issue no Python C API calls which could potentially invoke the
+       garbage collector (the GC will call type_traverse(), which will in
+       turn find the newly constructed type in an invalid state) */
+    auto *heap_type = (PyHeapTypeObject *) PyType_Type.tp_alloc(&PyType_Type, 0);
+    if (!heap_type) {
+        pybind11_fail("make_default_metaclass(): error allocating metaclass!");
+    }
+
+    heap_type->ht_name = name_obj.inc_ref().ptr();
+#ifdef PYBIND11_BUILTIN_QUALNAME
+    heap_type->ht_qualname = name_obj.inc_ref().ptr();
+#endif
+
+    auto *type = &heap_type->ht_type;
+    type->tp_name = name;
+    type->tp_base = type_incref(&PyType_Type);
+    type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
+
+    type->tp_call = pybind11_meta_call;
+
+    type->tp_setattro = pybind11_meta_setattro;
+    type->tp_getattro = pybind11_meta_getattro;
+
+    type->tp_dealloc = pybind11_meta_dealloc;
+
+    if (PyType_Ready(type) < 0) {
+        pybind11_fail("make_default_metaclass(): failure in PyType_Ready()!");
+    }
+
+    setattr((PyObject *) type, "__module__", str(PYBIND11_DUMMY_MODULE_NAME));
+    PYBIND11_SET_OLDPY_QUALNAME(type, name_obj);
+
+    return type;
+}
+
+/// For multiple inheritance types we need to recursively register/deregister base pointers for any
+/// base classes with pointers that are difference from the instance value pointer so that we can
+/// correctly recognize an offset base class pointer. This calls a function with any offset base
+/// ptrs.
+inline void traverse_offset_bases(void *valueptr,
+                                  const detail::type_info *tinfo,
+                                  instance *self,
+                                  bool (*f)(void * /*parentptr*/, instance * /*self*/)) {
+    for (handle h : reinterpret_borrow<tuple>(tinfo->type->tp_bases)) {
+        if (auto *parent_tinfo = get_type_info((PyTypeObject *) h.ptr())) {
+            for (auto &c : parent_tinfo->implicit_casts) {
+                if (c.first == tinfo->cpptype) {
+                    auto *parentptr = c.second(valueptr);
+                    if (parentptr != valueptr) {
+                        f(parentptr, self);
+                    }
+                    traverse_offset_bases(parentptr, parent_tinfo, self, f);
+                    break;
+                }
+            }
+        }
+    }
+}
+
+#ifdef Py_GIL_DISABLED
+inline void enable_try_inc_ref(PyObject *obj) {
+    // TODO: Replace with PyUnstable_Object_EnableTryIncRef when available.
+    // See https://github.com/python/cpython/issues/128844
+    if (_Py_IsImmortal(obj)) {
+        return;
+    }
+    for (;;) {
+        Py_ssize_t shared = _Py_atomic_load_ssize_relaxed(&obj->ob_ref_shared);
+        if ((shared & _Py_REF_SHARED_FLAG_MASK) != 0) {
+            // Nothing to do if it's in WEAKREFS, QUEUED, or MERGED states.
+            return;
+        }
+        if (_Py_atomic_compare_exchange_ssize(
+                &obj->ob_ref_shared, &shared, shared | _Py_REF_MAYBE_WEAKREF)) {
+            return;
+        }
+    }
+}
+#endif
+
+inline bool register_instance_impl(void *ptr, instance *self) {
+#ifdef Py_GIL_DISABLED
+    enable_try_inc_ref(reinterpret_cast<PyObject *>(self));
+#endif
+    with_instance_map(ptr, [&](instance_map &instances) { instances.emplace(ptr, self); });
+    return true; // unused, but gives the same signature as the deregister func
+}
+inline bool deregister_instance_impl(void *ptr, instance *self) {
+    return with_instance_map(ptr, [&](instance_map &instances) {
+        auto range = instances.equal_range(ptr);
+        for (auto it = range.first; it != range.second; ++it) {
+            if (self == it->second) {
+                instances.erase(it);
+                return true;
+            }
+        }
+        return false;
+    });
+}
+
+inline void register_instance(instance *self, void *valptr, const type_info *tinfo) {
+    register_instance_impl(valptr, self);
+    if (!tinfo->simple_ancestors) {
+        traverse_offset_bases(valptr, tinfo, self, register_instance_impl);
+    }
+}
+
+inline bool deregister_instance(instance *self, void *valptr, const type_info *tinfo) {
+    bool ret = deregister_instance_impl(valptr, self);
+    if (!tinfo->simple_ancestors) {
+        traverse_offset_bases(valptr, tinfo, self, deregister_instance_impl);
+    }
+    return ret;
+}
+
+/// Instance creation function for all pybind11 types. It allocates the internal instance layout
+/// for holding C++ objects and holders.  Allocation is done lazily (the first time the instance is
+/// cast to a reference or pointer), and initialization is done by an `__init__` function.
+inline PyObject *make_new_instance(PyTypeObject *type) {
+#if defined(PYPY_VERSION)
+    // PyPy gets tp_basicsize wrong (issue 2482) under multiple inheritance when the first
+    // inherited object is a plain Python type (i.e. not derived from an extension type).  Fix it.
+    ssize_t instance_size = static_cast<ssize_t>(sizeof(instance));
+    if (type->tp_basicsize < instance_size) {
+        type->tp_basicsize = instance_size;
+    }
+#endif
+    PyObject *self = type->tp_alloc(type, 0);
+    auto *inst = reinterpret_cast<instance *>(self);
+    // Allocate the value/holder internals:
+    inst->allocate_layout();
+
+    return self;
+}
+
+/// Instance creation function for all pybind11 types. It only allocates space for the
+/// C++ object, but doesn't call the constructor -- an `__init__` function must do that.
+extern "C" inline PyObject *pybind11_object_new(PyTypeObject *type, PyObject *, PyObject *) {
+    return make_new_instance(type);
+}
+
+/// An `__init__` function constructs the C++ object. Users should provide at least one
+/// of these using `py::init` or directly with `.def(__init__, ...)`. Otherwise, the
+/// following default function will be used which simply throws an exception.
+extern "C" inline int pybind11_object_init(PyObject *self, PyObject *, PyObject *) {
+    PyTypeObject *type = Py_TYPE(self);
+    std::string msg = get_fully_qualified_tp_name(type) + ": No constructor defined!";
+    set_error(PyExc_TypeError, msg.c_str());
+    return -1;
+}
+
+inline void add_patient(PyObject *nurse, PyObject *patient) {
+    auto *instance = reinterpret_cast<detail::instance *>(nurse);
+    instance->has_patients = true;
+    Py_INCREF(patient);
+
+    with_internals([&](internals &internals) { internals.patients[nurse].push_back(patient); });
+}
+
+inline void clear_patients(PyObject *self) {
+    auto *instance = reinterpret_cast<detail::instance *>(self);
+    std::vector<PyObject *> patients;
+
+    with_internals([&](internals &internals) {
+        auto pos = internals.patients.find(self);
+
+        if (pos == internals.patients.end()) {
+            pybind11_fail(
+                "FATAL: Internal consistency check failed: Invalid clear_patients() call.");
+        }
+
+        // Clearing the patients can cause more Python code to run, which
+        // can invalidate the iterator. Extract the vector of patients
+        // from the unordered_map first.
+        patients = std::move(pos->second);
+        internals.patients.erase(pos);
+    });
+
+    instance->has_patients = false;
+    for (PyObject *&patient : patients) {
+        Py_CLEAR(patient);
+    }
+}
+
+/// Clears all internal data from the instance and removes it from registered instances in
+/// preparation for deallocation.
+inline void clear_instance(PyObject *self) {
+    auto *instance = reinterpret_cast<detail::instance *>(self);
+
+    // Deallocate any values/holders, if present:
+    for (auto &v_h : values_and_holders(instance)) {
+        if (v_h) {
+
+            // We have to deregister before we call dealloc because, for virtual MI types, we still
+            // need to be able to get the parent pointers.
+            if (v_h.instance_registered()
+                && !deregister_instance(instance, v_h.value_ptr(), v_h.type)) {
+                pybind11_fail(
+                    "pybind11_object_dealloc(): Tried to deallocate unregistered instance!");
+            }
+
+            if (instance->owned || v_h.holder_constructed()) {
+                v_h.type->dealloc(v_h);
+            }
+        } else if (v_h.holder_constructed()) {
+            v_h.type->dealloc(v_h); // Disowned instance.
+        }
+    }
+    // Deallocate the value/holder layout internals:
+    instance->deallocate_layout();
+
+    if (instance->weakrefs) {
+        PyObject_ClearWeakRefs(self);
+    }
+
+    PyObject **dict_ptr = _PyObject_GetDictPtr(self);
+    if (dict_ptr) {
+        Py_CLEAR(*dict_ptr);
+    }
+
+    if (instance->has_patients) {
+        clear_patients(self);
+    }
+}
+
+/// Instance destructor function for all pybind11 types. It calls `type_info.dealloc`
+/// to destroy the C++ object itself, while the rest is Python bookkeeping.
+extern "C" inline void pybind11_object_dealloc(PyObject *self) {
+    auto *type = Py_TYPE(self);
+
+    // If this is a GC tracked object, untrack it first
+    // Note that the track call is implicitly done by the
+    // default tp_alloc, which we never override.
+    if (PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC) != 0) {
+        PyObject_GC_UnTrack(self);
+    }
+
+    clear_instance(self);
+
+    type->tp_free(self);
+
+    // This was not needed before Python 3.8 (Python issue 35810)
+    // https://github.com/pybind/pybind11/issues/1946
+    Py_DECREF(type);
+}
+
+PYBIND11_WARNING_PUSH
+PYBIND11_WARNING_DISABLE_GCC("-Wredundant-decls")
+
+std::string error_string();
+
+PYBIND11_WARNING_POP
+
+/** Create the type which can be used as a common base for all classes.  This is
+    needed in order to satisfy Python's requirements for multiple inheritance.
+    Return value: New reference. */
+inline PyObject *make_object_base_type(PyTypeObject *metaclass) {
+    constexpr auto *name = "pybind11_object";
+    auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name));
+
+    /* Danger zone: from now (and until PyType_Ready), make sure to
+       issue no Python C API calls which could potentially invoke the
+       garbage collector (the GC will call type_traverse(), which will in
+       turn find the newly constructed type in an invalid state) */
+    auto *heap_type = (PyHeapTypeObject *) metaclass->tp_alloc(metaclass, 0);
+    if (!heap_type) {
+        pybind11_fail("make_object_base_type(): error allocating type!");
+    }
+
+    heap_type->ht_name = name_obj.inc_ref().ptr();
+#ifdef PYBIND11_BUILTIN_QUALNAME
+    heap_type->ht_qualname = name_obj.inc_ref().ptr();
+#endif
+
+    auto *type = &heap_type->ht_type;
+    type->tp_name = name;
+    type->tp_base = type_incref(&PyBaseObject_Type);
+    type->tp_basicsize = static_cast<ssize_t>(sizeof(instance));
+    type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
+
+    type->tp_new = pybind11_object_new;
+    type->tp_init = pybind11_object_init;
+    type->tp_dealloc = pybind11_object_dealloc;
+
+    /* Support weak references (needed for the keep_alive feature) */
+    type->tp_weaklistoffset = offsetof(instance, weakrefs);
+
+    if (PyType_Ready(type) < 0) {
+        pybind11_fail("PyType_Ready failed in make_object_base_type(): " + error_string());
+    }
+
+    setattr((PyObject *) type, "__module__", str(PYBIND11_DUMMY_MODULE_NAME));
+    PYBIND11_SET_OLDPY_QUALNAME(type, name_obj);
+
+    assert(!PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC));
+    return (PyObject *) heap_type;
+}
+
+/// dynamic_attr: Allow the garbage collector to traverse the internal instance `__dict__`.
+extern "C" inline int pybind11_traverse(PyObject *self, visitproc visit, void *arg) {
+#if PY_VERSION_HEX >= 0x030D0000
+    PyObject_VisitManagedDict(self, visit, arg);
+#else
+    PyObject *&dict = *_PyObject_GetDictPtr(self);
+    Py_VISIT(dict);
+#endif
+// https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_traverse
+#if PY_VERSION_HEX >= 0x03090000
+    Py_VISIT(Py_TYPE(self));
+#endif
+    return 0;
+}
+
+/// dynamic_attr: Allow the GC to clear the dictionary.
+extern "C" inline int pybind11_clear(PyObject *self) {
+#if PY_VERSION_HEX >= 0x030D0000
+    PyObject_ClearManagedDict(self);
+#else
+    PyObject *&dict = *_PyObject_GetDictPtr(self);
+    Py_CLEAR(dict);
+#endif
+    return 0;
+}
+
+/// Give instances of this type a `__dict__` and opt into garbage collection.
+inline void enable_dynamic_attributes(PyHeapTypeObject *heap_type) {
+    auto *type = &heap_type->ht_type;
+    type->tp_flags |= Py_TPFLAGS_HAVE_GC;
+#ifdef PYBIND11_BACKWARD_COMPATIBILITY_TP_DICTOFFSET
+    type->tp_dictoffset = type->tp_basicsize;           // place dict at the end
+    type->tp_basicsize += (ssize_t) sizeof(PyObject *); // and allocate enough space for it
+#else
+    type->tp_flags |= Py_TPFLAGS_MANAGED_DICT;
+#endif
+    type->tp_traverse = pybind11_traverse;
+    type->tp_clear = pybind11_clear;
+
+    static PyGetSetDef getset[]
+        = {{"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict, nullptr, nullptr},
+           {nullptr, nullptr, nullptr, nullptr, nullptr}};
+    type->tp_getset = getset;
+}
+
+/// buffer_protocol: Fill in the view as specified by flags.
+extern "C" inline int pybind11_getbuffer(PyObject *obj, Py_buffer *view, int flags) {
+    // Look for a `get_buffer` implementation in this type's info or any bases (following MRO).
+    type_info *tinfo = nullptr;
+    for (auto type : reinterpret_borrow<tuple>(Py_TYPE(obj)->tp_mro)) {
+        tinfo = get_type_info((PyTypeObject *) type.ptr());
+        if (tinfo && tinfo->get_buffer) {
+            break;
+        }
+    }
+    if (view == nullptr || !tinfo || !tinfo->get_buffer) {
+        if (view) {
+            view->obj = nullptr;
+        }
+        set_error(PyExc_BufferError, "pybind11_getbuffer(): Internal error");
+        return -1;
+    }
+    std::memset(view, 0, sizeof(Py_buffer));
+    std::unique_ptr<buffer_info> info = nullptr;
+    try {
+        info.reset(tinfo->get_buffer(obj, tinfo->get_buffer_data));
+    } catch (...) {
+        try_translate_exceptions();
+        raise_from(PyExc_BufferError, "Error getting buffer");
+        return -1;
+    }
+    if (info == nullptr) {
+        pybind11_fail("FATAL UNEXPECTED SITUATION: tinfo->get_buffer() returned nullptr.");
+    }
+
+    if ((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE && info->readonly) {
+        // view->obj = nullptr;  // Was just memset to 0, so not necessary
+        set_error(PyExc_BufferError, "Writable buffer requested for readonly storage");
+        return -1;
+    }
+
+    // Fill in all the information, and then downgrade as requested by the caller, or raise an
+    // error if that's not possible.
+    view->itemsize = info->itemsize;
+    view->len = view->itemsize;
+    for (auto s : info->shape) {
+        view->len *= s;
+    }
+    view->ndim = static_cast<int>(info->ndim);
+    view->shape = info->shape.data();
+    view->strides = info->strides.data();
+    view->readonly = static_cast<int>(info->readonly);
+    if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) {
+        view->format = const_cast<char *>(info->format.c_str());
+    }
+
+    // Note, all contiguity flags imply PyBUF_STRIDES and lower.
+    if ((flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) {
+        if (PyBuffer_IsContiguous(view, 'C') == 0) {
+            std::memset(view, 0, sizeof(Py_buffer));
+            set_error(PyExc_BufferError,
+                      "C-contiguous buffer requested for discontiguous storage");
+            return -1;
+        }
+    } else if ((flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) {
+        if (PyBuffer_IsContiguous(view, 'F') == 0) {
+            std::memset(view, 0, sizeof(Py_buffer));
+            set_error(PyExc_BufferError,
+                      "Fortran-contiguous buffer requested for discontiguous storage");
+            return -1;
+        }
+    } else if ((flags & PyBUF_ANY_CONTIGUOUS) == PyBUF_ANY_CONTIGUOUS) {
+        if (PyBuffer_IsContiguous(view, 'A') == 0) {
+            std::memset(view, 0, sizeof(Py_buffer));
+            set_error(PyExc_BufferError, "Contiguous buffer requested for discontiguous storage");
+            return -1;
+        }
+
+    } else if ((flags & PyBUF_STRIDES) != PyBUF_STRIDES) {
+        // If no strides are requested, the buffer must be C-contiguous.
+        // https://docs.python.org/3/c-api/buffer.html#contiguity-requests
+        if (PyBuffer_IsContiguous(view, 'C') == 0) {
+            std::memset(view, 0, sizeof(Py_buffer));
+            set_error(PyExc_BufferError,
+                      "C-contiguous buffer requested for discontiguous storage");
+            return -1;
+        }
+
+        view->strides = nullptr;
+
+        // Since this is a contiguous buffer, it can also pretend to be 1D.
+        if ((flags & PyBUF_ND) != PyBUF_ND) {
+            view->shape = nullptr;
+            view->ndim = 0;
+        }
+    }
+
+    // Set these after all checks so they don't leak out into the caller, and can be automatically
+    // cleaned up on error.
+    view->buf = info->ptr;
+    view->internal = info.release();
+    view->obj = obj;
+    Py_INCREF(view->obj);
+    return 0;
+}
+
+/// buffer_protocol: Release the resources of the buffer.
+extern "C" inline void pybind11_releasebuffer(PyObject *, Py_buffer *view) {
+    delete (buffer_info *) view->internal;
+}
+
+/// Give this type a buffer interface.
+inline void enable_buffer_protocol(PyHeapTypeObject *heap_type) {
+    heap_type->ht_type.tp_as_buffer = &heap_type->as_buffer;
+
+    heap_type->as_buffer.bf_getbuffer = pybind11_getbuffer;
+    heap_type->as_buffer.bf_releasebuffer = pybind11_releasebuffer;
+}
+
+/** Create a brand new Python type according to the `type_record` specification.
+    Return value: New reference. */
+inline PyObject *make_new_python_type(const type_record &rec) {
+    auto name = reinterpret_steal<object>(PYBIND11_FROM_STRING(rec.name));
+
+    auto qualname = name;
+    if (rec.scope && !PyModule_Check(rec.scope.ptr()) && hasattr(rec.scope, "__qualname__")) {
+        qualname = reinterpret_steal<object>(
+            PyUnicode_FromFormat("%U.%U", rec.scope.attr("__qualname__").ptr(), name.ptr()));
+    }
+
+    object module_ = get_module_name_if_available(rec.scope);
+    const auto *full_name = c_str(
+#if !defined(PYPY_VERSION)
+        module_ ? str(module_).cast<std::string>() + "." + rec.name :
+#endif
+                rec.name);
+
+    char *tp_doc = nullptr;
+    if (rec.doc && options::show_user_defined_docstrings()) {
+        /* Allocate memory for docstring (Python will free this later on) */
+        size_t size = std::strlen(rec.doc) + 1;
+#if PY_VERSION_HEX >= 0x030D0000
+        tp_doc = (char *) PyMem_MALLOC(size);
+#else
+        tp_doc = (char *) PyObject_MALLOC(size);
+#endif
+        std::memcpy((void *) tp_doc, rec.doc, size);
+    }
+
+    auto &internals = get_internals();
+    auto bases = tuple(rec.bases);
+    auto *base = (bases.empty()) ? internals.instance_base : bases[0].ptr();
+
+    /* Danger zone: from now (and until PyType_Ready), make sure to
+       issue no Python C API calls which could potentially invoke the
+       garbage collector (the GC will call type_traverse(), which will in
+       turn find the newly constructed type in an invalid state) */
+    auto *metaclass
+        = rec.metaclass.ptr() ? (PyTypeObject *) rec.metaclass.ptr() : internals.default_metaclass;
+
+    auto *heap_type = (PyHeapTypeObject *) metaclass->tp_alloc(metaclass, 0);
+    if (!heap_type) {
+        pybind11_fail(std::string(rec.name) + ": Unable to create type object!");
+    }
+
+    heap_type->ht_name = name.release().ptr();
+#ifdef PYBIND11_BUILTIN_QUALNAME
+    heap_type->ht_qualname = qualname.inc_ref().ptr();
+#endif
+
+    auto *type = &heap_type->ht_type;
+    type->tp_name = full_name;
+    type->tp_doc = tp_doc;
+    type->tp_base = type_incref((PyTypeObject *) base);
+    type->tp_basicsize = static_cast<ssize_t>(sizeof(instance));
+    if (!bases.empty()) {
+        type->tp_bases = bases.release().ptr();
+    }
+
+    /* Don't inherit base __init__ */
+    type->tp_init = pybind11_object_init;
+
+    /* Supported protocols */
+    type->tp_as_number = &heap_type->as_number;
+    type->tp_as_sequence = &heap_type->as_sequence;
+    type->tp_as_mapping = &heap_type->as_mapping;
+    type->tp_as_async = &heap_type->as_async;
+
+    /* Flags */
+    type->tp_flags |= Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE;
+    if (!rec.is_final) {
+        type->tp_flags |= Py_TPFLAGS_BASETYPE;
+    }
+
+    if (rec.dynamic_attr) {
+        enable_dynamic_attributes(heap_type);
+    }
+
+    if (rec.buffer_protocol) {
+        enable_buffer_protocol(heap_type);
+    }
+
+    if (rec.custom_type_setup_callback) {
+        rec.custom_type_setup_callback(heap_type);
+    }
+
+    if (PyType_Ready(type) < 0) {
+        pybind11_fail(std::string(rec.name) + ": PyType_Ready failed: " + error_string());
+    }
+
+    assert(!rec.dynamic_attr || PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC));
+
+    /* Register type with the parent scope */
+    if (rec.scope) {
+        setattr(rec.scope, rec.name, (PyObject *) type);
+    } else {
+        Py_INCREF(type); // Keep it alive forever (reference leak)
+    }
+
+    if (module_) { // Needed by pydoc
+        setattr((PyObject *) type, "__module__", module_);
+    }
+
+    PYBIND11_SET_OLDPY_QUALNAME(type, qualname);
+
+    return (PyObject *) type;
+}
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/detail/common.h b/local_pybind11/pybind11/include/pybind11/detail/common.h
new file mode 100644
index 000000000..314dba409
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/common.h
@@ -0,0 +1,1348 @@
+/*
+    pybind11/detail/common.h -- Basic macros
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include <pybind11/conduit/wrap_include_python_h.h>
+#if PY_VERSION_HEX < 0x03080000
+#    error "PYTHON < 3.8 IS UNSUPPORTED. pybind11 v2.13 was the last to support Python 3.7."
+#endif
+
+// Similar to Python's convention: https://docs.python.org/3/c-api/apiabiversion.html
+// See also: https://github.com/python/cpython/blob/HEAD/Include/patchlevel.h
+/* -- start version constants -- */
+#define PYBIND11_VERSION_MAJOR 3
+#define PYBIND11_VERSION_MINOR 0
+#define PYBIND11_VERSION_MICRO 1
+// ALPHA = 0xA, BETA = 0xB, GAMMA = 0xC (release candidate), FINAL = 0xF (stable release)
+// - The release level is set to "alpha" for development versions.
+//   Use 0xA0 (LEVEL=0xA, SERIAL=0) for development versions.
+// - For stable releases, set the serial to 0.
+#define PYBIND11_VERSION_RELEASE_LEVEL PY_RELEASE_LEVEL_FINAL
+#define PYBIND11_VERSION_RELEASE_SERIAL 0
+// String version of (micro, release level, release serial), e.g.: 0a0, 0b1, 0rc1, 0
+#define PYBIND11_VERSION_PATCH 1
+/* -- end version constants -- */
+
+#if !defined(Py_PACK_FULL_VERSION)
+// Stable API since Python 3.14.0a4
+#    define Py_PACK_FULL_VERSION(X, Y, Z, LEVEL, SERIAL)                                          \
+        ((((X) & 0xff) << 24) | (((Y) & 0xff) << 16) | (((Z) & 0xff) << 8)                        \
+         | (((LEVEL) & 0xf) << 4) | (((SERIAL) & 0xf) << 0))
+#endif
+// Version as a single 4-byte hex number, e.g. 0x030C04B5 == 3.12.4b5.
+#define PYBIND11_VERSION_HEX                                                                      \
+    Py_PACK_FULL_VERSION(PYBIND11_VERSION_MAJOR,                                                  \
+                         PYBIND11_VERSION_MINOR,                                                  \
+                         PYBIND11_VERSION_MICRO,                                                  \
+                         PYBIND11_VERSION_RELEASE_LEVEL,                                          \
+                         PYBIND11_VERSION_RELEASE_SERIAL)
+
+#include "pybind11_namespace_macros.h"
+
+#if !(defined(_MSC_VER) && __cplusplus == 199711L)
+#    if __cplusplus >= 201402L
+#        define PYBIND11_CPP14
+#        if __cplusplus >= 201703L
+#            define PYBIND11_CPP17
+#            if __cplusplus >= 202002L
+#                define PYBIND11_CPP20
+// Please update tests/pybind11_tests.cpp `cpp_std()` when adding a macro here.
+#            endif
+#        endif
+#    endif
+#elif defined(_MSC_VER) && __cplusplus == 199711L
+// MSVC sets _MSVC_LANG rather than __cplusplus (supposedly until the standard is fully
+// implemented). Unless you use the /Zc:__cplusplus flag on Visual Studio 2017 15.7 Preview 3
+// or newer.
+#    if _MSVC_LANG >= 201402L
+#        define PYBIND11_CPP14
+#        if _MSVC_LANG > 201402L
+#            define PYBIND11_CPP17
+#            if _MSVC_LANG >= 202002L
+#                define PYBIND11_CPP20
+#            endif
+#        endif
+#    endif
+#endif
+
+// These PYBIND11_HAS_... macros are consolidated in pybind11/detail/common.h
+// to simplify backward compatibility handling for users (e.g., via #ifdef checks):
+#define PYBIND11_HAS_TYPE_CASTER_STD_FUNCTION_SPECIALIZATIONS 1
+#define PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT 1
+#define PYBIND11_HAS_CPP_CONDUIT 1
+#define PYBIND11_HAS_NATIVE_ENUM 1
+
+#if defined(PYBIND11_CPP17) && defined(__has_include)
+#    if __has_include(<filesystem>)
+#        define PYBIND11_HAS_FILESYSTEM 1
+#    elif __has_include(<experimental/filesystem>)
+#        define PYBIND11_HAS_EXPERIMENTAL_FILESYSTEM 1
+#    endif
+#endif
+
+#if defined(__cpp_lib_launder) && !(defined(_MSC_VER) && (_MSC_VER < 1914))
+#    define PYBIND11_STD_LAUNDER std::launder
+#    define PYBIND11_HAS_STD_LAUNDER 1
+#else
+#    define PYBIND11_STD_LAUNDER
+#    define PYBIND11_HAS_STD_LAUNDER 0
+#endif
+
+#if defined(PYBIND11_CPP20)
+#    define PYBIND11_CONSTINIT constinit
+#    define PYBIND11_DTOR_CONSTEXPR constexpr
+#else
+#    define PYBIND11_CONSTINIT
+#    define PYBIND11_DTOR_CONSTEXPR
+#endif
+
+// Compiler version assertions
+#if defined(__INTEL_COMPILER)
+#    if __INTEL_COMPILER < 1800
+#        error pybind11 requires Intel C++ compiler v18 or newer
+#    elif __INTEL_COMPILER < 1900 && defined(PYBIND11_CPP14)
+#        error pybind11 supports only C++11 with Intel C++ compiler v18. Use v19 or newer for C++14.
+#    endif
+/* The following pragma cannot be pop'ed:
+   https://community.intel.com/t5/Intel-C-Compiler/Inline-and-no-inline-warning/td-p/1216764 */
+#    pragma warning disable 2196 // warning #2196: routine is both "inline" and "noinline"
+#elif defined(__clang__) && !defined(__apple_build_version__)
+#    if __clang_major__ < 3 || (__clang_major__ == 3 && __clang_minor__ < 3)
+#        error pybind11 requires clang 3.3 or newer
+#    endif
+#elif defined(__clang__)
+// Apple changes clang version macros to its Xcode version; the first Xcode release based on
+// (upstream) clang 3.3 was Xcode 5:
+#    if __clang_major__ < 5
+#        error pybind11 requires Xcode/clang 5.0 or newer
+#    endif
+#elif defined(__GNUG__)
+#    if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8)
+#        error pybind11 requires gcc 4.8 or newer
+#    endif
+#elif defined(_MSC_VER)
+#    if _MSC_VER < 1910
+#        error pybind11 2.10+ requires MSVC 2017 or newer
+#    endif
+#endif
+
+#if !defined(PYBIND11_EXPORT)
+#    if defined(WIN32) || defined(_WIN32)
+#        define PYBIND11_EXPORT __declspec(dllexport)
+#    else
+#        define PYBIND11_EXPORT __attribute__((visibility("default")))
+#    endif
+#endif
+
+// For CUDA, GCC7, GCC8:
+// PYBIND11_NOINLINE_FORCED is incompatible with `-Wattributes -Werror`.
+// When defining PYBIND11_NOINLINE_FORCED, it is best to also use `-Wno-attributes`.
+// However, the measured shared-library size saving when using noinline are only
+// 1.7% for CUDA, -0.2% for GCC7, and 0.0% for GCC8 (using -DCMAKE_BUILD_TYPE=MinSizeRel,
+// the default under pybind11/tests).
+#if !defined(PYBIND11_NOINLINE_FORCED)                                                            \
+    && (defined(__CUDACC__) || (defined(__GNUC__) && (__GNUC__ == 7 || __GNUC__ == 8)))
+#    define PYBIND11_NOINLINE_DISABLED
+#endif
+
+// The PYBIND11_NOINLINE macro is for function DEFINITIONS.
+// In contrast, FORWARD DECLARATIONS should never use this macro:
+// https://stackoverflow.com/questions/9317473/forward-declaration-of-inline-functions
+#if defined(PYBIND11_NOINLINE_DISABLED) // Option for maximum portability and experimentation.
+#    define PYBIND11_NOINLINE inline
+#elif defined(_MSC_VER)
+#    define PYBIND11_NOINLINE __declspec(noinline) inline
+#else
+#    define PYBIND11_NOINLINE __attribute__((noinline)) inline
+#endif
+
+#if defined(__MINGW32__)
+// For unknown reasons all PYBIND11_DEPRECATED member trigger a warning when declared
+// whether it is used or not
+#    define PYBIND11_DEPRECATED(reason)
+#elif defined(PYBIND11_CPP14)
+#    define PYBIND11_DEPRECATED(reason) [[deprecated(reason)]]
+#else
+#    define PYBIND11_DEPRECATED(reason) __attribute__((deprecated(reason)))
+#endif
+
+#if defined(PYBIND11_CPP17)
+#    define PYBIND11_MAYBE_UNUSED [[maybe_unused]]
+#elif defined(_MSC_VER) && !defined(__clang__)
+#    define PYBIND11_MAYBE_UNUSED
+#else
+#    define PYBIND11_MAYBE_UNUSED __attribute__((__unused__))
+#endif
+
+// https://en.cppreference.com/w/c/chrono/localtime
+#if defined(__STDC_LIB_EXT1__) && !defined(__STDC_WANT_LIB_EXT1__)
+#    define __STDC_WANT_LIB_EXT1__
+#endif
+
+#ifdef __has_include
+// std::optional (but including it in c++14 mode isn't allowed)
+#    if defined(PYBIND11_CPP17) && __has_include(<optional>)
+#        define PYBIND11_HAS_OPTIONAL 1
+#    endif
+// std::experimental::optional (but not allowed in c++11 mode)
+#    if defined(PYBIND11_CPP14) && (__has_include(<experimental/optional>) && \
+                                 !__has_include(<optional>))
+#        define PYBIND11_HAS_EXP_OPTIONAL 1
+#    endif
+// std::variant
+#    if defined(PYBIND11_CPP17) && __has_include(<variant>)
+#        define PYBIND11_HAS_VARIANT 1
+#    endif
+#elif defined(_MSC_VER) && defined(PYBIND11_CPP17)
+#    define PYBIND11_HAS_OPTIONAL 1
+#    define PYBIND11_HAS_VARIANT 1
+#endif
+
+#if defined(PYBIND11_CPP17)                                                                       \
+    && ((defined(__has_include) && __has_include(<string_view>)) || defined(_MSC_VER))
+#    define PYBIND11_HAS_STRING_VIEW 1
+#endif
+
+#if (defined(PYPY_VERSION) || defined(GRAALVM_PYTHON)) && !defined(PYBIND11_SIMPLE_GIL_MANAGEMENT)
+#    define PYBIND11_SIMPLE_GIL_MANAGEMENT
+#endif
+
+#include <cstddef>
+#include <cstring>
+#include <exception>
+#include <forward_list>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <typeindex>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+#if defined(__has_include)
+#    if __has_include(<version>)
+#        include <version>
+#    endif
+#endif
+
+// For libc++, the exceptions should be exported,
+// otherwise, the exception translation would be incorrect.
+// IMPORTANT: This code block must stay BELOW the #include <exception> above (see PR #5390).
+#if !defined(PYBIND11_EXPORT_EXCEPTION)
+#    if defined(_LIBCPP_EXCEPTION)
+#        define PYBIND11_EXPORT_EXCEPTION PYBIND11_EXPORT
+#    else
+#        define PYBIND11_EXPORT_EXCEPTION
+#    endif
+#endif
+
+// Must be after including <version> or one of the other headers specified by the standard
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+#    define PYBIND11_HAS_U8STRING 1
+#endif
+
+// See description of PR #4246:
+#if !defined(PYBIND11_NO_ASSERT_GIL_HELD_INCREF_DECREF) && !defined(NDEBUG)                       \
+    && !defined(PYPY_VERSION) && !defined(PYBIND11_ASSERT_GIL_HELD_INCREF_DECREF)
+#    define PYBIND11_ASSERT_GIL_HELD_INCREF_DECREF
+#endif
+
+// Slightly faster code paths are available when PYBIND11_HAS_SUBINTERPRETER_SUPPORT is *not*
+// defined, so avoid defining it for implementations that do not support subinterpreters. However,
+// defining it unnecessarily is not expected to break anything.
+// This can be overridden by the user with -DPYBIND11_HAS_SUBINTERPRETER_SUPPORT=1 or 0
+#ifndef PYBIND11_HAS_SUBINTERPRETER_SUPPORT
+#    if PY_VERSION_HEX >= 0x030C0000 && !defined(PYPY_VERSION) && !defined(GRAALVM_PYTHON)
+#        define PYBIND11_HAS_SUBINTERPRETER_SUPPORT 1
+#    endif
+#else
+#    if PYBIND11_HAS_SUBINTERPRETER_SUPPORT == 0
+#        undef PYBIND11_HAS_SUBINTERPRETER_SUPPORT
+#    endif
+#endif
+
+// 3.13 Compatibility
+#if 0x030D0000 <= PY_VERSION_HEX
+#    define PYBIND11_TYPE_IS_TYPE_HINT "typing.TypeIs"
+#    define PYBIND11_CAPSULE_TYPE_TYPE_HINT "types.CapsuleType"
+#else
+#    define PYBIND11_TYPE_IS_TYPE_HINT "typing_extensions.TypeIs"
+#    define PYBIND11_CAPSULE_TYPE_TYPE_HINT "typing_extensions.CapsuleType"
+#endif
+
+// 3.12 Compatibility
+#if 0x030C0000 <= PY_VERSION_HEX
+#    define PYBIND11_BUFFER_TYPE_HINT "collections.abc.Buffer"
+#else
+#    define PYBIND11_BUFFER_TYPE_HINT "typing_extensions.Buffer"
+#endif
+
+// 3.11 Compatibility
+#if 0x030B0000 <= PY_VERSION_HEX
+#    define PYBIND11_NEVER_TYPE_HINT "typing.Never"
+#else
+#    define PYBIND11_NEVER_TYPE_HINT "typing_extensions.Never"
+#endif
+
+// 3.10 Compatibility
+#if 0x030A0000 <= PY_VERSION_HEX
+#    define PYBIND11_TYPE_GUARD_TYPE_HINT "typing.TypeGuard"
+#else
+#    define PYBIND11_TYPE_GUARD_TYPE_HINT "typing_extensions.TypeGuard"
+#endif
+
+// #define PYBIND11_STR_LEGACY_PERMISSIVE
+// If DEFINED, pybind11::str can hold PyUnicodeObject or PyBytesObject
+//             (probably surprising and never documented, but this was the
+//             legacy behavior until and including v2.6.x). As a side-effect,
+//             pybind11::isinstance<str>() is true for both pybind11::str and
+//             pybind11::bytes.
+// If UNDEFINED, pybind11::str can only hold PyUnicodeObject, and
+//               pybind11::isinstance<str>() is true only for pybind11::str.
+//               However, for Python 2 only (!), the pybind11::str caster
+//               implicitly decoded bytes to PyUnicodeObject. This was to ease
+//               the transition from the legacy behavior to the non-permissive
+//               behavior.
+
+/// Compatibility macros for Python 2 / Python 3 versions TODO: remove
+#define PYBIND11_INSTANCE_METHOD_NEW(ptr, class_) PyInstanceMethod_New(ptr)
+#define PYBIND11_INSTANCE_METHOD_CHECK PyInstanceMethod_Check
+#define PYBIND11_INSTANCE_METHOD_GET_FUNCTION PyInstanceMethod_GET_FUNCTION
+#define PYBIND11_BYTES_CHECK PyBytes_Check
+#define PYBIND11_BYTES_FROM_STRING PyBytes_FromString
+#define PYBIND11_BYTES_FROM_STRING_AND_SIZE PyBytes_FromStringAndSize
+#define PYBIND11_BYTES_AS_STRING_AND_SIZE PyBytes_AsStringAndSize
+#define PYBIND11_BYTES_AS_STRING PyBytes_AsString
+#define PYBIND11_BYTES_SIZE PyBytes_Size
+#define PYBIND11_LONG_CHECK(o) PyLong_Check(o)
+#define PYBIND11_LONG_AS_LONGLONG(o) PyLong_AsLongLong(o)
+#define PYBIND11_LONG_FROM_SIGNED(o) PyLong_FromSsize_t((ssize_t) (o))
+#define PYBIND11_LONG_FROM_UNSIGNED(o) PyLong_FromSize_t((size_t) (o))
+#define PYBIND11_BYTES_NAME "bytes"
+#define PYBIND11_STRING_NAME "str"
+#define PYBIND11_SLICE_OBJECT PyObject
+#define PYBIND11_FROM_STRING PyUnicode_FromString
+#define PYBIND11_STR_TYPE ::pybind11::str
+#define PYBIND11_BOOL_ATTR "__bool__"
+#define PYBIND11_NB_BOOL(ptr) ((ptr)->nb_bool)
+#define PYBIND11_BUILTINS_MODULE "builtins"
+// Providing a separate declaration to make Clang's -Wmissing-prototypes happy.
+// See comment for PYBIND11_MODULE below for why this is marked "maybe unused".
+#define PYBIND11_PLUGIN_DECL(name)                                                                \
+    extern "C" PYBIND11_MAYBE_UNUSED PYBIND11_EXPORT PyObject *PyInit_##name();
+#define PYBIND11_PLUGIN_IMPL(name)                                                                \
+    PYBIND11_PLUGIN_DECL(name)                                                                    \
+    extern "C" PYBIND11_EXPORT PyObject *PyInit_##name()
+
+#define PYBIND11_TRY_NEXT_OVERLOAD ((PyObject *) 1) // special failure return code
+#define PYBIND11_STRINGIFY(x) #x
+#define PYBIND11_TOSTRING(x) PYBIND11_STRINGIFY(x)
+#define PYBIND11_CONCAT(first, second) first##second
+#define PYBIND11_ENSURE_INTERNALS_READY                                                           \
+    {                                                                                             \
+        pybind11::detail::get_internals_pp_manager().unref();                                     \
+        pybind11::detail::get_internals();                                                        \
+    }
+
+#if !defined(GRAALVM_PYTHON)
+#    define PYBIND11_PYCFUNCTION_GET_DOC(func) ((func)->m_ml->ml_doc)
+#    define PYBIND11_PYCFUNCTION_SET_DOC(func, doc)                                               \
+        do {                                                                                      \
+            (func)->m_ml->ml_doc = (doc);                                                         \
+        } while (0)
+#else
+#    define PYBIND11_PYCFUNCTION_GET_DOC(func) (GraalPyCFunction_GetDoc((PyObject *) (func)))
+#    define PYBIND11_PYCFUNCTION_SET_DOC(func, doc)                                               \
+        do {                                                                                      \
+            GraalPyCFunction_SetDoc((PyObject *) (func), (doc));                                  \
+        } while (0)
+#endif
+
+#define PYBIND11_CHECK_PYTHON_VERSION                                                             \
+    {                                                                                             \
+        const char *compiled_ver                                                                  \
+            = PYBIND11_TOSTRING(PY_MAJOR_VERSION) "." PYBIND11_TOSTRING(PY_MINOR_VERSION);        \
+        const char *runtime_ver = Py_GetVersion();                                                \
+        size_t len = std::strlen(compiled_ver);                                                   \
+        if (std::strncmp(runtime_ver, compiled_ver, len) != 0                                     \
+            || (runtime_ver[len] >= '0' && runtime_ver[len] <= '9')) {                            \
+            PyErr_Format(PyExc_ImportError,                                                       \
+                         "Python version mismatch: module was compiled for Python %s, "           \
+                         "but the interpreter version is incompatible: %s.",                      \
+                         compiled_ver,                                                            \
+                         runtime_ver);                                                            \
+            return nullptr;                                                                       \
+        }                                                                                         \
+    }
+
+#define PYBIND11_CATCH_INIT_EXCEPTIONS                                                            \
+    catch (pybind11::error_already_set & e) {                                                     \
+        pybind11::raise_from(e, PyExc_ImportError, "initialization failed");                      \
+    }                                                                                             \
+    catch (const std::exception &e) {                                                             \
+        ::pybind11::set_error(PyExc_ImportError, e.what());                                       \
+    }
+
+/** \rst
+    ***Deprecated in favor of PYBIND11_MODULE***
+
+    This macro creates the entry point that will be invoked when the Python interpreter
+    imports a plugin library. Please create a `module_` in the function body and return
+    the pointer to its underlying Python object at the end.
+
+    .. code-block:: cpp
+
+        PYBIND11_PLUGIN(example) {
+            pybind11::module_ m("example", "pybind11 example plugin");
+            /// Set up bindings here
+            return m.ptr();
+        }
+\endrst */
+#define PYBIND11_PLUGIN(name)                                                                     \
+    PYBIND11_DEPRECATED("PYBIND11_PLUGIN is deprecated, use PYBIND11_MODULE")                     \
+    static PyObject *pybind11_init();                                                             \
+    PYBIND11_PLUGIN_IMPL(name) {                                                                  \
+        PYBIND11_CHECK_PYTHON_VERSION                                                             \
+        PYBIND11_ENSURE_INTERNALS_READY                                                           \
+        try {                                                                                     \
+            return pybind11_init();                                                               \
+        }                                                                                         \
+        PYBIND11_CATCH_INIT_EXCEPTIONS                                                            \
+        return nullptr;                                                                           \
+    }                                                                                             \
+    PyObject *pybind11_init()
+
+// this push is for the next several macros
+PYBIND11_WARNING_PUSH
+PYBIND11_WARNING_DISABLE_CLANG("-Wgnu-zero-variadic-macro-arguments")
+
+/**
+Create a PyInit_ function for this module.
+
+Note that this is run once for each (sub-)interpreter the module is imported into, including
+possibly concurrently.  The PyModuleDef is allowed to be static, but the PyObject* resulting from
+PyModuleDef_Init should be treated like any other PyObject (so not shared across interpreters).
+ */
+#define PYBIND11_MODULE_PYINIT(name, pre_init, ...)                                               \
+    static int PYBIND11_CONCAT(pybind11_exec_, name)(PyObject *);                                 \
+    PYBIND11_PLUGIN_IMPL(name) {                                                                  \
+        PYBIND11_CHECK_PYTHON_VERSION                                                             \
+        pre_init;                                                                                 \
+        PYBIND11_ENSURE_INTERNALS_READY                                                           \
+        static ::pybind11::detail::slots_array mod_def_slots = ::pybind11::detail::init_slots(    \
+            &PYBIND11_CONCAT(pybind11_exec_, name), ##__VA_ARGS__);                               \
+        static PyModuleDef def{/* m_base */ PyModuleDef_HEAD_INIT,                                \
+                               /* m_name */ PYBIND11_TOSTRING(name),                              \
+                               /* m_doc */ nullptr,                                               \
+                               /* m_size */ 0,                                                    \
+                               /* m_methods */ nullptr,                                           \
+                               /* m_slots */ mod_def_slots.data(),                                \
+                               /* m_traverse */ nullptr,                                          \
+                               /* m_clear */ nullptr,                                             \
+                               /* m_free */ nullptr};                                             \
+        return PyModuleDef_Init(&def);                                                            \
+    }
+
+#define PYBIND11_MODULE_EXEC(name, variable)                                                      \
+    static void PYBIND11_CONCAT(pybind11_init_, name)(::pybind11::module_ &);                     \
+    int PYBIND11_CONCAT(pybind11_exec_, name)(PyObject * pm) {                                    \
+        try {                                                                                     \
+            auto m = pybind11::reinterpret_borrow<::pybind11::module_>(pm);                       \
+            if (!pybind11::detail::get_cached_module(m.attr("__spec__").attr("name"))) {          \
+                PYBIND11_CONCAT(pybind11_init_, name)(m);                                         \
+                pybind11::detail::cache_completed_module(m);                                      \
+            }                                                                                     \
+            return 0;                                                                             \
+        }                                                                                         \
+        PYBIND11_CATCH_INIT_EXCEPTIONS                                                            \
+        return -1;                                                                                \
+    }                                                                                             \
+    void PYBIND11_CONCAT(pybind11_init_, name)(::pybind11::module_                                \
+                                               & variable) // NOLINT(bugprone-macro-parentheses)
+
+/** \rst
+    This macro creates the entry point that will be invoked when the Python interpreter
+    imports an extension module. The module name is given as the first argument and it
+    should not be in quotes. The second macro argument defines a variable of type
+    ``py::module_`` which can be used to initialize the module.
+
+    The entry point is marked as "maybe unused" to aid dead-code detection analysis:
+    since the entry point is typically only looked up at runtime and not referenced
+    during translation, it would otherwise appear as unused ("dead") code.
+
+    .. code-block:: cpp
+
+        PYBIND11_MODULE(example, m) {
+            m.doc() = "pybind11 example module";
+
+            // Add bindings here
+            m.def("foo", []() {
+                return "Hello, World!";
+            });
+        }
+
+    The third and subsequent macro arguments are optional (available since 2.13.0), and
+    can be used to mark the extension module as supporting various Python features.
+
+    - ``mod_gil_not_used()``
+    - ``multiple_interpreters::per_interpreter_gil()``
+    - ``multiple_interpreters::shared_gil()``
+    - ``multiple_interpreters::not_supported()``
+
+    .. code-block:: cpp
+
+        PYBIND11_MODULE(example, m, py::mod_gil_not_used()) {
+            m.doc() = "pybind11 example module safe to run without the GIL";
+            m.def("foo", []() {
+                return "Hello, Free-threaded World!";
+            });
+        }
+
+\endrst */
+#define PYBIND11_MODULE(name, variable, ...)                                                      \
+    PYBIND11_MODULE_PYINIT(                                                                       \
+        name, (pybind11::detail::get_num_interpreters_seen() += 1), ##__VA_ARGS__)                \
+    PYBIND11_MODULE_EXEC(name, variable)
+
+// pop gnu-zero-variadic-macro-arguments
+PYBIND11_WARNING_POP
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+using ssize_t = Py_ssize_t;
+using size_t = std::size_t;
+
+template <typename IntType>
+inline ssize_t ssize_t_cast(const IntType &val) {
+    static_assert(sizeof(IntType) <= sizeof(ssize_t), "Implicit narrowing is not permitted.");
+    return static_cast<ssize_t>(val);
+}
+
+/// Approach used to cast a previously unknown C++ instance into a Python object
+enum class return_value_policy : uint8_t {
+    /** This is the default return value policy, which falls back to the policy
+        return_value_policy::take_ownership when the return value is a pointer.
+        Otherwise, it uses return_value::move or return_value::copy for rvalue
+        and lvalue references, respectively. See below for a description of what
+        all of these different policies do. */
+    automatic = 0,
+
+    /** As above, but use policy return_value_policy::reference when the return
+        value is a pointer. This is the default conversion policy for function
+        arguments when calling Python functions manually from C++ code (i.e. via
+        handle::operator()). You probably won't need to use this. */
+    automatic_reference,
+
+    /** Reference an existing object (i.e. do not create a new copy) and take
+        ownership. Python will call the destructor and delete operator when the
+        object's reference count reaches zero. Undefined behavior ensues when
+        the C++ side does the same.. */
+    take_ownership,
+
+    /** Create a new copy of the returned object, which will be owned by
+        Python. This policy is comparably safe because the lifetimes of the two
+        instances are decoupled. */
+    copy,
+
+    /** Use std::move to move the return value contents into a new instance
+        that will be owned by Python. This policy is comparably safe because the
+        lifetimes of the two instances (move source and destination) are
+        decoupled. */
+    move,
+
+    /** Reference an existing object, but do not take ownership. The C++ side
+        is responsible for managing the object's lifetime and deallocating it
+        when it is no longer used. Warning: undefined behavior will ensue when
+        the C++ side deletes an object that is still referenced and used by
+        Python. */
+    reference,
+
+    /** This policy only applies to methods and properties. It references the
+        object without taking ownership similar to the above
+        return_value_policy::reference policy. In contrast to that policy, the
+        function or property's implicit this argument (called the parent) is
+        considered to be the owner of the return value (the child).
+        pybind11 then couples the lifetime of the parent to the child via a
+        reference relationship that ensures that the parent cannot be garbage
+        collected while Python is still using the child. More advanced
+        variations of this scheme are also possible using combinations of
+        return_value_policy::reference and the keep_alive call policy */
+    reference_internal
+};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+inline static constexpr int log2(size_t n, int k = 0) {
+    return (n <= 1) ? k : log2(n >> 1, k + 1);
+}
+
+// Returns the size as a multiple of sizeof(void *), rounded up.
+inline static constexpr size_t size_in_ptrs(size_t s) {
+    return 1 + ((s - 1) >> log2(sizeof(void *)));
+}
+
+/**
+ * The space to allocate for simple layout instance holders (see below) in multiple of the size of
+ * a pointer (e.g.  2 means 16 bytes on 64-bit architectures).  The default is the minimum required
+ * to holder either a std::unique_ptr or std::shared_ptr (which is almost always
+ * sizeof(std::shared_ptr<T>)).
+ */
+constexpr size_t instance_simple_holder_in_ptrs() {
+    static_assert(sizeof(std::shared_ptr<int>) >= sizeof(std::unique_ptr<int>),
+                  "pybind assumes std::shared_ptrs are at least as big as std::unique_ptrs");
+    return size_in_ptrs(sizeof(std::shared_ptr<int>));
+}
+
+// Forward declarations
+struct type_info;
+struct value_and_holder;
+
+struct nonsimple_values_and_holders {
+    void **values_and_holders;
+    uint8_t *status;
+};
+
+/// The 'instance' type which needs to be standard layout (need to be able to use 'offsetof')
+struct instance {
+    PyObject_HEAD
+    /// Storage for pointers and holder; see simple_layout, below, for a description
+    union {
+        void *simple_value_holder[1 + instance_simple_holder_in_ptrs()];
+        nonsimple_values_and_holders nonsimple;
+    };
+    /// Weak references
+    PyObject *weakrefs;
+    /// If true, the pointer is owned which means we're free to manage it with a holder.
+    bool owned : 1;
+    /**
+     * An instance has two possible value/holder layouts.
+     *
+     * Simple layout (when this flag is true), means the `simple_value_holder` is set with a
+     * pointer and the holder object governing that pointer, i.e. [val1*][holder].  This layout is
+     * applied whenever there is no python-side multiple inheritance of bound C++ types *and* the
+     * type's holder will fit in the default space (which is large enough to hold either a
+     * std::unique_ptr or std::shared_ptr).
+     *
+     * Non-simple layout applies when using custom holders that require more space than
+     * `shared_ptr` (which is typically the size of two pointers), or when multiple inheritance is
+     * used on the python side.  Non-simple layout allocates the required amount of memory to have
+     * multiple bound C++ classes as parents.  Under this layout, `nonsimple.values_and_holders` is
+     * set to a pointer to allocated space of the required space to hold a sequence of value
+     * pointers and holders followed `status`, a set of bit flags (1 byte each), i.e.
+     * [val1*][holder1][val2*][holder2]...[bb...]  where each [block] is rounded up to a multiple
+     * of `sizeof(void *)`.  `nonsimple.status` is, for convenience, a pointer to the beginning of
+     * the [bb...] block (but not independently allocated).
+     *
+     * Status bits indicate whether the associated holder is constructed (&
+     * status_holder_constructed) and whether the value pointer is registered (&
+     * status_instance_registered) in `registered_instances`.
+     */
+    bool simple_layout : 1;
+    /// For simple layout, tracks whether the holder has been constructed
+    bool simple_holder_constructed : 1;
+    /// For simple layout, tracks whether the instance is registered in `registered_instances`
+    bool simple_instance_registered : 1;
+    /// If true, get_internals().patients has an entry for this object
+    bool has_patients : 1;
+    /// If true, this Python object needs to be kept alive for the lifetime of the C++ value.
+    bool is_alias : 1;
+
+    /// Initializes all of the above type/values/holders data (but not the instance values
+    /// themselves)
+    void allocate_layout();
+
+    /// Destroys/deallocates all of the above
+    void deallocate_layout();
+
+    /// Returns the value_and_holder wrapper for the given type (or the first, if `find_type`
+    /// omitted).  Returns a default-constructed (with `.inst = nullptr`) object on failure if
+    /// `throw_if_missing` is false.
+    value_and_holder get_value_and_holder(const type_info *find_type = nullptr,
+                                          bool throw_if_missing = true);
+
+    /// Bit values for the non-simple status flags
+    static constexpr uint8_t status_holder_constructed = 1;
+    static constexpr uint8_t status_instance_registered = 2;
+};
+
+static_assert(std::is_standard_layout<instance>::value,
+              "Internal error: `pybind11::detail::instance` is not standard layout!");
+
+// Some older compilers (e.g. gcc 9.4.0) require
+//     static_assert(always_false<T>::value, "...");
+// instead of
+//     static_assert(false, "...");
+// to trigger the static_assert() in a template only if it is actually instantiated.
+template <typename>
+struct always_false : std::false_type {};
+
+/// from __cpp_future__ import (convenient aliases from C++14/17)
+#if defined(PYBIND11_CPP14)
+using std::conditional_t;
+using std::enable_if_t;
+using std::remove_cv_t;
+using std::remove_reference_t;
+#else
+template <bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+template <bool B, typename T, typename F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+template <typename T>
+using remove_cv_t = typename std::remove_cv<T>::type;
+template <typename T>
+using remove_reference_t = typename std::remove_reference<T>::type;
+#endif
+
+#if defined(PYBIND11_CPP20) && defined(__cpp_lib_remove_cvref)
+using std::remove_cvref;
+using std::remove_cvref_t;
+#else
+template <class T>
+struct remove_cvref {
+    using type = remove_cv_t<remove_reference_t<T>>;
+};
+template <class T>
+using remove_cvref_t = typename remove_cvref<T>::type;
+#endif
+
+/// Example usage: is_same_ignoring_cvref<T, PyObject *>::value
+template <typename T, typename U>
+using is_same_ignoring_cvref = std::is_same<detail::remove_cvref_t<T>, U>;
+
+/// Index sequences
+#if defined(PYBIND11_CPP14)
+using std::index_sequence;
+using std::make_index_sequence;
+#else
+template <size_t...>
+struct index_sequence {};
+// Comments about the algorithm below.
+//
+// Credit: This is based on an algorithm by taocpp here:
+//    https://github.com/taocpp/sequences/blob/main/include/tao/seq/make_integer_sequence.hpp
+// but significantly simplified.
+//
+// We build up a sequence S by repeatedly doubling its length and sometimes adding 1 to the end.
+// E.g. if the current S is 0...3, then we either go to 0...7 or 0...8 on the next pass.
+// The goal is to end with S = 0...N-1.
+// The key insight is that the times we need to add an additional digit to S correspond
+// exactly to the 1's in the binary representation of the number N.
+//
+// Invariants:
+// - digit is a power of 2
+// - N_digit_is_1 is whether N's binary representation has a 1 in that digit's position.
+// - end <= N
+// - S is 0...end-1.
+// - if digit > 0, end * digit * 2 <= N < (end+1) * digit * 2
+//
+// The process starts with digit > N, end = 0, and S is empty.
+// The process concludes with digit=0, in which case, end == N and S is 0...N-1.
+
+template <size_t digit, bool N_digit_is_1, size_t N, size_t end, size_t... S> // N_digit_is_1=false
+struct make_index_sequence_impl
+    : make_index_sequence_impl<digit / 2, (N & (digit / 2)) != 0, N, 2 * end, S..., (S + end)...> {
+};
+template <size_t digit, size_t N, size_t end, size_t... S>
+struct make_index_sequence_impl<digit, true, N, end, S...>
+    : make_index_sequence_impl<digit / 2,
+                               (N & (digit / 2)) != 0,
+                               N,
+                               2 * end + 1,
+                               S...,
+                               (S + end)...,
+                               2 * end> {};
+template <size_t N, size_t end, size_t... S>
+struct make_index_sequence_impl<0, false, N, end, S...> {
+    using type = index_sequence<S...>;
+};
+constexpr size_t next_power_of_2(size_t N) { return N == 0 ? 1 : next_power_of_2(N >> 1) << 1; }
+template <size_t N>
+using make_index_sequence =
+    typename make_index_sequence_impl<next_power_of_2(N), false, N, 0>::type;
+#endif
+
+/// Make an index sequence of the indices of true arguments
+template <typename ISeq, size_t, bool...>
+struct select_indices_impl {
+    using type = ISeq;
+};
+template <size_t... IPrev, size_t I, bool B, bool... Bs>
+struct select_indices_impl<index_sequence<IPrev...>, I, B, Bs...>
+    : select_indices_impl<conditional_t<B, index_sequence<IPrev..., I>, index_sequence<IPrev...>>,
+                          I + 1,
+                          Bs...> {};
+template <bool... Bs>
+using select_indices = typename select_indices_impl<index_sequence<>, 0, Bs...>::type;
+
+/// Backports of std::bool_constant and std::negation to accommodate older compilers
+template <bool B>
+using bool_constant = std::integral_constant<bool, B>;
+template <typename T>
+struct negation : bool_constant<!T::value> {};
+
+// PGI/Intel cannot detect operator delete with the "compatible" void_t impl, so
+// using the new one (C++14 defect, so generally works on newer compilers, even
+// if not in C++17 mode)
+#if defined(__PGIC__) || defined(__INTEL_COMPILER)
+template <typename...>
+using void_t = void;
+#else
+template <typename...>
+struct void_t_impl {
+    using type = void;
+};
+template <typename... Ts>
+using void_t = typename void_t_impl<Ts...>::type;
+#endif
+
+/// Compile-time all/any/none of that check the boolean value of all template types
+#if defined(__cpp_fold_expressions) && !(defined(_MSC_VER) && (_MSC_VER < 1916))
+template <class... Ts>
+using all_of = bool_constant<(Ts::value && ...)>;
+template <class... Ts>
+using any_of = bool_constant<(Ts::value || ...)>;
+#elif !defined(_MSC_VER)
+template <bool...>
+struct bools {};
+template <class... Ts>
+using all_of = std::is_same<bools<Ts::value..., true>, bools<true, Ts::value...>>;
+template <class... Ts>
+using any_of = negation<all_of<negation<Ts>...>>;
+#else
+// MSVC has trouble with the above, but supports std::conjunction, which we can use instead (albeit
+// at a slight loss of compilation efficiency).
+template <class... Ts>
+using all_of = std::conjunction<Ts...>;
+template <class... Ts>
+using any_of = std::disjunction<Ts...>;
+#endif
+template <class... Ts>
+using none_of = negation<any_of<Ts...>>;
+
+template <class T, template <class> class... Predicates>
+using satisfies_all_of = all_of<Predicates<T>...>;
+template <class T, template <class> class... Predicates>
+using satisfies_any_of = any_of<Predicates<T>...>;
+template <class T, template <class> class... Predicates>
+using satisfies_none_of = none_of<Predicates<T>...>;
+
+/// Strip the class from a method type
+template <typename T>
+struct remove_class {};
+template <typename C, typename R, typename... A>
+struct remove_class<R (C::*)(A...)> {
+    using type = R(A...);
+};
+template <typename C, typename R, typename... A>
+struct remove_class<R (C::*)(A...) const> {
+    using type = R(A...);
+};
+#ifdef __cpp_noexcept_function_type
+template <typename C, typename R, typename... A>
+struct remove_class<R (C::*)(A...) noexcept> {
+    using type = R(A...);
+};
+template <typename C, typename R, typename... A>
+struct remove_class<R (C::*)(A...) const noexcept> {
+    using type = R(A...);
+};
+#endif
+/// Helper template to strip away type modifiers
+template <typename T>
+struct intrinsic_type {
+    using type = T;
+};
+template <typename T>
+struct intrinsic_type<const T> {
+    using type = typename intrinsic_type<T>::type;
+};
+template <typename T>
+struct intrinsic_type<T *> {
+    using type = typename intrinsic_type<T>::type;
+};
+template <typename T>
+struct intrinsic_type<T &> {
+    using type = typename intrinsic_type<T>::type;
+};
+template <typename T>
+struct intrinsic_type<T &&> {
+    using type = typename intrinsic_type<T>::type;
+};
+template <typename T, size_t N>
+struct intrinsic_type<const T[N]> {
+    using type = typename intrinsic_type<T>::type;
+};
+template <typename T, size_t N>
+struct intrinsic_type<T[N]> {
+    using type = typename intrinsic_type<T>::type;
+};
+template <typename T>
+using intrinsic_t = typename intrinsic_type<T>::type;
+
+/// Helper type to replace 'void' in some expressions
+struct void_type {};
+
+/// Helper template which holds a list of types
+template <typename...>
+struct type_list {};
+
+/// Compile-time integer sum
+#ifdef __cpp_fold_expressions
+template <typename... Ts>
+constexpr size_t constexpr_sum(Ts... ns) {
+    return (0 + ... + size_t{ns});
+}
+#else
+constexpr size_t constexpr_sum() { return 0; }
+template <typename T, typename... Ts>
+constexpr size_t constexpr_sum(T n, Ts... ns) {
+    return size_t{n} + constexpr_sum(ns...);
+}
+#endif
+
+PYBIND11_NAMESPACE_BEGIN(constexpr_impl)
+/// Implementation details for constexpr functions
+constexpr int first(int i) { return i; }
+template <typename T, typename... Ts>
+constexpr int first(int i, T v, Ts... vs) {
+    return v ? i : first(i + 1, vs...);
+}
+
+constexpr int last(int /*i*/, int result) { return result; }
+template <typename T, typename... Ts>
+constexpr int last(int i, int result, T v, Ts... vs) {
+    return last(i + 1, v ? i : result, vs...);
+}
+PYBIND11_NAMESPACE_END(constexpr_impl)
+
+/// Return the index of the first type in Ts which satisfies Predicate<T>.
+/// Returns sizeof...(Ts) if none match.
+template <template <typename> class Predicate, typename... Ts>
+constexpr int constexpr_first() {
+    return constexpr_impl::first(0, Predicate<Ts>::value...);
+}
+
+/// Return the index of the last type in Ts which satisfies Predicate<T>, or -1 if none match.
+template <template <typename> class Predicate, typename... Ts>
+constexpr int constexpr_last() {
+    return constexpr_impl::last(0, -1, Predicate<Ts>::value...);
+}
+
+/// Return the Nth element from the parameter pack
+template <size_t N, typename T, typename... Ts>
+struct pack_element {
+    using type = typename pack_element<N - 1, Ts...>::type;
+};
+template <typename T, typename... Ts>
+struct pack_element<0, T, Ts...> {
+    using type = T;
+};
+
+/// Return the one and only type which matches the predicate, or Default if none match.
+/// If more than one type matches the predicate, fail at compile-time.
+template <template <typename> class Predicate, typename Default, typename... Ts>
+struct exactly_one {
+    static constexpr auto found = constexpr_sum(Predicate<Ts>::value...);
+    static_assert(found <= 1, "Found more than one type matching the predicate");
+
+    static constexpr auto index = found ? constexpr_first<Predicate, Ts...>() : 0;
+    using type = conditional_t<found, typename pack_element<index, Ts...>::type, Default>;
+};
+template <template <typename> class P, typename Default>
+struct exactly_one<P, Default> {
+    using type = Default;
+};
+
+template <template <typename> class Predicate, typename Default, typename... Ts>
+using exactly_one_t = typename exactly_one<Predicate, Default, Ts...>::type;
+
+/// Defer the evaluation of type T until types Us are instantiated
+template <typename T, typename... /*Us*/>
+struct deferred_type {
+    using type = T;
+};
+template <typename T, typename... Us>
+using deferred_t = typename deferred_type<T, Us...>::type;
+
+/// Like is_base_of, but requires a strict base (i.e. `is_strict_base_of<T, T>::value == false`,
+/// unlike `std::is_base_of`)
+template <typename Base, typename Derived>
+using is_strict_base_of
+    = bool_constant<std::is_base_of<Base, Derived>::value && !std::is_same<Base, Derived>::value>;
+
+/// Like is_base_of, but also requires that the base type is accessible (i.e. that a Derived
+/// pointer can be converted to a Base pointer) For unions, `is_base_of<T, T>::value` is False, so
+/// we need to check `is_same` as well.
+template <typename Base, typename Derived>
+using is_accessible_base_of
+    = bool_constant<(std::is_same<Base, Derived>::value || std::is_base_of<Base, Derived>::value)
+                    && std::is_convertible<Derived *, Base *>::value>;
+
+template <template <typename...> class Base>
+struct is_template_base_of_impl {
+    template <typename... Us>
+    static std::true_type check(Base<Us...> *);
+    static std::false_type check(...);
+};
+
+/// Check if a template is the base of a type. For example:
+/// `is_template_base_of<Base, T>` is true if `struct T : Base<U> {}` where U can be anything
+template <template <typename...> class Base, typename T>
+// Sadly, all MSVC versions incl. 2022 need the workaround, even in C++20 mode.
+// See also: https://github.com/pybind/pybind11/pull/3741
+#if !defined(_MSC_VER)
+using is_template_base_of
+    = decltype(is_template_base_of_impl<Base>::check((intrinsic_t<T> *) nullptr));
+#else
+struct is_template_base_of
+    : decltype(is_template_base_of_impl<Base>::check((intrinsic_t<T> *) nullptr)){};
+#endif
+
+/// Check if T is an instantiation of the template `Class`. For example:
+/// `is_instantiation<shared_ptr, T>` is true if `T == shared_ptr<U>` where U can be anything.
+template <template <typename...> class Class, typename T>
+struct is_instantiation : std::false_type {};
+template <template <typename...> class Class, typename... Us>
+struct is_instantiation<Class, Class<Us...>> : std::true_type {};
+
+/// Check if T is std::shared_ptr<U> where U can be anything
+template <typename T>
+using is_shared_ptr = is_instantiation<std::shared_ptr, T>;
+
+/// Check if T looks like an input iterator
+template <typename T, typename = void>
+struct is_input_iterator : std::false_type {};
+template <typename T>
+struct is_input_iterator<T,
+                         void_t<decltype(*std::declval<T &>()), decltype(++std::declval<T &>())>>
+    : std::true_type {};
+
+template <typename T>
+using is_function_pointer
+    = bool_constant<std::is_pointer<T>::value
+                    && std::is_function<typename std::remove_pointer<T>::type>::value>;
+
+template <typename F>
+struct strip_function_object {
+    // If you are encountering an
+    // 'error: name followed by "::" must be a class or namespace name'
+    // with the Intel compiler and a noexcept function here,
+    // try to use noexcept(true) instead of plain noexcept.
+    using type = typename remove_class<decltype(&F::operator())>::type;
+};
+
+// Extracts the function signature from a function, function pointer or lambda.
+template <typename Function, typename F = remove_reference_t<Function>>
+using function_signature_t = conditional_t<
+    std::is_function<F>::value,
+    F,
+    typename conditional_t<std::is_pointer<F>::value || std::is_member_pointer<F>::value,
+                           std::remove_pointer<F>,
+                           strip_function_object<F>>::type>;
+
+/// Returns true if the type looks like a lambda: that is, isn't a function, pointer or member
+/// pointer.  Note that this can catch all sorts of other things, too; this is intended to be used
+/// in a place where passing a lambda makes sense.
+template <typename T>
+using is_lambda = satisfies_none_of<remove_reference_t<T>,
+                                    std::is_function,
+                                    std::is_pointer,
+                                    std::is_member_pointer>;
+
+// [workaround(intel)] Internal error on fold expression
+/// Apply a function over each element of a parameter pack
+#if defined(__cpp_fold_expressions) && !defined(__INTEL_COMPILER)
+// Intel compiler produces an internal error on this fold expression (tested with ICC 19.0.2)
+#    define PYBIND11_EXPAND_SIDE_EFFECTS(PATTERN) (((PATTERN), void()), ...)
+#else
+using expand_side_effects = bool[];
+#    define PYBIND11_EXPAND_SIDE_EFFECTS(PATTERN)                                                 \
+        (void) pybind11::detail::expand_side_effects { ((PATTERN), void(), false)..., false }
+#endif
+
+PYBIND11_NAMESPACE_END(detail)
+
+/// C++ bindings of builtin Python exceptions
+class PYBIND11_EXPORT_EXCEPTION builtin_exception : public std::runtime_error {
+public:
+    using std::runtime_error::runtime_error;
+    /// Set the error using the Python C API
+    virtual void set_error() const = 0;
+};
+
+#define PYBIND11_RUNTIME_EXCEPTION(name, type)                                                    \
+    class PYBIND11_EXPORT_EXCEPTION name : public builtin_exception {                             \
+    public:                                                                                       \
+        using builtin_exception::builtin_exception;                                               \
+        name() : name("") {}                                                                      \
+        void set_error() const override { PyErr_SetString(type, what()); }                        \
+    };
+
+PYBIND11_RUNTIME_EXCEPTION(stop_iteration, PyExc_StopIteration)
+PYBIND11_RUNTIME_EXCEPTION(index_error, PyExc_IndexError)
+PYBIND11_RUNTIME_EXCEPTION(key_error, PyExc_KeyError)
+PYBIND11_RUNTIME_EXCEPTION(value_error, PyExc_ValueError)
+PYBIND11_RUNTIME_EXCEPTION(type_error, PyExc_TypeError)
+PYBIND11_RUNTIME_EXCEPTION(buffer_error, PyExc_BufferError)
+PYBIND11_RUNTIME_EXCEPTION(import_error, PyExc_ImportError)
+PYBIND11_RUNTIME_EXCEPTION(attribute_error, PyExc_AttributeError)
+PYBIND11_RUNTIME_EXCEPTION(cast_error, PyExc_RuntimeError) /// Thrown when pybind11::cast or
+                                                           /// handle::call fail due to a type
+                                                           /// casting error
+PYBIND11_RUNTIME_EXCEPTION(reference_cast_error, PyExc_RuntimeError) /// Used internally
+
+[[noreturn]] PYBIND11_NOINLINE void pybind11_fail(const char *reason) {
+    assert(!PyErr_Occurred());
+    throw std::runtime_error(reason);
+}
+[[noreturn]] PYBIND11_NOINLINE void pybind11_fail(const std::string &reason) {
+    assert(!PyErr_Occurred());
+    throw std::runtime_error(reason);
+}
+
+template <typename T, typename SFINAE = void>
+struct format_descriptor {};
+
+template <typename T>
+struct format_descriptor<
+    T,
+    detail::enable_if_t<detail::is_same_ignoring_cvref<T, PyObject *>::value>> {
+    static constexpr const char c = 'O';
+    static constexpr const char value[2] = {c, '\0'};
+    static std::string format() { return std::string(1, c); }
+};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+// Returns the index of the given type in the type char array below, and in the list in numpy.h
+// The order here is: bool; 8 ints ((signed,unsigned)x(8,16,32,64)bits); float,double,long double;
+// complex float,double,long double.  Note that the long double types only participate when long
+// double is actually longer than double (it isn't under MSVC).
+// NB: not only the string below but also complex.h and numpy.h rely on this order.
+template <typename T, typename SFINAE = void>
+struct is_fmt_numeric {
+    static constexpr bool value = false;
+};
+template <typename T>
+struct is_fmt_numeric<T, enable_if_t<std::is_arithmetic<T>::value>> {
+    static constexpr bool value = true;
+    static constexpr int index
+        = std::is_same<T, bool>::value
+              ? 0
+              : 1
+                    + (std::is_integral<T>::value
+                           ? detail::log2(sizeof(T)) * 2 + std::is_unsigned<T>::value
+                           : 8
+                                 + (std::is_same<T, double>::value        ? 1
+                                    : std::is_same<T, long double>::value ? 2
+                                                                          : 0));
+};
+PYBIND11_NAMESPACE_END(detail)
+
+template <typename T>
+struct format_descriptor<T, detail::enable_if_t<std::is_arithmetic<T>::value>> {
+    static constexpr const char c = "?bBhHiIqQfdg"[detail::is_fmt_numeric<T>::index];
+    static constexpr const char value[2] = {c, '\0'};
+    static std::string format() { return std::string(1, c); }
+};
+
+#if !defined(PYBIND11_CPP17)
+
+template <typename T>
+constexpr const char
+    format_descriptor<T, detail::enable_if_t<std::is_arithmetic<T>::value>>::value[2];
+
+#endif
+
+/// RAII wrapper that temporarily clears any Python error state
+struct error_scope {
+    PyObject *type, *value, *trace;
+    error_scope() { PyErr_Fetch(&type, &value, &trace); }
+    error_scope(const error_scope &) = delete;
+    error_scope &operator=(const error_scope &) = delete;
+    ~error_scope() { PyErr_Restore(type, value, trace); }
+};
+
+/// Dummy destructor wrapper that can be used to expose classes with a private destructor
+struct nodelete {
+    template <typename T>
+    void operator()(T *) {}
+};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+template <typename... Args>
+struct overload_cast_impl {
+    template <typename Return>
+    constexpr auto operator()(Return (*pf)(Args...)) const noexcept -> decltype(pf) {
+        return pf;
+    }
+
+    template <typename Return, typename Class>
+    constexpr auto operator()(Return (Class::*pmf)(Args...), std::false_type = {}) const noexcept
+        -> decltype(pmf) {
+        return pmf;
+    }
+
+    template <typename Return, typename Class>
+    constexpr auto operator()(Return (Class::*pmf)(Args...) const, std::true_type) const noexcept
+        -> decltype(pmf) {
+        return pmf;
+    }
+};
+PYBIND11_NAMESPACE_END(detail)
+
+// overload_cast requires variable templates: C++14
+#if defined(PYBIND11_CPP14)
+#    define PYBIND11_OVERLOAD_CAST 1
+/// Syntax sugar for resolving overloaded function pointers:
+///  - regular: static_cast<Return (Class::*)(Arg0, Arg1, Arg2)>(&Class::func)
+///  - sweet:   overload_cast<Arg0, Arg1, Arg2>(&Class::func)
+template <typename... Args>
+static constexpr detail::overload_cast_impl<Args...> overload_cast{};
+#endif
+
+/// Const member function selector for overload_cast
+///  - regular: static_cast<Return (Class::*)(Arg) const>(&Class::func)
+///  - sweet:   overload_cast<Arg>(&Class::func, const_)
+static constexpr auto const_ = std::true_type{};
+
+#if !defined(PYBIND11_CPP14) // no overload_cast: providing something that static_assert-fails:
+template <typename... Args>
+struct overload_cast {
+    static_assert(detail::deferred_t<std::false_type, Args...>::value,
+                  "pybind11::overload_cast<...> requires compiling in C++14 mode");
+};
+#endif // overload_cast
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+// Adaptor for converting arbitrary container arguments into a vector; implicitly convertible from
+// any standard container (or C-style array) supporting std::begin/std::end, any singleton
+// arithmetic type (if T is arithmetic), or explicitly constructible from an iterator pair.
+template <typename T>
+class any_container {
+    std::vector<T> v;
+
+public:
+    any_container() = default;
+
+    // Can construct from a pair of iterators
+    template <typename It, typename = enable_if_t<is_input_iterator<It>::value>>
+    any_container(It first, It last) : v(first, last) {}
+
+    // Implicit conversion constructor from any arbitrary container type
+    // with values convertible to T
+    template <typename Container,
+              typename = enable_if_t<
+                  std::is_convertible<decltype(*std::begin(std::declval<const Container &>())),
+                                      T>::value>>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    any_container(const Container &c) : any_container(std::begin(c), std::end(c)) {}
+
+    // initializer_list's aren't deducible, so don't get matched by the above template;
+    // we need this to explicitly allow implicit conversion from one:
+    template <typename TIn, typename = enable_if_t<std::is_convertible<TIn, T>::value>>
+    any_container(const std::initializer_list<TIn> &c) : any_container(c.begin(), c.end()) {}
+
+    // Avoid copying if given an rvalue vector of the correct type.
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    any_container(std::vector<T> &&v) : v(std::move(v)) {}
+
+    // Moves the vector out of an rvalue any_container
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator std::vector<T> &&() && { return std::move(v); }
+
+    // Dereferencing obtains a reference to the underlying vector
+    std::vector<T> &operator*() { return v; }
+    const std::vector<T> &operator*() const { return v; }
+
+    // -> lets you call methods on the underlying vector
+    std::vector<T> *operator->() { return &v; }
+    const std::vector<T> *operator->() const { return &v; }
+};
+
+// Forward-declaration; see detail/class.h
+std::string get_fully_qualified_tp_name(PyTypeObject *);
+
+template <typename T>
+inline static std::shared_ptr<T>
+try_get_shared_from_this(std::enable_shared_from_this<T> *holder_value_ptr) {
+// Pre C++17, this code path exploits undefined behavior, but is known to work on many platforms.
+// Use at your own risk!
+// See also https://en.cppreference.com/w/cpp/memory/enable_shared_from_this, and in particular
+// the `std::shared_ptr<Good> gp1 = not_so_good.getptr();` and `try`-`catch` parts of the example.
+#if defined(__cpp_lib_enable_shared_from_this) && (!defined(_MSC_VER) || _MSC_VER >= 1912)
+    return holder_value_ptr->weak_from_this().lock();
+#else
+    try {
+        return holder_value_ptr->shared_from_this();
+    } catch (const std::bad_weak_ptr &) {
+        return nullptr;
+    }
+#endif
+}
+
+// For silencing "unused" compiler warnings in special situations.
+template <typename... Args>
+#if defined(_MSC_VER) && _MSC_VER < 1920 // MSVC 2017
+constexpr
+#endif
+    inline void
+    silence_unused_warnings(Args &&...) {
+}
+
+// MSVC warning C4100: Unreferenced formal parameter
+#if defined(_MSC_VER) && _MSC_VER <= 1916
+#    define PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(...)                                         \
+        detail::silence_unused_warnings(__VA_ARGS__)
+#else
+#    define PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(...)
+#endif
+
+// GCC -Wunused-but-set-parameter  All GCC versions (as of July 2021).
+#if defined(__GNUG__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
+#    define PYBIND11_WORKAROUND_INCORRECT_GCC_UNUSED_BUT_SET_PARAMETER(...)                       \
+        detail::silence_unused_warnings(__VA_ARGS__)
+#else
+#    define PYBIND11_WORKAROUND_INCORRECT_GCC_UNUSED_BUT_SET_PARAMETER(...)
+#endif
+
+#if defined(__clang__)                                                                            \
+    && (defined(__apple_build_version__) /* AppleClang 13.0.0.13000029 was the only data point    \
+                                            available. */                                         \
+        || (__clang_major__ >= 7                                                                  \
+            && __clang_major__ <= 12) /* Clang 3, 5, 13, 14, 15 do not generate the warning. */   \
+    )
+#    define PYBIND11_DETECTED_CLANG_WITH_MISLEADING_CALL_STD_MOVE_EXPLICITLY_WARNING
+// Example:
+// tests/test_kwargs_and_defaults.cpp:46:68: error: local variable 'args' will be copied despite
+// being returned by name [-Werror,-Wreturn-std-move]
+//     m.def("args_function", [](py::args args) -> py::tuple { return args; });
+//                                                                    ^~~~
+// test_kwargs_and_defaults.cpp:46:68: note: call 'std::move' explicitly to avoid copying
+//     m.def("args_function", [](py::args args) -> py::tuple { return args; });
+//                                                                    ^~~~
+//                                                                    std::move(args)
+#endif
+
+// Pybind offers detailed error messages by default for all builts that are debug (through the
+// negation of NDEBUG). This can also be manually enabled by users, for any builds, through
+// defining PYBIND11_DETAILED_ERROR_MESSAGES. This information is primarily useful for those
+// who are writing (as opposed to merely using) libraries that use pybind11.
+#if !defined(PYBIND11_DETAILED_ERROR_MESSAGES) && !defined(NDEBUG)
+#    define PYBIND11_DETAILED_ERROR_MESSAGES
+#endif
+
+// CPython 3.11+ provides Py_TPFLAGS_MANAGED_DICT, but PyPy3.11 does not, see PR #5508.
+#if PY_VERSION_HEX < 0x030B0000 || defined(PYPY_VERSION)
+#    define PYBIND11_BACKWARD_COMPATIBILITY_TP_DICTOFFSET
+#endif
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/detail/cpp_conduit.h b/local_pybind11/pybind11/include/pybind11/detail/cpp_conduit.h
new file mode 100644
index 000000000..a06b9b21a
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/cpp_conduit.h
@@ -0,0 +1,75 @@
+// Copyright (c) 2024 The pybind Community.
+
+#pragma once
+
+#include <pybind11/pytypes.h>
+
+#include "common.h"
+#include "internals.h"
+
+#include <typeinfo>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+// Forward declaration needed here: Refactoring opportunity.
+extern "C" inline PyObject *pybind11_object_new(PyTypeObject *type, PyObject *, PyObject *);
+
+inline bool type_is_managed_by_our_internals(PyTypeObject *type_obj) {
+#if defined(PYPY_VERSION)
+    auto &internals = get_internals();
+    return bool(internals.registered_types_py.find(type_obj)
+                != internals.registered_types_py.end());
+#else
+    return bool(type_obj->tp_new == pybind11_object_new);
+#endif
+}
+
+inline bool is_instance_method_of_type(PyTypeObject *type_obj, PyObject *attr_name) {
+    PyObject *descr = _PyType_Lookup(type_obj, attr_name);
+    return bool((descr != nullptr) && PyInstanceMethod_Check(descr));
+}
+
+inline object try_get_cpp_conduit_method(PyObject *obj) {
+    if (PyType_Check(obj)) {
+        return object();
+    }
+    PyTypeObject *type_obj = Py_TYPE(obj);
+    str attr_name("_pybind11_conduit_v1_");
+    bool assumed_to_be_callable = false;
+    if (type_is_managed_by_our_internals(type_obj)) {
+        if (!is_instance_method_of_type(type_obj, attr_name.ptr())) {
+            return object();
+        }
+        assumed_to_be_callable = true;
+    }
+    PyObject *method = PyObject_GetAttr(obj, attr_name.ptr());
+    if (method == nullptr) {
+        PyErr_Clear();
+        return object();
+    }
+    if (!assumed_to_be_callable && PyCallable_Check(method) == 0) {
+        Py_DECREF(method);
+        return object();
+    }
+    return reinterpret_steal<object>(method);
+}
+
+inline void *try_raw_pointer_ephemeral_from_cpp_conduit(handle src,
+                                                        const std::type_info *cpp_type_info) {
+    object method = try_get_cpp_conduit_method(src.ptr());
+    if (method) {
+        capsule cpp_type_info_capsule(const_cast<void *>(static_cast<const void *>(cpp_type_info)),
+                                      typeid(std::type_info).name());
+        object cpp_conduit = method(bytes(PYBIND11_PLATFORM_ABI_ID),
+                                    cpp_type_info_capsule,
+                                    bytes("raw_pointer_ephemeral"));
+        if (isinstance<capsule>(cpp_conduit)) {
+            return reinterpret_borrow<capsule>(cpp_conduit).get_pointer();
+        }
+    }
+    return nullptr;
+}
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/detail/descr.h b/local_pybind11/pybind11/include/pybind11/detail/descr.h
new file mode 100644
index 000000000..701662c4c
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/descr.h
@@ -0,0 +1,226 @@
+/*
+    pybind11/detail/descr.h: Helper type for concatenating type signatures at compile time
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "common.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+#if !defined(_MSC_VER)
+#    define PYBIND11_DESCR_CONSTEXPR static constexpr
+#else
+#    define PYBIND11_DESCR_CONSTEXPR const
+#endif
+
+/* Concatenate type signatures at compile time */
+template <size_t N, typename... Ts>
+struct descr {
+    char text[N + 1]{'\0'};
+
+    constexpr descr() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    constexpr descr(char const (&s)[N + 1]) : descr(s, make_index_sequence<N>()) {}
+
+    template <size_t... Is>
+    constexpr descr(char const (&s)[N + 1], index_sequence<Is...>) : text{s[Is]..., '\0'} {}
+
+    template <typename... Chars>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    constexpr descr(char c, Chars... cs) : text{c, static_cast<char>(cs)..., '\0'} {}
+
+    static constexpr std::array<const std::type_info *, sizeof...(Ts) + 1> types() {
+        return {{&typeid(Ts)..., nullptr}};
+    }
+};
+
+template <size_t N1, size_t N2, typename... Ts1, typename... Ts2, size_t... Is1, size_t... Is2>
+constexpr descr<N1 + N2, Ts1..., Ts2...> plus_impl(const descr<N1, Ts1...> &a,
+                                                   const descr<N2, Ts2...> &b,
+                                                   index_sequence<Is1...>,
+                                                   index_sequence<Is2...>) {
+    PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(b);
+    return {a.text[Is1]..., b.text[Is2]...};
+}
+
+template <size_t N1, size_t N2, typename... Ts1, typename... Ts2>
+constexpr descr<N1 + N2, Ts1..., Ts2...> operator+(const descr<N1, Ts1...> &a,
+                                                   const descr<N2, Ts2...> &b) {
+    return plus_impl(a, b, make_index_sequence<N1>(), make_index_sequence<N2>());
+}
+
+template <size_t N>
+constexpr descr<N - 1> const_name(char const (&text)[N]) {
+    return descr<N - 1>(text);
+}
+constexpr descr<0> const_name(char const (&)[1]) { return {}; }
+
+template <size_t Rem, size_t... Digits>
+struct int_to_str : int_to_str<Rem / 10, Rem % 10, Digits...> {};
+template <size_t... Digits>
+struct int_to_str<0, Digits...> {
+    // WARNING: This only works with C++17 or higher.
+    static constexpr auto digits = descr<sizeof...(Digits)>(('0' + Digits)...);
+};
+
+// Ternary description (like std::conditional)
+template <bool B, size_t N1, size_t N2>
+constexpr enable_if_t<B, descr<N1 - 1>> const_name(char const (&text1)[N1], char const (&)[N2]) {
+    return const_name(text1);
+}
+template <bool B, size_t N1, size_t N2>
+constexpr enable_if_t<!B, descr<N2 - 1>> const_name(char const (&)[N1], char const (&text2)[N2]) {
+    return const_name(text2);
+}
+
+template <bool B, typename T1, typename T2>
+constexpr enable_if_t<B, T1> const_name(const T1 &d, const T2 &) {
+    return d;
+}
+template <bool B, typename T1, typename T2>
+constexpr enable_if_t<!B, T2> const_name(const T1 &, const T2 &d) {
+    return d;
+}
+
+template <size_t Size>
+auto constexpr const_name() -> remove_cv_t<decltype(int_to_str<Size / 10, Size % 10>::digits)> {
+    return int_to_str<Size / 10, Size % 10>::digits;
+}
+
+template <typename Type>
+constexpr descr<1, Type> const_name() {
+    return {'%'};
+}
+
+// Use a different name based on whether the parameter is used as input or output
+template <size_t N1, size_t N2>
+constexpr descr<N1 + N2 + 1> io_name(char const (&text1)[N1], char const (&text2)[N2]) {
+    return const_name("@") + const_name(text1) + const_name("@") + const_name(text2)
+           + const_name("@");
+}
+
+// Ternary description for io_name (like the numeric type_caster)
+template <bool B, size_t N1, size_t N2, size_t N3, size_t N4>
+constexpr enable_if_t<B, descr<N1 + N2 + 1>>
+io_name(char const (&text1)[N1], char const (&text2)[N2], char const (&)[N3], char const (&)[N4]) {
+    return io_name(text1, text2);
+}
+
+template <bool B, size_t N1, size_t N2, size_t N3, size_t N4>
+constexpr enable_if_t<!B, descr<N3 + N4 + 1>>
+io_name(char const (&)[N1], char const (&)[N2], char const (&text3)[N3], char const (&text4)[N4]) {
+    return io_name(text3, text4);
+}
+
+// If "_" is defined as a macro, py::detail::_ cannot be provided.
+// It is therefore best to use py::detail::const_name universally.
+// This block is for backward compatibility only.
+// (The const_name code is repeated to avoid introducing a "_" #define ourselves.)
+#ifndef _
+#    define PYBIND11_DETAIL_UNDERSCORE_BACKWARD_COMPATIBILITY
+template <size_t N>
+constexpr descr<N - 1> _(char const (&text)[N]) {
+    return const_name<N>(text);
+}
+template <bool B, size_t N1, size_t N2>
+constexpr enable_if_t<B, descr<N1 - 1>> _(char const (&text1)[N1], char const (&text2)[N2]) {
+    return const_name<B, N1, N2>(text1, text2);
+}
+template <bool B, size_t N1, size_t N2>
+constexpr enable_if_t<!B, descr<N2 - 1>> _(char const (&text1)[N1], char const (&text2)[N2]) {
+    return const_name<B, N1, N2>(text1, text2);
+}
+template <bool B, typename T1, typename T2>
+constexpr enable_if_t<B, T1> _(const T1 &d1, const T2 &d2) {
+    return const_name<B, T1, T2>(d1, d2);
+}
+template <bool B, typename T1, typename T2>
+constexpr enable_if_t<!B, T2> _(const T1 &d1, const T2 &d2) {
+    return const_name<B, T1, T2>(d1, d2);
+}
+
+template <size_t Size>
+auto constexpr _() -> remove_cv_t<decltype(int_to_str<Size / 10, Size % 10>::digits)> {
+    return const_name<Size>();
+}
+template <typename Type>
+constexpr descr<1, Type> _() {
+    return const_name<Type>();
+}
+#endif // #ifndef _
+
+constexpr descr<0> concat() { return {}; }
+constexpr descr<0> union_concat() { return {}; }
+
+template <size_t N, typename... Ts>
+constexpr descr<N, Ts...> concat(const descr<N, Ts...> &descr) {
+    return descr;
+}
+
+template <size_t N, typename... Ts>
+constexpr descr<N, Ts...> union_concat(const descr<N, Ts...> &descr) {
+    return descr;
+}
+
+template <size_t N1, size_t N2, typename... Ts1, typename... Ts2>
+constexpr descr<N1 + N2 + 3, Ts1..., Ts2...> operator|(const descr<N1, Ts1...> &a,
+                                                       const descr<N2, Ts2...> &b) {
+    return a + const_name(" | ") + b;
+}
+
+#ifdef __cpp_fold_expressions
+template <size_t N1, size_t N2, typename... Ts1, typename... Ts2>
+constexpr descr<N1 + N2 + 2, Ts1..., Ts2...> operator,(const descr<N1, Ts1...> &a,
+                                                       const descr<N2, Ts2...> &b) {
+    return a + const_name(", ") + b;
+}
+
+template <size_t N, typename... Ts, typename... Args>
+constexpr auto concat(const descr<N, Ts...> &d, const Args &...args) {
+    return (d, ..., args);
+}
+
+template <size_t N, typename... Ts, typename... Args>
+constexpr auto union_concat(const descr<N, Ts...> &d, const Args &...args) {
+    return (d | ... | args);
+}
+
+#else
+template <size_t N, typename... Ts, typename... Args>
+constexpr auto concat(const descr<N, Ts...> &d, const Args &...args)
+    -> decltype(std::declval<descr<N + 2, Ts...>>() + concat(args...)) {
+    return d + const_name(", ") + concat(args...);
+}
+
+template <size_t N, typename... Ts, typename... Args>
+constexpr auto union_concat(const descr<N, Ts...> &d, const Args &...args)
+    -> decltype(std::declval<descr<N + 3, Ts...>>() + union_concat(args...)) {
+    return d + const_name(" | ") + union_concat(args...);
+}
+
+#endif
+
+template <size_t N, typename... Ts>
+constexpr descr<N + 2, Ts...> type_descr(const descr<N, Ts...> &descr) {
+    return const_name("{") + descr + const_name("}");
+}
+
+template <size_t N, typename... Ts>
+constexpr descr<N + 4, Ts...> arg_descr(const descr<N, Ts...> &descr) {
+    return const_name("@^") + descr + const_name("@!");
+}
+
+template <size_t N, typename... Ts>
+constexpr descr<N + 4, Ts...> return_descr(const descr<N, Ts...> &descr) {
+    return const_name("@$") + descr + const_name("@!");
+}
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/detail/dynamic_raw_ptr_cast_if_possible.h b/local_pybind11/pybind11/include/pybind11/detail/dynamic_raw_ptr_cast_if_possible.h
new file mode 100644
index 000000000..7c00fe98c
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/dynamic_raw_ptr_cast_if_possible.h
@@ -0,0 +1,39 @@
+// Copyright (c) 2021 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#pragma once
+
+#include "common.h"
+
+#include <type_traits>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+template <typename To, typename From, typename SFINAE = void>
+struct dynamic_raw_ptr_cast_is_possible : std::false_type {};
+
+template <typename To, typename From>
+struct dynamic_raw_ptr_cast_is_possible<
+    To,
+    From,
+    detail::enable_if_t<!std::is_same<To, void>::value && std::is_polymorphic<From>::value>>
+    : std::true_type {};
+
+template <typename To,
+          typename From,
+          detail::enable_if_t<!dynamic_raw_ptr_cast_is_possible<To, From>::value, int> = 0>
+To *dynamic_raw_ptr_cast_if_possible(From * /*ptr*/) {
+    return nullptr;
+}
+
+template <typename To,
+          typename From,
+          detail::enable_if_t<dynamic_raw_ptr_cast_is_possible<To, From>::value, int> = 0>
+To *dynamic_raw_ptr_cast_if_possible(From *ptr) {
+    return dynamic_cast<To *>(ptr);
+}
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/detail/exception_translation.h b/local_pybind11/pybind11/include/pybind11/detail/exception_translation.h
new file mode 100644
index 000000000..22ae8a1c9
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/exception_translation.h
@@ -0,0 +1,71 @@
+/*
+    pybind11/detail/exception_translation.h: means to translate C++ exceptions to Python exceptions
+
+    Copyright (c) 2024 The Pybind Development Team.
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "common.h"
+#include "internals.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+// Apply all the extensions translators from a list
+// Return true if one of the translators completed without raising an exception
+// itself. Return of false indicates that if there are other translators
+// available, they should be tried.
+inline bool apply_exception_translators(std::forward_list<ExceptionTranslator> &translators) {
+    auto last_exception = std::current_exception();
+
+    for (auto &translator : translators) {
+        try {
+            translator(last_exception);
+            return true;
+        } catch (...) {
+            last_exception = std::current_exception();
+        }
+    }
+    return false;
+}
+
+inline void try_translate_exceptions() {
+    /* When an exception is caught, give each registered exception
+        translator a chance to translate it to a Python exception. First
+        all module-local translators will be tried in reverse order of
+        registration. If none of the module-locale translators handle
+        the exception (or there are no module-locale translators) then
+        the global translators will be tried, also in reverse order of
+        registration.
+
+        A translator may choose to do one of the following:
+
+        - catch the exception and call py::set_error()
+            to set a standard (or custom) Python exception, or
+        - do nothing and let the exception fall through to the next translator, or
+        - delegate translation to the next translator by throwing a new type of exception.
+        */
+
+    bool handled = with_exception_translators(
+        [&](std::forward_list<ExceptionTranslator> &exception_translators,
+            std::forward_list<ExceptionTranslator> &local_exception_translators) {
+            if (detail::apply_exception_translators(local_exception_translators)) {
+                return true;
+            }
+            if (detail::apply_exception_translators(exception_translators)) {
+                return true;
+            }
+            return false;
+        });
+
+    if (!handled) {
+        set_error(PyExc_SystemError, "Exception escaped from default exception translator!");
+    }
+}
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/detail/function_record_pyobject.h b/local_pybind11/pybind11/include/pybind11/detail/function_record_pyobject.h
new file mode 100644
index 000000000..d9c5bad93
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/function_record_pyobject.h
@@ -0,0 +1,191 @@
+// Copyright (c) 2024-2025 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// For background see the description of PR google/pybind11clif#30099.
+
+#pragma once
+
+#include <pybind11/attr.h>
+#include <pybind11/conduit/pybind11_platform_abi_id.h>
+#include <pybind11/pytypes.h>
+
+#include "common.h"
+
+#include <cstring>
+#include <utility>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+struct function_record_PyObject {
+    PyObject_HEAD
+    function_record *cpp_func_rec;
+};
+
+PYBIND11_NAMESPACE_BEGIN(function_record_PyTypeObject_methods)
+
+PyObject *tp_new_impl(PyTypeObject *type, PyObject *args, PyObject *kwds);
+PyObject *tp_alloc_impl(PyTypeObject *type, Py_ssize_t nitems);
+int tp_init_impl(PyObject *self, PyObject *args, PyObject *kwds);
+void tp_dealloc_impl(PyObject *self);
+void tp_free_impl(void *self);
+
+static PyObject *reduce_ex_impl(PyObject *self, PyObject *, PyObject *);
+
+static PyMethodDef tp_methods_impl[]
+    = {{"__reduce_ex__",
+        // reduce_ex_impl is a PyCFunctionWithKeywords, but PyMethodDef
+        // requires a PyCFunction. The cast through void* is safe and
+        // idiomatic with METH_KEYWORDS, and it successfully sidesteps
+        // unhelpful compiler warnings.
+        // NOLINTNEXTLINE(bugprone-casting-through-void)
+        reinterpret_cast<PyCFunction>(reinterpret_cast<void *>(reduce_ex_impl)),
+        METH_VARARGS | METH_KEYWORDS,
+        nullptr},
+       {nullptr, nullptr, 0, nullptr}};
+
+// Python 3.12+ emits a DeprecationWarning for heap types whose tp_name does
+// not contain a dot ('.') and that lack a __module__ attribute. For pybind11's
+// internal function_record type, we do not have an actual module object to
+// attach, so we cannot use PyType_FromModuleAndSpec (introduced in Python 3.9)
+// to set __module__ automatically.
+//
+// As a workaround, we define a "qualified" type name that includes a dummy
+// module name (PYBIND11_DUMMY_MODULE_NAME). This is non‑idiomatic but avoids
+// the deprecation warning, and results in reprs like
+//
+//     <class 'pybind11_builtins.pybind11_detail_function_record_...'>
+//
+// even though no real pybind11_builtins module exists. If pybind11 gains an
+// actual module object in the future, this code should switch to
+// PyType_FromModuleAndSpec for Python 3.9+ and drop the dummy module
+// workaround.
+//
+// Note that this name is versioned.
+#define PYBIND11_DETAIL_FUNCTION_RECORD_TP_PLAINNAME                                              \
+    "pybind11_detail_function_record_" PYBIND11_DETAIL_FUNCTION_RECORD_ABI_ID                     \
+    "_" PYBIND11_PLATFORM_ABI_ID
+constexpr char tp_plainname_impl[] = PYBIND11_DETAIL_FUNCTION_RECORD_TP_PLAINNAME;
+constexpr char tp_qualname_impl[]
+    = PYBIND11_DUMMY_MODULE_NAME "." PYBIND11_DETAIL_FUNCTION_RECORD_TP_PLAINNAME;
+
+PYBIND11_NAMESPACE_END(function_record_PyTypeObject_methods)
+
+static PyType_Slot function_record_PyType_Slots[] = {
+    {Py_tp_dealloc,
+     reinterpret_cast<void *>(function_record_PyTypeObject_methods::tp_dealloc_impl)},
+    {Py_tp_methods,
+     reinterpret_cast<void *>(function_record_PyTypeObject_methods::tp_methods_impl)},
+    {Py_tp_init, reinterpret_cast<void *>(function_record_PyTypeObject_methods::tp_init_impl)},
+    {Py_tp_alloc, reinterpret_cast<void *>(function_record_PyTypeObject_methods::tp_alloc_impl)},
+    {Py_tp_new, reinterpret_cast<void *>(function_record_PyTypeObject_methods::tp_new_impl)},
+    {Py_tp_free, reinterpret_cast<void *>(function_record_PyTypeObject_methods::tp_free_impl)},
+    {0, nullptr}};
+
+static PyType_Spec function_record_PyType_Spec
+    = {function_record_PyTypeObject_methods::tp_qualname_impl,
+       sizeof(function_record_PyObject),
+       0,
+       Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE,
+       function_record_PyType_Slots};
+
+inline PyTypeObject *get_function_record_PyTypeObject() {
+    PyTypeObject *&py_type_obj = detail::get_local_internals().function_record_py_type;
+    if (!py_type_obj) {
+        PyObject *py_obj = PyType_FromSpec(&function_record_PyType_Spec);
+        if (py_obj == nullptr) {
+            throw error_already_set();
+        }
+        py_type_obj = reinterpret_cast<PyTypeObject *>(py_obj);
+    }
+    return py_type_obj;
+}
+
+inline bool is_function_record_PyObject(PyObject *obj) {
+    if (PyType_Check(obj) != 0) {
+        return false;
+    }
+    PyTypeObject *obj_type = Py_TYPE(obj);
+
+    PyTypeObject *frtype = get_function_record_PyTypeObject();
+
+    // Fast path (pointer comparison).
+    if (obj_type == frtype) {
+        return true;
+    }
+    // This works across extension modules. Note that tp_name is versioned.
+    if (strcmp(obj_type->tp_name, function_record_PyTypeObject_methods::tp_qualname_impl) == 0
+        || strcmp(obj_type->tp_name, function_record_PyTypeObject_methods::tp_plainname_impl)
+               == 0) {
+        return true;
+    }
+    return false;
+}
+
+inline function_record *function_record_ptr_from_PyObject(PyObject *obj) {
+    if (is_function_record_PyObject(obj)) {
+        return ((detail::function_record_PyObject *) obj)->cpp_func_rec;
+    }
+    return nullptr;
+}
+
+inline object function_record_PyObject_New() {
+    auto *py_func_rec = PyObject_New(function_record_PyObject, get_function_record_PyTypeObject());
+    if (py_func_rec == nullptr) {
+        throw error_already_set();
+    }
+    py_func_rec->cpp_func_rec = nullptr; // For clarity/purity. Redundant in practice.
+    return reinterpret_steal<object>((PyObject *) py_func_rec);
+}
+
+PYBIND11_NAMESPACE_BEGIN(function_record_PyTypeObject_methods)
+
+// Guard against accidents & oversights, in particular when porting to future Python versions.
+inline PyObject *tp_new_impl(PyTypeObject *, PyObject *, PyObject *) {
+    pybind11_fail("UNEXPECTED CALL OF function_record_PyTypeObject_methods::tp_new_impl");
+    // return nullptr; // Unreachable.
+}
+
+inline PyObject *tp_alloc_impl(PyTypeObject *, Py_ssize_t) {
+    pybind11_fail("UNEXPECTED CALL OF function_record_PyTypeObject_methods::tp_alloc_impl");
+    // return nullptr; // Unreachable.
+}
+
+inline int tp_init_impl(PyObject *, PyObject *, PyObject *) {
+    pybind11_fail("UNEXPECTED CALL OF function_record_PyTypeObject_methods::tp_init_impl");
+    // return -1; // Unreachable.
+}
+
+inline void tp_free_impl(void *) {
+    pybind11_fail("UNEXPECTED CALL OF function_record_PyTypeObject_methods::tp_free_impl");
+}
+
+inline PyObject *reduce_ex_impl(PyObject *self, PyObject *, PyObject *) {
+    // Deliberately ignoring the arguments for simplicity (expected is `protocol: int`).
+    const function_record *rec = function_record_ptr_from_PyObject(self);
+    if (rec == nullptr) {
+        pybind11_fail(
+            "FATAL: function_record_PyTypeObject reduce_ex_impl(): cannot obtain cpp_func_rec.");
+    }
+    if (rec->name != nullptr && rec->name[0] != '\0' && rec->scope
+        && PyModule_Check(rec->scope.ptr()) != 0) {
+        object scope_module = get_scope_module(rec->scope);
+        if (scope_module) {
+            auto builtins = reinterpret_borrow<dict>(PyEval_GetBuiltins());
+            auto builtins_eval = builtins["eval"];
+            auto reconstruct_args = make_tuple(str("__import__('importlib').import_module('")
+                                               + scope_module + str("')"));
+            return make_tuple(std::move(builtins_eval), std::move(reconstruct_args))
+                .release()
+                .ptr();
+        }
+    }
+    set_error(PyExc_RuntimeError, repr(self) + str(" is not pickleable."));
+    return nullptr;
+}
+
+PYBIND11_NAMESPACE_END(function_record_PyTypeObject_methods)
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/detail/init.h b/local_pybind11/pybind11/include/pybind11/detail/init.h
new file mode 100644
index 000000000..9589d74d2
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/init.h
@@ -0,0 +1,538 @@
+/*
+    pybind11/detail/init.h: init factory function implementation and support code.
+
+    Copyright (c) 2017 Jason Rhinelander <jason@imaginary.ca>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "class.h"
+#include "using_smart_holder.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+PYBIND11_WARNING_DISABLE_MSVC(4127)
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+template <>
+class type_caster<value_and_holder> {
+public:
+    bool load(handle h, bool) {
+        value = reinterpret_cast<value_and_holder *>(h.ptr());
+        return true;
+    }
+
+    template <typename>
+    using cast_op_type = value_and_holder &;
+    explicit operator value_and_holder &() { return *value; }
+    static constexpr auto name = const_name<value_and_holder>();
+
+private:
+    value_and_holder *value = nullptr;
+};
+
+PYBIND11_NAMESPACE_BEGIN(initimpl)
+
+inline void no_nullptr(const void *ptr) {
+    if (!ptr) {
+        throw type_error("pybind11::init(): factory function returned nullptr");
+    }
+}
+
+// Implementing functions for all forms of py::init<...> and py::init(...)
+template <typename Class>
+using Cpp = typename Class::type;
+template <typename Class>
+using Alias = typename Class::type_alias;
+template <typename Class>
+using Holder = typename Class::holder_type;
+
+template <typename Class>
+using is_alias_constructible = std::is_constructible<Alias<Class>, Cpp<Class> &&>;
+
+// Takes a Cpp pointer and returns true if it actually is a polymorphic Alias instance.
+template <typename Class, enable_if_t<Class::has_alias, int> = 0>
+bool is_alias(Cpp<Class> *ptr) {
+    return dynamic_cast<Alias<Class> *>(ptr) != nullptr;
+}
+// Failing fallback version of the above for a no-alias class (always returns false)
+template <typename /*Class*/>
+constexpr bool is_alias(const void *) {
+    return false;
+}
+
+// Constructs and returns a new object; if the given arguments don't map to a constructor, we fall
+// back to brace aggregate initialization so that for aggregate initialization can be used with
+// py::init, e.g.  `py::init<int, int>` to initialize a `struct T { int a; int b; }`.  For
+// non-aggregate types, we need to use an ordinary T(...) constructor (invoking as `T{...}` usually
+// works, but will not do the expected thing when `T` has an `initializer_list<T>` constructor).
+template <typename Class,
+          typename... Args,
+          detail::enable_if_t<std::is_constructible<Class, Args...>::value, int> = 0>
+inline Class *construct_or_initialize(Args &&...args) {
+    return new Class(std::forward<Args>(args)...);
+}
+template <typename Class,
+          typename... Args,
+          detail::enable_if_t<!std::is_constructible<Class, Args...>::value, int> = 0>
+inline Class *construct_or_initialize(Args &&...args) {
+    return new Class{std::forward<Args>(args)...};
+}
+
+// Attempts to constructs an alias using a `Alias(Cpp &&)` constructor.  This allows types with
+// an alias to provide only a single Cpp factory function as long as the Alias can be
+// constructed from an rvalue reference of the base Cpp type.  This means that Alias classes
+// can, when appropriate, simply define a `Alias(Cpp &&)` constructor rather than needing to
+// inherit all the base class constructors.
+template <typename Class>
+void construct_alias_from_cpp(std::true_type /*is_alias_constructible*/,
+                              value_and_holder &v_h,
+                              Cpp<Class> &&base) {
+    v_h.value_ptr() = new Alias<Class>(std::move(base));
+}
+template <typename Class>
+[[noreturn]] void construct_alias_from_cpp(std::false_type /*!is_alias_constructible*/,
+                                           value_and_holder &,
+                                           Cpp<Class> &&) {
+    throw type_error("pybind11::init(): unable to convert returned instance to required "
+                     "alias class: no `Alias<Class>(Class &&)` constructor available");
+}
+
+// Error-generating fallback for factories that don't match one of the below construction
+// mechanisms.
+template <typename Class>
+void construct(...) {
+    static_assert(!std::is_same<Class, Class>::value /* always false */,
+                  "pybind11::init(): init function must return a compatible pointer, "
+                  "holder, or value");
+}
+
+// Pointer return v1: the factory function returns a class pointer for a registered class.
+// If we don't need an alias (because this class doesn't have one, or because the final type is
+// inherited on the Python side) we can simply take over ownership.  Otherwise we need to try to
+// construct an Alias from the returned base instance.
+template <typename Class>
+void construct(value_and_holder &v_h, Cpp<Class> *ptr, bool need_alias) {
+    PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(need_alias);
+    no_nullptr(ptr);
+    if (Class::has_alias && need_alias && !is_alias<Class>(ptr)) {
+        // We're going to try to construct an alias by moving the cpp type.  Whether or not
+        // that succeeds, we still need to destroy the original cpp pointer (either the
+        // moved away leftover, if the alias construction works, or the value itself if we
+        // throw an error), but we can't just call `delete ptr`: it might have a special
+        // deleter, or might be shared_from_this.  So we construct a holder around it as if
+        // it was a normal instance, then steal the holder away into a local variable; thus
+        // the holder and destruction happens when we leave the C++ scope, and the holder
+        // class gets to handle the destruction however it likes.
+        v_h.value_ptr() = ptr;
+        v_h.set_instance_registered(true); // Trick to prevent init_instance from registering it
+        // DANGER ZONE BEGIN: exceptions will leave v_h in an invalid state.
+        v_h.type->init_instance(v_h.inst, nullptr);                        // Set up the holder
+        Holder<Class> temp_holder(std::move(v_h.holder<Holder<Class>>())); // Steal the holder
+        v_h.type->dealloc(v_h); // Destroys the moved-out holder remains, resets value ptr to null
+        v_h.set_instance_registered(false);
+        // DANGER ZONE END.
+
+        construct_alias_from_cpp<Class>(is_alias_constructible<Class>{}, v_h, std::move(*ptr));
+    } else {
+        // Otherwise the type isn't inherited, so we don't need an Alias
+        v_h.value_ptr() = ptr;
+    }
+}
+
+// Pointer return v2: a factory that always returns an alias instance ptr.  We simply take over
+// ownership of the pointer.
+template <typename Class, enable_if_t<Class::has_alias, int> = 0>
+void construct(value_and_holder &v_h, Alias<Class> *alias_ptr, bool) {
+    no_nullptr(alias_ptr);
+    v_h.value_ptr() = static_cast<Cpp<Class> *>(alias_ptr);
+}
+
+// Holder return: copy its pointer, and move or copy the returned holder into the new instance's
+// holder.  This also handles types like std::shared_ptr<T> and std::unique_ptr<T> where T is a
+// derived type (through those holder's implicit conversion from derived class holder
+// constructors).
+template <typename Class, detail::enable_if_t<!is_smart_holder<Holder<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h, Holder<Class> holder, bool need_alias) {
+    PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(need_alias);
+    auto *ptr = holder_helper<Holder<Class>>::get(holder);
+    no_nullptr(ptr);
+    // If we need an alias, check that the held pointer is actually an alias instance
+    if (Class::has_alias && need_alias && !is_alias<Class>(ptr)) {
+        throw type_error("pybind11::init(): construction failed: returned holder-wrapped instance "
+                         "is not an alias instance");
+    }
+
+    // Cast away constness to store in void* storage.
+    // The value_and_holder storage is fundamentally untyped (void**), so we lose
+    // const-correctness here by design. The const qualifier will be restored
+    // when the pointer is later retrieved and cast back to the original type.
+    // This explicit const_cast makes the const-removal clearly visible.
+    v_h.value_ptr() = const_cast<void *>(static_cast<const void *>(ptr));
+    v_h.type->init_instance(v_h.inst, &holder);
+}
+
+// return-by-value version 1: returning a cpp class by value.  If the class has an alias and an
+// alias is required the alias must have an `Alias(Cpp &&)` constructor so that we can construct
+// the alias from the base when needed (i.e. because of Python-side inheritance).  When we don't
+// need it, we simply move-construct the cpp value into a new instance.
+template <typename Class>
+void construct(value_and_holder &v_h, Cpp<Class> &&result, bool need_alias) {
+    PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(need_alias);
+    static_assert(is_move_constructible<Cpp<Class>>::value,
+                  "pybind11::init() return-by-value factory function requires a movable class");
+    if (Class::has_alias && need_alias) {
+        construct_alias_from_cpp<Class>(is_alias_constructible<Class>{}, v_h, std::move(result));
+    } else {
+        v_h.value_ptr() = new Cpp<Class>(std::move(result));
+    }
+}
+
+// return-by-value version 2: returning a value of the alias type itself.  We move-construct an
+// Alias instance (even if no the python-side inheritance is involved).  The is intended for
+// cases where Alias initialization is always desired.
+template <typename Class>
+void construct(value_and_holder &v_h, Alias<Class> &&result, bool) {
+    static_assert(
+        is_move_constructible<Alias<Class>>::value,
+        "pybind11::init() return-by-alias-value factory function requires a movable alias class");
+    v_h.value_ptr() = new Alias<Class>(std::move(result));
+}
+
+template <typename T, typename D>
+smart_holder init_smart_holder_from_unique_ptr(std::unique_ptr<T, D> &&unq_ptr,
+                                               bool void_cast_raw_ptr) {
+    void *void_ptr = void_cast_raw_ptr ? static_cast<void *>(unq_ptr.get()) : nullptr;
+    return smart_holder::from_unique_ptr(std::move(unq_ptr), void_ptr);
+}
+
+template <typename Class,
+          typename D = std::default_delete<Cpp<Class>>,
+          detail::enable_if_t<is_smart_holder<Holder<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr, bool need_alias) {
+    PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(need_alias);
+    auto *ptr = unq_ptr.get();
+    no_nullptr(ptr);
+    if (Class::has_alias && need_alias && !is_alias<Class>(ptr)) {
+        throw type_error("pybind11::init(): construction failed: returned std::unique_ptr pointee "
+                         "is not an alias instance");
+    }
+    // Here and below: if the new object is a trampoline, the shared_from_this mechanism needs
+    // to be prevented from accessing the smart_holder vptr, because it does not keep the
+    // trampoline Python object alive. For types that don't inherit from enable_shared_from_this
+    // it does not matter if void_cast_raw_ptr is true or false, therefore it's not necessary
+    // to also inspect the type.
+    auto smhldr = init_smart_holder_from_unique_ptr(
+        std::move(unq_ptr), /*void_cast_raw_ptr*/ Class::has_alias && is_alias<Class>(ptr));
+    v_h.value_ptr() = ptr;
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}
+
+template <typename Class,
+          typename D = std::default_delete<Alias<Class>>,
+          detail::enable_if_t<is_smart_holder<Holder<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h,
+               std::unique_ptr<Alias<Class>, D> &&unq_ptr,
+               bool /*need_alias*/) {
+    auto *ptr = unq_ptr.get();
+    no_nullptr(ptr);
+    auto smhldr
+        = init_smart_holder_from_unique_ptr(std::move(unq_ptr), /*void_cast_raw_ptr*/ true);
+    v_h.value_ptr() = ptr;
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}
+
+template <typename PtrType, typename Class>
+void construct_from_shared_ptr(value_and_holder &v_h,
+                               std::shared_ptr<PtrType> &&shd_ptr,
+                               bool need_alias) {
+    static_assert(std::is_same<PtrType, Cpp<Class>>::value
+                      || std::is_same<PtrType, const Cpp<Class>>::value,
+                  "Expected (const) Cpp<Class> as shared_ptr pointee");
+    auto *ptr = shd_ptr.get();
+    no_nullptr(ptr);
+    if (Class::has_alias && need_alias && !is_alias<Class>(ptr)) {
+        throw type_error("pybind11::init(): construction failed: returned std::shared_ptr pointee "
+                         "is not an alias instance");
+    }
+    // Cast to non-const if needed, consistent with internal design
+    auto smhldr
+        = smart_holder::from_shared_ptr(std::const_pointer_cast<Cpp<Class>>(std::move(shd_ptr)));
+    v_h.value_ptr() = const_cast<Cpp<Class> *>(ptr);
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}
+
+template <typename Class, detail::enable_if_t<is_smart_holder<Holder<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, bool need_alias) {
+    construct_from_shared_ptr<Cpp<Class>, Class>(v_h, std::move(shd_ptr), need_alias);
+}
+
+template <typename Class, detail::enable_if_t<is_smart_holder<Holder<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h,
+               std::shared_ptr<const Cpp<Class>> &&shd_ptr,
+               bool need_alias) {
+    construct_from_shared_ptr<const Cpp<Class>, Class>(v_h, std::move(shd_ptr), need_alias);
+}
+
+template <typename Class, detail::enable_if_t<is_smart_holder<Holder<Class>>::value, int> = 0>
+void construct(value_and_holder &v_h,
+               std::shared_ptr<Alias<Class>> &&shd_ptr,
+               bool /*need_alias*/) {
+    auto *ptr = shd_ptr.get();
+    no_nullptr(ptr);
+    auto smhldr = smart_holder::from_shared_ptr(shd_ptr);
+    v_h.value_ptr() = ptr;
+    v_h.type->init_instance(v_h.inst, &smhldr);
+}
+
+// Implementing class for py::init<...>()
+template <typename... Args>
+struct constructor {
+    template <typename Class, typename... Extra, enable_if_t<!Class::has_alias, int> = 0>
+    static void execute(Class &cl, const Extra &...extra) {
+        cl.def(
+            "__init__",
+            [](value_and_holder &v_h,
+               Args... args) { // NOLINT(performance-unnecessary-value-param)
+                v_h.value_ptr() = construct_or_initialize<Cpp<Class>>(std::forward<Args>(args)...);
+            },
+            is_new_style_constructor(),
+            extra...);
+    }
+
+    template <
+        typename Class,
+        typename... Extra,
+        enable_if_t<Class::has_alias && std::is_constructible<Cpp<Class>, Args...>::value, int>
+        = 0>
+    static void execute(Class &cl, const Extra &...extra) {
+        cl.def(
+            "__init__",
+            [](value_and_holder &v_h, Args... args) {
+                if (Py_TYPE(v_h.inst) == v_h.type->type) {
+                    v_h.value_ptr()
+                        = construct_or_initialize<Cpp<Class>>(std::forward<Args>(args)...);
+                } else {
+                    v_h.value_ptr()
+                        = construct_or_initialize<Alias<Class>>(std::forward<Args>(args)...);
+                }
+            },
+            is_new_style_constructor(),
+            extra...);
+    }
+
+    template <
+        typename Class,
+        typename... Extra,
+        enable_if_t<Class::has_alias && !std::is_constructible<Cpp<Class>, Args...>::value, int>
+        = 0>
+    static void execute(Class &cl, const Extra &...extra) {
+        cl.def(
+            "__init__",
+            [](value_and_holder &v_h, Args... args) {
+                v_h.value_ptr()
+                    = construct_or_initialize<Alias<Class>>(std::forward<Args>(args)...);
+            },
+            is_new_style_constructor(),
+            extra...);
+    }
+};
+
+// Implementing class for py::init_alias<...>()
+template <typename... Args>
+struct alias_constructor {
+    template <
+        typename Class,
+        typename... Extra,
+        enable_if_t<Class::has_alias && std::is_constructible<Alias<Class>, Args...>::value, int>
+        = 0>
+    static void execute(Class &cl, const Extra &...extra) {
+        cl.def(
+            "__init__",
+            [](value_and_holder &v_h, Args... args) {
+                v_h.value_ptr()
+                    = construct_or_initialize<Alias<Class>>(std::forward<Args>(args)...);
+            },
+            is_new_style_constructor(),
+            extra...);
+    }
+};
+
+// Implementation class for py::init(Func) and py::init(Func, AliasFunc)
+template <typename CFunc,
+          typename AFunc = void_type (*)(),
+          typename = function_signature_t<CFunc>,
+          typename = function_signature_t<AFunc>>
+struct factory;
+
+// Specialization for py::init(Func)
+template <typename Func, typename Return, typename... Args>
+struct factory<Func, void_type (*)(), Return(Args...)> {
+    remove_reference_t<Func> class_factory;
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    factory(Func &&f) : class_factory(std::forward<Func>(f)) {}
+
+    // The given class either has no alias or has no separate alias factory;
+    // this always constructs the class itself.  If the class is registered with an alias
+    // type and an alias instance is needed (i.e. because the final type is a Python class
+    // inheriting from the C++ type) the returned value needs to either already be an alias
+    // instance, or the alias needs to be constructible from a `Class &&` argument.
+    template <typename Class, typename... Extra>
+    void execute(Class &cl, const Extra &...extra) && {
+#if defined(PYBIND11_CPP14)
+        cl.def(
+            "__init__",
+            [func = std::move(class_factory)]
+#else
+        auto &func = class_factory;
+        cl.def(
+            "__init__",
+            [func]
+#endif
+            (value_and_holder &v_h, Args... args) {
+                construct<Class>(
+                    v_h, func(std::forward<Args>(args)...), Py_TYPE(v_h.inst) != v_h.type->type);
+            },
+            is_new_style_constructor(),
+            extra...);
+    }
+};
+
+// Specialization for py::init(Func, AliasFunc)
+template <typename CFunc,
+          typename AFunc,
+          typename CReturn,
+          typename... CArgs,
+          typename AReturn,
+          typename... AArgs>
+struct factory<CFunc, AFunc, CReturn(CArgs...), AReturn(AArgs...)> {
+    static_assert(sizeof...(CArgs) == sizeof...(AArgs),
+                  "pybind11::init(class_factory, alias_factory): class and alias factories "
+                  "must have identical argument signatures");
+    static_assert(all_of<std::is_same<CArgs, AArgs>...>::value,
+                  "pybind11::init(class_factory, alias_factory): class and alias factories "
+                  "must have identical argument signatures");
+
+    remove_reference_t<CFunc> class_factory;
+    remove_reference_t<AFunc> alias_factory;
+
+    factory(CFunc &&c, AFunc &&a)
+        : class_factory(std::forward<CFunc>(c)), alias_factory(std::forward<AFunc>(a)) {}
+
+    // The class factory is called when the `self` type passed to `__init__` is the direct
+    // class (i.e. not inherited), the alias factory when `self` is a Python-side subtype.
+    template <typename Class, typename... Extra>
+    void execute(Class &cl, const Extra &...extra) && {
+        static_assert(Class::has_alias,
+                      "The two-argument version of `py::init()` can "
+                      "only be used if the class has an alias");
+#if defined(PYBIND11_CPP14)
+        cl.def(
+            "__init__",
+            [class_func = std::move(class_factory), alias_func = std::move(alias_factory)]
+#else
+        auto &class_func = class_factory;
+        auto &alias_func = alias_factory;
+        cl.def(
+            "__init__",
+            [class_func, alias_func]
+#endif
+            (value_and_holder &v_h, CArgs... args) {
+                if (Py_TYPE(v_h.inst) == v_h.type->type) {
+                    // If the instance type equals the registered type we don't have inheritance,
+                    // so don't need the alias and can construct using the class function:
+                    construct<Class>(v_h, class_func(std::forward<CArgs>(args)...), false);
+                } else {
+                    construct<Class>(v_h, alias_func(std::forward<CArgs>(args)...), true);
+                }
+            },
+            is_new_style_constructor(),
+            extra...);
+    }
+};
+
+/// Set just the C++ state. Same as `__init__`.
+template <typename Class, typename T>
+void setstate(value_and_holder &v_h, T &&result, bool need_alias) {
+    construct<Class>(v_h, std::forward<T>(result), need_alias);
+}
+
+/// Set both the C++ and Python states
+template <typename Class,
+          typename T,
+          typename O,
+          enable_if_t<std::is_convertible<O, handle>::value, int> = 0>
+void setstate(value_and_holder &v_h, std::pair<T, O> &&result, bool need_alias) {
+    construct<Class>(v_h, std::move(result.first), need_alias);
+    auto d = handle(result.second);
+    if (PyDict_Check(d.ptr()) && PyDict_Size(d.ptr()) == 0) {
+        // Skipping setattr below, to not force use of py::dynamic_attr() for Class unnecessarily.
+        // See PR #2972 for details.
+        return;
+    }
+    // Our tests never run into an unset dict, but being careful here for now (see #5658)
+    auto dict = getattr((PyObject *) v_h.inst, "__dict__", none());
+    if (dict.is_none()) {
+        setattr((PyObject *) v_h.inst, "__dict__", d);
+    } else {
+        // Keep the original object dict and just update it
+        if (PyDict_Update(dict.ptr(), d.ptr()) < 0) {
+            throw error_already_set();
+        }
+    }
+}
+
+/// Implementation for py::pickle(GetState, SetState)
+template <typename Get,
+          typename Set,
+          typename = function_signature_t<Get>,
+          typename = function_signature_t<Set>>
+struct pickle_factory;
+
+template <typename Get,
+          typename Set,
+          typename RetState,
+          typename Self,
+          typename NewInstance,
+          typename ArgState>
+struct pickle_factory<Get, Set, RetState(Self), NewInstance(ArgState)> {
+    static_assert(std::is_same<intrinsic_t<RetState>, intrinsic_t<ArgState>>::value,
+                  "The type returned by `__getstate__` must be the same "
+                  "as the argument accepted by `__setstate__`");
+
+    remove_reference_t<Get> get;
+    remove_reference_t<Set> set;
+
+    pickle_factory(Get get, Set set) : get(std::forward<Get>(get)), set(std::forward<Set>(set)) {}
+
+    template <typename Class, typename... Extra>
+    void execute(Class &cl, const Extra &...extra) && {
+        cl.def("__getstate__", std::move(get), pos_only());
+
+#if defined(PYBIND11_CPP14)
+        cl.def(
+            "__setstate__",
+            [func = std::move(set)]
+#else
+        auto &func = set;
+        cl.def(
+            "__setstate__",
+            [func]
+#endif
+            (value_and_holder &v_h, ArgState state) {
+                setstate<Class>(
+                    v_h, func(std::forward<ArgState>(state)), Py_TYPE(v_h.inst) != v_h.type->type);
+            },
+            is_new_style_constructor(),
+            extra...);
+    }
+};
+
+PYBIND11_NAMESPACE_END(initimpl)
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/detail/internals.h b/local_pybind11/pybind11/include/pybind11/detail/internals.h
new file mode 100644
index 000000000..4ea374861
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/internals.h
@@ -0,0 +1,799 @@
+/*
+    pybind11/detail/internals.h: Internal data structure and related functions
+
+    Copyright (c) 2017 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include <pybind11/conduit/pybind11_platform_abi_id.h>
+#include <pybind11/gil_simple.h>
+#include <pybind11/pytypes.h>
+#include <pybind11/trampoline_self_life_support.h>
+
+#include "common.h"
+#include "struct_smart_holder.h"
+
+#include <atomic>
+#include <cstdint>
+#include <exception>
+#include <limits>
+#include <mutex>
+#include <thread>
+
+/// Tracks the `internals` and `type_info` ABI version independent of the main library version.
+///
+/// Some portions of the code use an ABI that is conditional depending on this
+/// version number.  That allows ABI-breaking changes to be "pre-implemented".
+/// Once the default version number is incremented, the conditional logic that
+/// no longer applies can be removed.  Additionally, users that need not
+/// maintain ABI compatibility can increase the version number in order to take
+/// advantage of any functionality/efficiency improvements that depend on the
+/// newer ABI.
+///
+/// WARNING: If you choose to manually increase the ABI version, note that
+/// pybind11 may not be tested as thoroughly with a non-default ABI version, and
+/// further ABI-incompatible changes may be made before the ABI is officially
+/// changed to the new version.
+#ifndef PYBIND11_INTERNALS_VERSION
+#    define PYBIND11_INTERNALS_VERSION 11
+#endif
+
+#if PYBIND11_INTERNALS_VERSION < 11
+#    error "PYBIND11_INTERNALS_VERSION 11 is the minimum for all platforms for pybind11v3."
+#endif
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+using ExceptionTranslator = void (*)(std::exception_ptr);
+
+// The old Python Thread Local Storage (TLS) API is deprecated in Python 3.7 in favor of the new
+// Thread Specific Storage (TSS) API.
+// Avoid unnecessary allocation of `Py_tss_t`, since we cannot use
+// `Py_LIMITED_API` anyway.
+#define PYBIND11_TLS_KEY_REF Py_tss_t &
+#if defined(__clang__)
+#    define PYBIND11_TLS_KEY_INIT(var)                                                            \
+        _Pragma("clang diagnostic push")                                         /**/             \
+            _Pragma("clang diagnostic ignored \"-Wmissing-field-initializers\"") /**/             \
+            Py_tss_t var                                                                          \
+            = Py_tss_NEEDS_INIT;                                                                  \
+        _Pragma("clang diagnostic pop")
+#elif defined(__GNUC__) && !defined(__INTEL_COMPILER)
+#    define PYBIND11_TLS_KEY_INIT(var)                                                            \
+        _Pragma("GCC diagnostic push")                                         /**/               \
+            _Pragma("GCC diagnostic ignored \"-Wmissing-field-initializers\"") /**/               \
+            Py_tss_t var                                                                          \
+            = Py_tss_NEEDS_INIT;                                                                  \
+        _Pragma("GCC diagnostic pop")
+#else
+#    define PYBIND11_TLS_KEY_INIT(var) Py_tss_t var = Py_tss_NEEDS_INIT;
+#endif
+#define PYBIND11_TLS_KEY_CREATE(var) (PyThread_tss_create(&(var)) == 0)
+#define PYBIND11_TLS_GET_VALUE(key) PyThread_tss_get(&(key))
+#define PYBIND11_TLS_REPLACE_VALUE(key, value) PyThread_tss_set(&(key), (value))
+#define PYBIND11_TLS_DELETE_VALUE(key) PyThread_tss_set(&(key), nullptr)
+#define PYBIND11_TLS_FREE(key) PyThread_tss_delete(&(key))
+
+/// A smart-pointer-like wrapper around a thread-specific value. get/set of the pointer applies to
+/// the current thread only.
+template <typename T>
+class thread_specific_storage {
+public:
+    thread_specific_storage() {
+        // NOLINTNEXTLINE(bugprone-assignment-in-if-condition)
+        if (!PYBIND11_TLS_KEY_CREATE(key_)) {
+            pybind11_fail(
+                "thread_specific_storage constructor: could not initialize the TSS key!");
+        }
+    }
+
+    ~thread_specific_storage() {
+        // This destructor is often called *after* Py_Finalize(). That *SHOULD BE* fine on most
+        // platforms. The following details what happens when PyThread_tss_free is called in
+        // CPython. PYBIND11_TLS_FREE is PyThread_tss_free on python 3.7+. On older python, it does
+        // nothing. PyThread_tss_free calls PyThread_tss_delete and PyMem_RawFree.
+        // PyThread_tss_delete just calls TlsFree (on Windows) or pthread_key_delete (on *NIX).
+        // Neither of those have anything to do with CPython internals. PyMem_RawFree *requires*
+        // that the `key` be allocated with the CPython allocator (as it is by
+        // PyThread_tss_create).
+        // However, in GraalPy (as of v24.2 or older), TSS is implemented by Java and this call
+        // requires a living Python interpreter.
+#ifdef GRAALVM_PYTHON
+        if (!Py_IsInitialized() || _Py_IsFinalizing()) {
+            return;
+        }
+#endif
+        PYBIND11_TLS_FREE(key_);
+    }
+
+    thread_specific_storage(thread_specific_storage const &) = delete;
+    thread_specific_storage(thread_specific_storage &&) = delete;
+    thread_specific_storage &operator=(thread_specific_storage const &) = delete;
+    thread_specific_storage &operator=(thread_specific_storage &&) = delete;
+
+    T *get() const { return reinterpret_cast<T *>(PYBIND11_TLS_GET_VALUE(key_)); }
+
+    T &operator*() const { return *get(); }
+    explicit operator T *() const { return get(); }
+    explicit operator bool() const { return get() != nullptr; }
+
+    void set(T *val) { PYBIND11_TLS_REPLACE_VALUE(key_, reinterpret_cast<void *>(val)); }
+    void reset(T *p = nullptr) { set(p); }
+    thread_specific_storage &operator=(T *pval) {
+        set(pval);
+        return *this;
+    }
+
+private:
+    PYBIND11_TLS_KEY_INIT(mutable key_)
+};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+// This does NOT actually exist as a module.
+#define PYBIND11_DUMMY_MODULE_NAME "pybind11_builtins"
+
+// Forward declarations
+inline PyTypeObject *make_static_property_type();
+inline PyTypeObject *make_default_metaclass();
+inline PyObject *make_object_base_type(PyTypeObject *metaclass);
+inline void translate_exception(std::exception_ptr p);
+
+// Python loads modules by default with dlopen with the RTLD_LOCAL flag; under libc++ and possibly
+// other STLs, this means `typeid(A)` from one module won't equal `typeid(A)` from another module
+// even when `A` is the same, non-hidden-visibility type (e.g. from a common include).  Under
+// libstdc++, this doesn't happen: equality and the type_index hash are based on the type name,
+// which works.  If not under a known-good stl, provide our own name-based hash and equality
+// functions that use the type name.
+#if !defined(_LIBCPP_VERSION)
+inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) { return lhs == rhs; }
+using type_hash = std::hash<std::type_index>;
+using type_equal_to = std::equal_to<std::type_index>;
+#else
+inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) {
+    return lhs.name() == rhs.name() || std::strcmp(lhs.name(), rhs.name()) == 0;
+}
+
+struct type_hash {
+    size_t operator()(const std::type_index &t) const {
+        size_t hash = 5381;
+        const char *ptr = t.name();
+        while (auto c = static_cast<unsigned char>(*ptr++)) {
+            hash = (hash * 33) ^ c;
+        }
+        return hash;
+    }
+};
+
+struct type_equal_to {
+    bool operator()(const std::type_index &lhs, const std::type_index &rhs) const {
+        return lhs.name() == rhs.name() || std::strcmp(lhs.name(), rhs.name()) == 0;
+    }
+};
+#endif
+
+template <typename value_type>
+using type_map = std::unordered_map<std::type_index, value_type, type_hash, type_equal_to>;
+
+struct override_hash {
+    inline size_t operator()(const std::pair<const PyObject *, const char *> &v) const {
+        size_t value = std::hash<const void *>()(v.first);
+        value ^= std::hash<const void *>()(v.second) + 0x9e3779b9 + (value << 6) + (value >> 2);
+        return value;
+    }
+};
+
+using instance_map = std::unordered_multimap<const void *, instance *>;
+
+#ifdef Py_GIL_DISABLED
+// Wrapper around PyMutex to provide BasicLockable semantics
+class pymutex {
+    PyMutex mutex;
+
+public:
+    pymutex() : mutex({}) {}
+    void lock() { PyMutex_Lock(&mutex); }
+    void unlock() { PyMutex_Unlock(&mutex); }
+};
+
+// Instance map shards are used to reduce mutex contention in free-threaded Python.
+struct instance_map_shard {
+    instance_map registered_instances;
+    pymutex mutex;
+    // alignas(64) would be better, but causes compile errors in macOS before 10.14 (see #5200)
+    char padding[64 - (sizeof(instance_map) + sizeof(pymutex)) % 64];
+};
+
+static_assert(sizeof(instance_map_shard) % 64 == 0,
+              "instance_map_shard size is not a multiple of 64 bytes");
+
+inline uint64_t round_up_to_next_pow2(uint64_t x) {
+    // Round-up to the next power of two.
+    // See https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+    x--;
+    x |= (x >> 1);
+    x |= (x >> 2);
+    x |= (x >> 4);
+    x |= (x >> 8);
+    x |= (x >> 16);
+    x |= (x >> 32);
+    x++;
+    return x;
+}
+#endif
+
+class loader_life_support;
+
+/// Internal data structure used to track registered instances and types.
+/// Whenever binary incompatible changes are made to this structure,
+/// `PYBIND11_INTERNALS_VERSION` must be incremented.
+struct internals {
+#ifdef Py_GIL_DISABLED
+    pymutex mutex;
+    pymutex exception_translator_mutex;
+#endif
+    // std::type_index -> pybind11's type information
+    type_map<type_info *> registered_types_cpp;
+    // PyTypeObject* -> base type_info(s)
+    std::unordered_map<PyTypeObject *, std::vector<type_info *>> registered_types_py;
+#ifdef Py_GIL_DISABLED
+    std::unique_ptr<instance_map_shard[]> instance_shards; // void * -> instance*
+    size_t instance_shards_mask = 0;
+#else
+    instance_map registered_instances; // void * -> instance*
+#endif
+    std::unordered_set<std::pair<const PyObject *, const char *>, override_hash>
+        inactive_override_cache;
+    type_map<std::vector<bool (*)(PyObject *, void *&)>> direct_conversions;
+    std::unordered_map<const PyObject *, std::vector<PyObject *>> patients;
+    std::forward_list<ExceptionTranslator> registered_exception_translators;
+    std::unordered_map<std::string, void *> shared_data; // Custom data to be shared across
+                                                         // extensions
+    std::forward_list<std::string> static_strings;       // Stores the std::strings backing
+                                                         // detail::c_str()
+    PyTypeObject *static_property_type = nullptr;
+    PyTypeObject *default_metaclass = nullptr;
+    PyObject *instance_base = nullptr;
+    // Unused if PYBIND11_SIMPLE_GIL_MANAGEMENT is defined:
+    thread_specific_storage<PyThreadState> tstate;
+    thread_specific_storage<loader_life_support> loader_life_support_tls;
+    // Unused if PYBIND11_SIMPLE_GIL_MANAGEMENT is defined:
+    PyInterpreterState *istate = nullptr;
+
+    type_map<PyObject *> native_enum_type_map;
+
+    internals()
+        : static_property_type(make_static_property_type()),
+          default_metaclass(make_default_metaclass()) {
+        PyThreadState *cur_tstate = PyThreadState_Get();
+        tstate = cur_tstate;
+
+        istate = cur_tstate->interp;
+        registered_exception_translators.push_front(&translate_exception);
+#ifdef Py_GIL_DISABLED
+        // Scale proportional to the number of cores. 2x is a heuristic to reduce contention.
+        // Make sure the number isn't unreasonable by limiting it to 16 bits (65K)
+        auto num_shards = static_cast<std::uint16_t>(
+            std::min<std::size_t>(round_up_to_next_pow2(2 * std::thread::hardware_concurrency()),
+                                  std::numeric_limits<std::uint16_t>::max()));
+        if (num_shards == 0) {
+            num_shards = 1;
+        }
+        instance_shards.reset(new instance_map_shard[num_shards]);
+        instance_shards_mask = num_shards - 1;
+#endif
+    }
+    internals(const internals &other) = delete;
+    internals(internals &&other) = delete;
+    internals &operator=(const internals &other) = delete;
+    internals &operator=(internals &&other) = delete;
+    ~internals() = default;
+};
+
+// the internals struct (above) is shared between all the modules. local_internals are only
+// for a single module. Any changes made to internals may require an update to
+// PYBIND11_INTERNALS_VERSION, breaking backwards compatibility. local_internals is, by design,
+// restricted to a single module. Whether a module has local internals or not should not
+// impact any other modules, because the only things accessing the local internals is the
+// module that contains them.
+struct local_internals {
+    type_map<type_info *> registered_types_cpp;
+    std::forward_list<ExceptionTranslator> registered_exception_translators;
+    PyTypeObject *function_record_py_type = nullptr;
+};
+
+enum class holder_enum_t : uint8_t {
+    undefined,
+    std_unique_ptr, // Default, lacking interop with std::shared_ptr.
+    std_shared_ptr, // Lacking interop with std::unique_ptr.
+    smart_holder,   // Full std::unique_ptr / std::shared_ptr interop.
+    custom_holder,
+};
+
+/// Additional type information which does not fit into the PyTypeObject.
+/// Changes to this struct also require bumping `PYBIND11_INTERNALS_VERSION`.
+struct type_info {
+    PyTypeObject *type;
+    const std::type_info *cpptype;
+    size_t type_size, type_align, holder_size_in_ptrs;
+    void *(*operator_new)(size_t);
+    void (*init_instance)(instance *, const void *);
+    void (*dealloc)(value_and_holder &v_h);
+
+    // Cross-DSO-safe function pointers, to sidestep cross-DSO RTTI issues
+    // on platforms like macOS (see PR #5728 for details):
+    memory::get_guarded_delete_fn get_memory_guarded_delete = memory::get_guarded_delete;
+    get_trampoline_self_life_support_fn get_trampoline_self_life_support = nullptr;
+
+    std::vector<PyObject *(*) (PyObject *, PyTypeObject *)> implicit_conversions;
+    std::vector<std::pair<const std::type_info *, void *(*) (void *)>> implicit_casts;
+    std::vector<bool (*)(PyObject *, void *&)> *direct_conversions;
+    buffer_info *(*get_buffer)(PyObject *, void *) = nullptr;
+    void *get_buffer_data = nullptr;
+    void *(*module_local_load)(PyObject *, const type_info *) = nullptr;
+    holder_enum_t holder_enum_v = holder_enum_t::undefined;
+    /* A simple type never occurs as a (direct or indirect) parent
+     * of a class that makes use of multiple inheritance.
+     * A type can be simple even if it has non-simple ancestors as long as it has no descendants.
+     */
+    bool simple_type : 1;
+    /* True if there is no multiple inheritance in this type's inheritance tree */
+    bool simple_ancestors : 1;
+    /* true if this is a type registered with py::module_local */
+    bool module_local : 1;
+};
+
+#define PYBIND11_INTERNALS_ID                                                                     \
+    "__pybind11_internals_v" PYBIND11_TOSTRING(PYBIND11_INTERNALS_VERSION)                        \
+        PYBIND11_COMPILER_TYPE_LEADING_UNDERSCORE PYBIND11_PLATFORM_ABI_ID "__"
+
+#define PYBIND11_MODULE_LOCAL_ID                                                                  \
+    "__pybind11_module_local_v" PYBIND11_TOSTRING(PYBIND11_INTERNALS_VERSION)                     \
+        PYBIND11_COMPILER_TYPE_LEADING_UNDERSCORE PYBIND11_PLATFORM_ABI_ID "__"
+
+inline PyThreadState *get_thread_state_unchecked() {
+#if defined(PYPY_VERSION) || defined(GRAALVM_PYTHON)
+    return PyThreadState_GET();
+#elif PY_VERSION_HEX < 0x030D0000
+    return _PyThreadState_UncheckedGet();
+#else
+    return PyThreadState_GetUnchecked();
+#endif
+}
+
+/// We use this counter to figure out if there are or have been multiple subinterpreters active at
+/// any point. This must never decrease while any interpreter may be running in any thread!
+inline std::atomic<int> &get_num_interpreters_seen() {
+    static std::atomic<int> counter(0);
+    return counter;
+}
+
+template <class T,
+          enable_if_t<std::is_same<std::nested_exception, remove_cvref_t<T>>::value, int> = 0>
+bool handle_nested_exception(const T &exc, const std::exception_ptr &p) {
+    std::exception_ptr nested = exc.nested_ptr();
+    if (nested != nullptr && nested != p) {
+        translate_exception(nested);
+        return true;
+    }
+    return false;
+}
+
+template <class T,
+          enable_if_t<!std::is_same<std::nested_exception, remove_cvref_t<T>>::value, int> = 0>
+bool handle_nested_exception(const T &exc, const std::exception_ptr &p) {
+    if (const auto *nep = dynamic_cast<const std::nested_exception *>(std::addressof(exc))) {
+        return handle_nested_exception(*nep, p);
+    }
+    return false;
+}
+
+inline bool raise_err(PyObject *exc_type, const char *msg) {
+    if (PyErr_Occurred()) {
+        raise_from(exc_type, msg);
+        return true;
+    }
+    set_error(exc_type, msg);
+    return false;
+}
+
+inline void translate_exception(std::exception_ptr p) {
+    if (!p) {
+        return;
+    }
+    try {
+        std::rethrow_exception(p);
+    } catch (error_already_set &e) {
+        handle_nested_exception(e, p);
+        e.restore();
+        return;
+    } catch (const builtin_exception &e) {
+        // Could not use template since it's an abstract class.
+        if (const auto *nep = dynamic_cast<const std::nested_exception *>(std::addressof(e))) {
+            handle_nested_exception(*nep, p);
+        }
+        e.set_error();
+        return;
+    } catch (const std::bad_alloc &e) {
+        handle_nested_exception(e, p);
+        raise_err(PyExc_MemoryError, e.what());
+        return;
+    } catch (const std::domain_error &e) {
+        handle_nested_exception(e, p);
+        raise_err(PyExc_ValueError, e.what());
+        return;
+    } catch (const std::invalid_argument &e) {
+        handle_nested_exception(e, p);
+        raise_err(PyExc_ValueError, e.what());
+        return;
+    } catch (const std::length_error &e) {
+        handle_nested_exception(e, p);
+        raise_err(PyExc_ValueError, e.what());
+        return;
+    } catch (const std::out_of_range &e) {
+        handle_nested_exception(e, p);
+        raise_err(PyExc_IndexError, e.what());
+        return;
+    } catch (const std::range_error &e) {
+        handle_nested_exception(e, p);
+        raise_err(PyExc_ValueError, e.what());
+        return;
+    } catch (const std::overflow_error &e) {
+        handle_nested_exception(e, p);
+        raise_err(PyExc_OverflowError, e.what());
+        return;
+    } catch (const std::exception &e) {
+        handle_nested_exception(e, p);
+        raise_err(PyExc_RuntimeError, e.what());
+        return;
+    } catch (const std::nested_exception &e) {
+        handle_nested_exception(e, p);
+        raise_err(PyExc_RuntimeError, "Caught an unknown nested exception!");
+        return;
+    } catch (...) {
+        raise_err(PyExc_RuntimeError, "Caught an unknown exception!");
+        return;
+    }
+}
+
+#if !defined(__GLIBCXX__)
+inline void translate_local_exception(std::exception_ptr p) {
+    try {
+        if (p) {
+            std::rethrow_exception(p);
+        }
+    } catch (error_already_set &e) {
+        e.restore();
+        return;
+    } catch (const builtin_exception &e) {
+        e.set_error();
+        return;
+    }
+}
+#endif
+
+inline object get_python_state_dict() {
+    object state_dict;
+#if defined(PYPY_VERSION) || defined(GRAALVM_PYTHON)
+    state_dict = reinterpret_borrow<object>(PyEval_GetBuiltins());
+#else
+#    if PY_VERSION_HEX < 0x03090000
+    PyInterpreterState *istate = _PyInterpreterState_Get();
+#    else
+    PyInterpreterState *istate = PyInterpreterState_Get();
+#    endif
+    if (istate) {
+        state_dict = reinterpret_borrow<object>(PyInterpreterState_GetDict(istate));
+    }
+#endif
+    if (!state_dict) {
+        raise_from(PyExc_SystemError, "pybind11::detail::get_python_state_dict() FAILED");
+        throw error_already_set();
+    }
+    return state_dict;
+}
+
+template <typename InternalsType>
+class internals_pp_manager {
+public:
+    using on_fetch_function = void(InternalsType *);
+    internals_pp_manager(char const *id, on_fetch_function *on_fetch)
+        : holder_id_(id), on_fetch_(on_fetch) {}
+
+    /// Get the current pointer-to-pointer, allocating it if it does not already exist.  May
+    /// acquire the GIL. Will never return nullptr.
+    std::unique_ptr<InternalsType> *get_pp() {
+#ifdef PYBIND11_HAS_SUBINTERPRETER_SUPPORT
+        if (get_num_interpreters_seen() > 1) {
+            // Whenever the interpreter changes on the current thread we need to invalidate the
+            // internals_pp so that it can be pulled from the interpreter's state dict.  That is
+            // slow, so we use the current PyThreadState to check if it is necessary.
+            auto *tstate = get_thread_state_unchecked();
+            if (!tstate || tstate->interp != last_istate_.get()) {
+                gil_scoped_acquire_simple gil;
+                if (!tstate) {
+                    tstate = get_thread_state_unchecked();
+                }
+                last_istate_ = tstate->interp;
+                internals_tls_p_ = get_or_create_pp_in_state_dict();
+            }
+            return internals_tls_p_.get();
+        }
+#endif
+        if (!internals_singleton_pp_) {
+            gil_scoped_acquire_simple gil;
+            internals_singleton_pp_ = get_or_create_pp_in_state_dict();
+        }
+        return internals_singleton_pp_;
+    }
+
+    /// Drop all the references we're currently holding.
+    void unref() {
+#ifdef PYBIND11_HAS_SUBINTERPRETER_SUPPORT
+        if (get_num_interpreters_seen() > 1) {
+            last_istate_.reset();
+            internals_tls_p_.reset();
+            return;
+        }
+#endif
+        internals_singleton_pp_ = nullptr;
+    }
+
+    void destroy() {
+#ifdef PYBIND11_HAS_SUBINTERPRETER_SUPPORT
+        if (get_num_interpreters_seen() > 1) {
+            auto *tstate = get_thread_state_unchecked();
+            // this could be called without an active interpreter, just use what was cached
+            if (!tstate || tstate->interp == last_istate_.get()) {
+                auto tpp = internals_tls_p_.get();
+                if (tpp) {
+                    delete tpp;
+                }
+            }
+            unref();
+            return;
+        }
+#endif
+        delete internals_singleton_pp_;
+        unref();
+    }
+
+private:
+    std::unique_ptr<InternalsType> *get_or_create_pp_in_state_dict() {
+        error_scope err_scope;
+        dict state_dict = get_python_state_dict();
+        auto internals_obj
+            = reinterpret_steal<object>(dict_getitemstringref(state_dict.ptr(), holder_id_));
+        std::unique_ptr<InternalsType> *pp = nullptr;
+        if (internals_obj) {
+            void *raw_ptr = PyCapsule_GetPointer(internals_obj.ptr(), /*name=*/nullptr);
+            if (!raw_ptr) {
+                raise_from(PyExc_SystemError,
+                           "pybind11::detail::internals_pp_manager::get_pp_from_dict() FAILED");
+                throw error_already_set();
+            }
+            pp = reinterpret_cast<std::unique_ptr<InternalsType> *>(raw_ptr);
+            if (on_fetch_ && pp) {
+                on_fetch_(pp->get());
+            }
+        } else {
+            pp = new std::unique_ptr<InternalsType>;
+            // NOLINTNEXTLINE(bugprone-casting-through-void)
+            state_dict[holder_id_] = capsule(reinterpret_cast<void *>(pp));
+        }
+        return pp;
+    }
+
+    char const *holder_id_ = nullptr;
+    on_fetch_function *on_fetch_ = nullptr;
+#ifdef PYBIND11_HAS_SUBINTERPRETER_SUPPORT
+    thread_specific_storage<PyInterpreterState> last_istate_;
+    thread_specific_storage<std::unique_ptr<InternalsType>> internals_tls_p_;
+#endif
+    std::unique_ptr<InternalsType> *internals_singleton_pp_;
+};
+
+// If We loaded the internals through `state_dict`, our `error_already_set`
+// and `builtin_exception` may be different local classes than the ones set up in the
+// initial exception translator, below, so add another for our local exception classes.
+//
+// libstdc++ doesn't require this (types there are identified only by name)
+// libc++ with CPython doesn't require this (types are explicitly exported)
+// libc++ with PyPy still need it, awaiting further investigation
+#if !defined(__GLIBCXX__)
+inline void check_internals_local_exception_translator(internals *internals_ptr) {
+    if (internals_ptr) {
+        for (auto et : internals_ptr->registered_exception_translators) {
+            if (et == &translate_local_exception) {
+                return;
+            }
+        }
+        internals_ptr->registered_exception_translators.push_front(&translate_local_exception);
+    }
+}
+#endif
+
+inline internals_pp_manager<internals> &get_internals_pp_manager() {
+#if defined(__GLIBCXX__)
+#    define ON_FETCH_FN nullptr
+#else
+#    define ON_FETCH_FN &check_internals_local_exception_translator
+#endif
+    static internals_pp_manager<internals> internals_pp_manager(PYBIND11_INTERNALS_ID,
+                                                                ON_FETCH_FN);
+#undef ON_FETCH_FN
+    return internals_pp_manager;
+}
+
+/// Return a reference to the current `internals` data
+PYBIND11_NOINLINE internals &get_internals() {
+    auto &ppmgr = get_internals_pp_manager();
+    auto &internals_ptr = *ppmgr.get_pp();
+    if (!internals_ptr) {
+        // Slow path, something needs fetched from the state dict or created
+        gil_scoped_acquire_simple gil;
+        error_scope err_scope;
+        internals_ptr.reset(new internals());
+
+        if (!internals_ptr->instance_base) {
+            // This calls get_internals, so cannot be called from within the internals constructor
+            // called above because internals_ptr must be set before get_internals is called again
+            internals_ptr->instance_base = make_object_base_type(internals_ptr->default_metaclass);
+        }
+    }
+    return *internals_ptr;
+}
+
+inline internals_pp_manager<local_internals> &get_local_internals_pp_manager() {
+    // Use the address of this static itself as part of the key, so that the value is uniquely tied
+    // to where the module is loaded in memory
+    static const std::string this_module_idstr
+        = PYBIND11_MODULE_LOCAL_ID
+          + std::to_string(reinterpret_cast<uintptr_t>(&this_module_idstr));
+    static internals_pp_manager<local_internals> local_internals_pp_manager(
+        this_module_idstr.c_str(), nullptr);
+    return local_internals_pp_manager;
+}
+
+/// Works like `get_internals`, but for things which are locally registered.
+inline local_internals &get_local_internals() {
+    auto &ppmgr = get_local_internals_pp_manager();
+    auto &internals_ptr = *ppmgr.get_pp();
+    if (!internals_ptr) {
+        internals_ptr.reset(new local_internals());
+    }
+    return *internals_ptr;
+}
+
+#ifdef Py_GIL_DISABLED
+#    define PYBIND11_LOCK_INTERNALS(internals) std::unique_lock<pymutex> lock((internals).mutex)
+#else
+#    define PYBIND11_LOCK_INTERNALS(internals)
+#endif
+
+template <typename F>
+inline auto with_internals(const F &cb) -> decltype(cb(get_internals())) {
+    auto &internals = get_internals();
+    PYBIND11_LOCK_INTERNALS(internals);
+    return cb(internals);
+}
+
+template <typename F>
+inline auto with_exception_translators(const F &cb)
+    -> decltype(cb(get_internals().registered_exception_translators,
+                   get_local_internals().registered_exception_translators)) {
+    auto &internals = get_internals();
+#ifdef Py_GIL_DISABLED
+    std::unique_lock<pymutex> lock((internals).exception_translator_mutex);
+#endif
+    auto &local_internals = get_local_internals();
+    return cb(internals.registered_exception_translators,
+              local_internals.registered_exception_translators);
+}
+
+inline std::uint64_t mix64(std::uint64_t z) {
+    // David Stafford's variant 13 of the MurmurHash3 finalizer popularized
+    // by the SplitMix PRNG.
+    // https://zimbry.blogspot.com/2011/09/better-bit-mixing-improving-on.html
+    z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
+    z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
+    return z ^ (z >> 31);
+}
+
+template <typename F>
+inline auto with_instance_map(const void *ptr, const F &cb)
+    -> decltype(cb(std::declval<instance_map &>())) {
+    auto &internals = get_internals();
+
+#ifdef Py_GIL_DISABLED
+    // Hash address to compute shard, but ignore low bits. We'd like allocations
+    // from the same thread/core to map to the same shard and allocations from
+    // other threads/cores to map to other shards. Using the high bits is a good
+    // heuristic because memory allocators often have a per-thread
+    // arena/superblock/segment from which smaller allocations are served.
+    auto addr = reinterpret_cast<std::uintptr_t>(ptr);
+    auto hash = mix64(static_cast<std::uint64_t>(addr >> 20));
+    auto idx = static_cast<size_t>(hash & internals.instance_shards_mask);
+
+    auto &shard = internals.instance_shards[idx];
+    std::unique_lock<pymutex> lock(shard.mutex);
+    return cb(shard.registered_instances);
+#else
+    (void) ptr;
+    return cb(internals.registered_instances);
+#endif
+}
+
+// Returns the number of registered instances for testing purposes.  The result may not be
+// consistent if other threads are registering or unregistering instances concurrently.
+inline size_t num_registered_instances() {
+    auto &internals = get_internals();
+#ifdef Py_GIL_DISABLED
+    size_t count = 0;
+    for (size_t i = 0; i <= internals.instance_shards_mask; ++i) {
+        auto &shard = internals.instance_shards[i];
+        std::unique_lock<pymutex> lock(shard.mutex);
+        count += shard.registered_instances.size();
+    }
+    return count;
+#else
+    return internals.registered_instances.size();
+#endif
+}
+
+/// Constructs a std::string with the given arguments, stores it in `internals`, and returns its
+/// `c_str()`.  Such strings objects have a long storage duration -- the internal strings are only
+/// cleared when the program exits or after interpreter shutdown (when embedding), and so are
+/// suitable for c-style strings needed by Python internals (such as PyTypeObject's tp_name).
+template <typename... Args>
+const char *c_str(Args &&...args) {
+    // GCC 4.8 doesn't like parameter unpack within lambda capture, so use
+    // PYBIND11_LOCK_INTERNALS.
+    auto &internals = get_internals();
+    PYBIND11_LOCK_INTERNALS(internals);
+    auto &strings = internals.static_strings;
+    strings.emplace_front(std::forward<Args>(args)...);
+    return strings.front().c_str();
+}
+
+PYBIND11_NAMESPACE_END(detail)
+
+/// Returns a named pointer that is shared among all extension modules (using the same
+/// pybind11 version) running in the current interpreter. Names starting with underscores
+/// are reserved for internal usage. Returns `nullptr` if no matching entry was found.
+PYBIND11_NOINLINE void *get_shared_data(const std::string &name) {
+    return detail::with_internals([&](detail::internals &internals) {
+        auto it = internals.shared_data.find(name);
+        return it != internals.shared_data.end() ? it->second : nullptr;
+    });
+}
+
+/// Set the shared data that can be later recovered by `get_shared_data()`.
+PYBIND11_NOINLINE void *set_shared_data(const std::string &name, void *data) {
+    return detail::with_internals([&](detail::internals &internals) {
+        internals.shared_data[name] = data;
+        return data;
+    });
+}
+
+/// Returns a typed reference to a shared data entry (by using `get_shared_data()`) if
+/// such entry exists. Otherwise, a new object of default-constructible type `T` is
+/// added to the shared data under the given name and a reference to it is returned.
+template <typename T>
+T &get_or_create_shared_data(const std::string &name) {
+    return *detail::with_internals([&](detail::internals &internals) {
+        auto it = internals.shared_data.find(name);
+        T *ptr = (T *) (it != internals.shared_data.end() ? it->second : nullptr);
+        if (!ptr) {
+            ptr = new T();
+            internals.shared_data[name] = ptr;
+        }
+        return ptr;
+    });
+}
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/detail/native_enum_data.h b/local_pybind11/pybind11/include/pybind11/detail/native_enum_data.h
new file mode 100644
index 000000000..a8f7675ba
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/native_enum_data.h
@@ -0,0 +1,209 @@
+// Copyright (c) 2022-2025 The pybind Community.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#pragma once
+
+#include "../pytypes.h"
+#include "common.h"
+#include "internals.h"
+
+#include <cassert>
+#include <sstream>
+#include <string>
+#include <typeindex>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+// This is a separate function only to enable easy unit testing.
+inline std::string
+native_enum_missing_finalize_error_message(const std::string &enum_name_encoded) {
+    return "pybind11::native_enum<...>(\"" + enum_name_encoded + "\", ...): MISSING .finalize()";
+}
+
+class native_enum_data {
+public:
+    native_enum_data(const object &parent_scope,
+                     const char *enum_name,
+                     const char *native_type_name,
+                     const char *class_doc,
+                     const std::type_index &enum_type_index)
+        : enum_name_encoded{enum_name}, native_type_name_encoded{native_type_name},
+          enum_type_index{enum_type_index}, parent_scope(parent_scope), enum_name{enum_name},
+          native_type_name{native_type_name}, class_doc(class_doc), export_values_flag{false},
+          finalize_needed{false} {}
+
+    void finalize();
+
+    native_enum_data(const native_enum_data &) = delete;
+    native_enum_data &operator=(const native_enum_data &) = delete;
+
+#if !defined(NDEBUG)
+    // This dtor cannot easily be unit tested because it terminates the process.
+    ~native_enum_data() {
+        if (finalize_needed) {
+            pybind11_fail(native_enum_missing_finalize_error_message(enum_name_encoded));
+        }
+    }
+#endif
+
+protected:
+    void disarm_finalize_check(const char *error_context) {
+        if (!finalize_needed) {
+            pybind11_fail("pybind11::native_enum<...>(\"" + enum_name_encoded
+                          + "\"): " + error_context);
+        }
+        finalize_needed = false;
+    }
+
+    void arm_finalize_check() {
+        assert(!finalize_needed); // Catch redundant calls.
+        finalize_needed = true;
+    }
+
+    std::string enum_name_encoded;
+    std::string native_type_name_encoded;
+    std::type_index enum_type_index;
+
+private:
+    object parent_scope;
+    str enum_name;
+    str native_type_name;
+    std::string class_doc;
+
+protected:
+    list members;
+    list member_docs;
+    bool export_values_flag : 1; // Attention: It is best to keep the bools together.
+
+private:
+    bool finalize_needed : 1;
+};
+
+inline void global_internals_native_enum_type_map_set_item(const std::type_index &enum_type_index,
+                                                           PyObject *py_enum) {
+    with_internals(
+        [&](internals &internals) { internals.native_enum_type_map[enum_type_index] = py_enum; });
+}
+
+inline handle
+global_internals_native_enum_type_map_get_item(const std::type_index &enum_type_index) {
+    return with_internals([&](internals &internals) {
+        auto found = internals.native_enum_type_map.find(enum_type_index);
+        if (found != internals.native_enum_type_map.end()) {
+            return handle(found->second);
+        }
+        return handle();
+    });
+}
+
+inline bool
+global_internals_native_enum_type_map_contains(const std::type_index &enum_type_index) {
+    return with_internals([&](internals &internals) {
+        return internals.native_enum_type_map.count(enum_type_index) != 0;
+    });
+}
+
+inline object import_or_getattr(const std::string &fully_qualified_name,
+                                const std::string &append_to_exception_message) {
+    std::istringstream stream(fully_qualified_name);
+    std::string part;
+
+    if (!std::getline(stream, part, '.') || part.empty()) {
+        std::string msg = "Invalid fully-qualified name `";
+        msg += fully_qualified_name;
+        msg += "`";
+        msg += append_to_exception_message;
+        throw value_error(msg);
+    }
+
+    auto curr_scope = reinterpret_steal<object>(PyImport_ImportModule(part.c_str()));
+    if (!curr_scope) {
+        std::string msg = "Failed to import top-level module `";
+        msg += part;
+        msg += "`";
+        msg += append_to_exception_message;
+        raise_from(PyExc_ImportError, msg.c_str());
+        throw error_already_set();
+    }
+
+    // Now recursively getattr or import remaining parts
+    std::string curr_path = part;
+    while (std::getline(stream, part, '.')) {
+        if (part.empty()) {
+            std::string msg = "Invalid fully-qualified name `";
+            msg += fully_qualified_name;
+            msg += "`";
+            msg += append_to_exception_message;
+            throw value_error(msg);
+        }
+        std::string next_path = curr_path;
+        next_path += ".";
+        next_path += part;
+        auto next_scope
+            = reinterpret_steal<object>(PyObject_GetAttrString(curr_scope.ptr(), part.c_str()));
+        if (!next_scope) {
+            error_fetch_and_normalize stored_getattr_error("getattr");
+            // Try importing the next level
+            next_scope = reinterpret_steal<object>(PyImport_ImportModule(next_path.c_str()));
+            if (!next_scope) {
+                error_fetch_and_normalize stored_import_error("import");
+                std::string msg = "Failed to import or getattr `";
+                msg += part;
+                msg += "` from `";
+                msg += curr_path;
+                msg += "`";
+                msg += append_to_exception_message;
+                msg += "\n-------- getattr exception --------\n";
+                msg += stored_getattr_error.error_string();
+                msg += "\n-------- import exception --------\n";
+                msg += stored_import_error.error_string();
+                throw import_error(msg.c_str());
+            }
+        }
+        curr_scope = next_scope;
+        curr_path = next_path;
+    }
+    return curr_scope;
+}
+
+inline void native_enum_data::finalize() {
+    disarm_finalize_check("DOUBLE finalize");
+    if (hasattr(parent_scope, enum_name)) {
+        pybind11_fail("pybind11::native_enum<...>(\"" + enum_name_encoded
+                      + "\"): an object with that name is already defined");
+    }
+    auto py_enum_type = import_or_getattr(native_type_name, " (native_type_name)");
+    auto py_enum = py_enum_type(enum_name, members);
+    object module_name = get_module_name_if_available(parent_scope);
+    if (module_name) {
+        py_enum.attr("__module__") = module_name;
+    }
+    if (hasattr(parent_scope, "__qualname__")) {
+        const auto parent_qualname = parent_scope.attr("__qualname__").cast<std::string>();
+        py_enum.attr("__qualname__") = str(parent_qualname + "." + enum_name.cast<std::string>());
+    }
+    parent_scope.attr(enum_name) = py_enum;
+    if (export_values_flag) {
+        for (auto member : members) {
+            auto member_name = member[int_(0)];
+            if (hasattr(parent_scope, member_name)) {
+                pybind11_fail("pybind11::native_enum<...>(\"" + enum_name_encoded + "\").value(\""
+                              + member_name.cast<std::string>()
+                              + "\"): an object with that name is already defined");
+            }
+            parent_scope.attr(member_name) = py_enum[member_name];
+        }
+    }
+    if (!class_doc.empty()) {
+        py_enum.attr("__doc__") = class_doc.c_str();
+    }
+    for (auto doc : member_docs) {
+        py_enum[doc[int_(0)]].attr("__doc__") = doc[int_(1)];
+    }
+    global_internals_native_enum_type_map_set_item(enum_type_index, py_enum.release().ptr());
+}
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/detail/pybind11_namespace_macros.h b/local_pybind11/pybind11/include/pybind11/detail/pybind11_namespace_macros.h
new file mode 100644
index 000000000..bd18c8c0a
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/pybind11_namespace_macros.h
@@ -0,0 +1,82 @@
+// Copyright (c) 2016-2025 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#pragma once
+
+// PLEASE DO NOT ADD ANY INCLUDES HERE
+
+// Define some generic pybind11 helper macros for warning management.
+//
+// Note that compiler-specific push/pop pairs are baked into the
+// PYBIND11_NAMESPACE_BEGIN/PYBIND11_NAMESPACE_END pair of macros. Therefore manual
+// PYBIND11_WARNING_PUSH/PYBIND11_WARNING_POP are usually only needed in `#include` sections.
+//
+// If you find you need to suppress a warning, please try to make the suppression as local as
+// possible using these macros. Please also be sure to push/pop with the pybind11 macros. Please
+// only use compiler specifics if you need to check specific versions, e.g. Apple Clang vs. vanilla
+// Clang.
+#if defined(_MSC_VER)
+#    define PYBIND11_COMPILER_MSVC
+#    define PYBIND11_PRAGMA(...) __pragma(__VA_ARGS__)
+#    define PYBIND11_WARNING_PUSH PYBIND11_PRAGMA(warning(push))
+#    define PYBIND11_WARNING_POP PYBIND11_PRAGMA(warning(pop))
+#elif defined(__INTEL_COMPILER)
+#    define PYBIND11_COMPILER_INTEL
+#    define PYBIND11_PRAGMA(...) _Pragma(#__VA_ARGS__)
+#    define PYBIND11_WARNING_PUSH PYBIND11_PRAGMA(warning push)
+#    define PYBIND11_WARNING_POP PYBIND11_PRAGMA(warning pop)
+#elif defined(__clang__)
+#    define PYBIND11_COMPILER_CLANG
+#    define PYBIND11_PRAGMA(...) _Pragma(#__VA_ARGS__)
+#    define PYBIND11_WARNING_PUSH PYBIND11_PRAGMA(clang diagnostic push)
+#    define PYBIND11_WARNING_POP PYBIND11_PRAGMA(clang diagnostic pop)
+#elif defined(__GNUC__)
+#    define PYBIND11_COMPILER_GCC
+#    define PYBIND11_PRAGMA(...) _Pragma(#__VA_ARGS__)
+#    define PYBIND11_WARNING_PUSH PYBIND11_PRAGMA(GCC diagnostic push)
+#    define PYBIND11_WARNING_POP PYBIND11_PRAGMA(GCC diagnostic pop)
+#endif
+
+#ifdef PYBIND11_COMPILER_MSVC
+#    define PYBIND11_WARNING_DISABLE_MSVC(name) PYBIND11_PRAGMA(warning(disable : name))
+#else
+#    define PYBIND11_WARNING_DISABLE_MSVC(name)
+#endif
+
+#ifdef PYBIND11_COMPILER_CLANG
+#    define PYBIND11_WARNING_DISABLE_CLANG(name) PYBIND11_PRAGMA(clang diagnostic ignored name)
+#else
+#    define PYBIND11_WARNING_DISABLE_CLANG(name)
+#endif
+
+#ifdef PYBIND11_COMPILER_GCC
+#    define PYBIND11_WARNING_DISABLE_GCC(name) PYBIND11_PRAGMA(GCC diagnostic ignored name)
+#else
+#    define PYBIND11_WARNING_DISABLE_GCC(name)
+#endif
+
+#ifdef PYBIND11_COMPILER_INTEL
+#    define PYBIND11_WARNING_DISABLE_INTEL(name) PYBIND11_PRAGMA(warning disable name)
+#else
+#    define PYBIND11_WARNING_DISABLE_INTEL(name)
+#endif
+
+#define PYBIND11_NAMESPACE_BEGIN(name)                                                            \
+    namespace name {                                                                              \
+    PYBIND11_WARNING_PUSH
+
+#define PYBIND11_NAMESPACE_END(name)                                                              \
+    PYBIND11_WARNING_POP                                                                          \
+    }
+
+// Robust support for some features and loading modules compiled against different pybind versions
+// requires forcing hidden visibility on pybind code, so we enforce this by setting the attribute
+// on the main `pybind11` namespace.
+#if !defined(PYBIND11_NAMESPACE)
+#    if defined(__GNUG__) && !defined(_WIN32)
+#        define PYBIND11_NAMESPACE pybind11 __attribute__((visibility("hidden")))
+#    else
+#        define PYBIND11_NAMESPACE pybind11
+#    endif
+#endif
diff --git a/local_pybind11/pybind11/include/pybind11/detail/struct_smart_holder.h b/local_pybind11/pybind11/include/pybind11/detail/struct_smart_holder.h
new file mode 100644
index 000000000..5b65b4a9b
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/struct_smart_holder.h
@@ -0,0 +1,378 @@
+// Copyright (c) 2020-2024 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/* Proof-of-Concept for smart pointer interoperability.
+
+High-level aspects:
+
+* Support all `unique_ptr`, `shared_ptr` interops that are feasible.
+
+* Cleanly and clearly report all interops that are infeasible.
+
+* Meant to fit into a `PyObject`, as a holder for C++ objects.
+
+* Support a system design that makes it impossible to trigger
+  C++ Undefined Behavior, especially from Python.
+
+* Support a system design with clean runtime inheritance casting. From this
+  it follows that the `smart_holder` needs to be type-erased (`void*`).
+
+* Handling of RTTI for the type-erased held pointer is NOT implemented here.
+  It is the responsibility of the caller to ensure that `static_cast<T *>`
+  is well-formed when calling `as_*` member functions. Inheritance casting
+  needs to be handled in a different layer (similar to the code organization
+  in boost/python/object/inheritance.hpp).
+
+Details:
+
+* The "root holder" chosen here is a `shared_ptr<void>` (named `vptr` in this
+  implementation). This choice is practically inevitable because `shared_ptr`
+  has only very limited support for inspecting and accessing its deleter.
+
+* If created from a raw pointer, or a `unique_ptr` without a custom deleter,
+  `vptr` always uses a custom deleter, to support `unique_ptr`-like disowning.
+  The custom deleters could be extended to included life-time management for
+  external objects (e.g. `PyObject`).
+
+* If created from an external `shared_ptr`, or a `unique_ptr` with a custom
+  deleter, including life-time management for external objects is infeasible.
+
+* By choice, the smart_holder is movable but not copyable, to keep the design
+  simple, and to guard against accidental copying overhead.
+
+* The `void_cast_raw_ptr` option is needed to make the `smart_holder` `vptr`
+  member invisible to the `shared_from_this` mechanism, in case the lifetime
+  of a `PyObject` is tied to the pointee.
+*/
+
+#pragma once
+
+#include "pybind11_namespace_macros.h"
+
+#include <cstring>
+#include <functional>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(memory)
+
+// Default fallback.
+static constexpr bool type_has_shared_from_this(...) { return false; }
+
+// This overload uses SFINAE to skip enable_shared_from_this checks when the
+// base is inaccessible (e.g. private inheritance).
+template <typename T>
+static auto type_has_shared_from_this(const T *ptr)
+    -> decltype(static_cast<const std::enable_shared_from_this<T> *>(ptr), true) {
+    return true;
+}
+
+// Inaccessible base → substitution failure → fallback overload selected
+template <typename T>
+static constexpr bool type_has_shared_from_this(const void *) {
+    return false;
+}
+
+struct guarded_delete {
+    // NOTE: PYBIND11_INTERNALS_VERSION needs to be bumped if changes are made to this struct.
+    std::weak_ptr<void> released_ptr;    // Trick to keep the smart_holder memory footprint small.
+    std::function<void(void *)> del_fun; // Rare case.
+    void (*del_ptr)(void *);             // Common case.
+    bool use_del_fun;
+    bool armed_flag;
+    guarded_delete(std::function<void(void *)> &&del_fun, bool armed_flag)
+        : del_fun{std::move(del_fun)}, del_ptr{nullptr}, use_del_fun{true},
+          armed_flag{armed_flag} {}
+    guarded_delete(void (*del_ptr)(void *), bool armed_flag)
+        : del_ptr{del_ptr}, use_del_fun{false}, armed_flag{armed_flag} {}
+    void operator()(void *raw_ptr) const {
+        if (armed_flag) {
+            if (use_del_fun) {
+                del_fun(raw_ptr);
+            } else {
+                del_ptr(raw_ptr);
+            }
+        }
+    }
+};
+
+inline guarded_delete *get_guarded_delete(const std::shared_ptr<void> &ptr) {
+    return std::get_deleter<guarded_delete>(ptr);
+}
+
+using get_guarded_delete_fn = guarded_delete *(*) (const std::shared_ptr<void> &);
+
+template <typename T, typename std::enable_if<std::is_destructible<T>::value, int>::type = 0>
+inline void std_default_delete_if_destructible(void *raw_ptr) {
+    std::default_delete<T>{}(static_cast<T *>(raw_ptr));
+}
+
+template <typename T, typename std::enable_if<!std::is_destructible<T>::value, int>::type = 0>
+inline void std_default_delete_if_destructible(void *) {
+    // This noop operator is needed to avoid a compilation error (for `delete raw_ptr;`), but
+    // throwing an exception from a destructor will std::terminate the process. Therefore the
+    // runtime check for lifetime-management correctness is implemented elsewhere (in
+    // ensure_pointee_is_destructible()).
+}
+
+template <typename T>
+guarded_delete make_guarded_std_default_delete(bool armed_flag) {
+    return guarded_delete(std_default_delete_if_destructible<T>, armed_flag);
+}
+
+template <typename T, typename D>
+struct custom_deleter {
+    // NOTE: PYBIND11_INTERNALS_VERSION needs to be bumped if changes are made to this struct.
+    D deleter;
+    explicit custom_deleter(D &&deleter) : deleter{std::forward<D>(deleter)} {}
+    void operator()(void *raw_ptr) { deleter(static_cast<T *>(raw_ptr)); }
+};
+
+template <typename T, typename D>
+guarded_delete make_guarded_custom_deleter(D &&uqp_del, bool armed_flag) {
+    return guarded_delete(
+        std::function<void(void *)>(custom_deleter<T, D>(std::forward<D>(uqp_del))), armed_flag);
+}
+
+template <typename T, typename D>
+constexpr bool uqp_del_is_std_default_delete() {
+    return std::is_same<D, std::default_delete<T>>::value
+           || std::is_same<D, std::default_delete<T const>>::value;
+}
+
+inline bool type_info_equal_across_dso_boundaries(const std::type_info &a,
+                                                  const std::type_info &b) {
+    // RTTI pointer comparison may fail across DSOs (e.g., macOS libc++).
+    // Fallback to name comparison, which is generally safe and ABI-stable enough for our use.
+    return a == b || std::strcmp(a.name(), b.name()) == 0;
+}
+
+struct smart_holder {
+    // NOTE: PYBIND11_INTERNALS_VERSION needs to be bumped if changes are made to this struct.
+    const std::type_info *rtti_uqp_del = nullptr;
+    std::shared_ptr<void> vptr;
+    bool vptr_is_using_noop_deleter : 1;
+    bool vptr_is_using_std_default_delete : 1;
+    bool vptr_is_external_shared_ptr : 1;
+    bool is_populated : 1;
+    bool is_disowned : 1;
+
+    // Design choice: smart_holder is movable but not copyable.
+    smart_holder(smart_holder &&) = default;
+    smart_holder(const smart_holder &) = delete;
+    smart_holder &operator=(smart_holder &&) = delete;
+    smart_holder &operator=(const smart_holder &) = delete;
+
+    smart_holder()
+        : vptr_is_using_noop_deleter{false}, vptr_is_using_std_default_delete{false},
+          vptr_is_external_shared_ptr{false}, is_populated{false}, is_disowned{false} {}
+
+    bool has_pointee() const { return vptr != nullptr; }
+
+    template <typename T>
+    static void ensure_pointee_is_destructible(const char *context) {
+        if (!std::is_destructible<T>::value) {
+            throw std::invalid_argument(std::string("Pointee is not destructible (") + context
+                                        + ").");
+        }
+    }
+
+    void ensure_is_populated(const char *context) const {
+        if (!is_populated) {
+            throw std::runtime_error(std::string("Unpopulated holder (") + context + ").");
+        }
+    }
+    void ensure_is_not_disowned(const char *context) const {
+        if (is_disowned) {
+            throw std::runtime_error(std::string("Holder was disowned already (") + context
+                                     + ").");
+        }
+    }
+
+    void ensure_vptr_is_using_std_default_delete(const char *context) const {
+        if (vptr_is_external_shared_ptr) {
+            throw std::invalid_argument(std::string("Cannot disown external shared_ptr (")
+                                        + context + ").");
+        }
+        if (vptr_is_using_noop_deleter) {
+            throw std::invalid_argument(std::string("Cannot disown non-owning holder (") + context
+                                        + ").");
+        }
+        if (!vptr_is_using_std_default_delete) {
+            throw std::invalid_argument(std::string("Cannot disown custom deleter (") + context
+                                        + ").");
+        }
+    }
+
+    template <typename T, typename D>
+    void ensure_compatible_uqp_del(const char *context) const {
+        if (!rtti_uqp_del) {
+            if (!uqp_del_is_std_default_delete<T, D>()) {
+                throw std::invalid_argument(std::string("Missing unique_ptr deleter (") + context
+                                            + ").");
+            }
+            ensure_vptr_is_using_std_default_delete(context);
+            return;
+        }
+        if (uqp_del_is_std_default_delete<T, D>() && vptr_is_using_std_default_delete) {
+            return;
+        }
+        if (!type_info_equal_across_dso_boundaries(typeid(D), *rtti_uqp_del)) {
+            throw std::invalid_argument(std::string("Incompatible unique_ptr deleter (") + context
+                                        + ").");
+        }
+    }
+
+    void ensure_has_pointee(const char *context) const {
+        if (!has_pointee()) {
+            throw std::invalid_argument(std::string("Disowned holder (") + context + ").");
+        }
+    }
+
+    void ensure_use_count_1(const char *context) const {
+        if (vptr == nullptr) {
+            throw std::invalid_argument(std::string("Cannot disown nullptr (") + context + ").");
+        }
+        // In multithreaded environments accessing use_count can lead to
+        // race conditions, but in the context of Python it is a bug (elsewhere)
+        // if the Global Interpreter Lock (GIL) is not being held when this code
+        // is reached.
+        // PYBIND11:REMINDER: This may need to be protected by a mutex in free-threaded Python.
+        if (vptr.use_count() != 1) {
+            throw std::invalid_argument(std::string("Cannot disown use_count != 1 (") + context
+                                        + ").");
+        }
+    }
+
+    void reset_vptr_deleter_armed_flag(const get_guarded_delete_fn ggd_fn, bool armed_flag) const {
+        auto *gd = ggd_fn(vptr);
+        if (gd == nullptr) {
+            throw std::runtime_error(
+                "smart_holder::reset_vptr_deleter_armed_flag() called in an invalid context.");
+        }
+        gd->armed_flag = armed_flag;
+    }
+
+    // Caller is responsible for precondition: ensure_compatible_uqp_del<T, D>() must succeed.
+    template <typename T, typename D>
+    std::unique_ptr<D> extract_deleter(const char *context,
+                                       const get_guarded_delete_fn ggd_fn) const {
+        auto *gd = ggd_fn(vptr);
+        if (gd && gd->use_del_fun) {
+            const auto &custom_deleter_ptr = gd->del_fun.template target<custom_deleter<T, D>>();
+            if (custom_deleter_ptr == nullptr) {
+                throw std::runtime_error(
+                    std::string("smart_holder::extract_deleter() precondition failure (") + context
+                    + ").");
+            }
+            static_assert(std::is_copy_constructible<D>::value,
+                          "Required for compatibility with smart_holder functionality.");
+            return std::unique_ptr<D>(new D(custom_deleter_ptr->deleter));
+        }
+        return nullptr;
+    }
+
+    static smart_holder from_raw_ptr_unowned(void *raw_ptr) {
+        smart_holder hld;
+        hld.vptr.reset(raw_ptr, [](void *) {});
+        hld.vptr_is_using_noop_deleter = true;
+        hld.is_populated = true;
+        return hld;
+    }
+
+    template <typename T>
+    T *as_raw_ptr_unowned() const {
+        return static_cast<T *>(vptr.get());
+    }
+
+    template <typename T>
+    static smart_holder from_raw_ptr_take_ownership(T *raw_ptr, bool void_cast_raw_ptr = false) {
+        ensure_pointee_is_destructible<T>("from_raw_ptr_take_ownership");
+        smart_holder hld;
+        auto gd = make_guarded_std_default_delete<T>(true);
+        if (void_cast_raw_ptr) {
+            hld.vptr.reset(static_cast<void *>(raw_ptr), std::move(gd));
+        } else {
+            hld.vptr.reset(raw_ptr, std::move(gd));
+        }
+        hld.vptr_is_using_std_default_delete = true;
+        hld.is_populated = true;
+        return hld;
+    }
+
+    // Caller is responsible for ensuring the complex preconditions
+    // (see `smart_holder_type_caster_support::load_helper`).
+    void disown(const get_guarded_delete_fn ggd_fn) {
+        reset_vptr_deleter_armed_flag(ggd_fn, false);
+        is_disowned = true;
+    }
+
+    // Caller is responsible for ensuring the complex preconditions
+    // (see `smart_holder_type_caster_support::load_helper`).
+    void reclaim_disowned(const get_guarded_delete_fn ggd_fn) {
+        reset_vptr_deleter_armed_flag(ggd_fn, true);
+        is_disowned = false;
+    }
+
+    // Caller is responsible for ensuring the complex preconditions
+    // (see `smart_holder_type_caster_support::load_helper`).
+    void release_disowned() { vptr.reset(); }
+
+    void ensure_can_release_ownership(const char *context = "ensure_can_release_ownership") const {
+        ensure_is_not_disowned(context);
+        ensure_vptr_is_using_std_default_delete(context);
+        ensure_use_count_1(context);
+    }
+
+    // Caller is responsible for ensuring the complex preconditions
+    // (see `smart_holder_type_caster_support::load_helper`).
+    void release_ownership(const get_guarded_delete_fn ggd_fn) {
+        reset_vptr_deleter_armed_flag(ggd_fn, false);
+        release_disowned();
+    }
+
+    template <typename T, typename D>
+    static smart_holder from_unique_ptr(std::unique_ptr<T, D> &&unq_ptr,
+                                        void *void_ptr = nullptr) {
+        smart_holder hld;
+        hld.rtti_uqp_del = &typeid(D);
+        hld.vptr_is_using_std_default_delete = uqp_del_is_std_default_delete<T, D>();
+        guarded_delete gd{nullptr, false};
+        if (hld.vptr_is_using_std_default_delete) {
+            gd = make_guarded_std_default_delete<T>(true);
+        } else {
+            gd = make_guarded_custom_deleter<T, D>(std::move(unq_ptr.get_deleter()), true);
+        }
+        if (void_ptr != nullptr) {
+            hld.vptr.reset(void_ptr, std::move(gd));
+        } else {
+            hld.vptr.reset(unq_ptr.get(), std::move(gd));
+        }
+        (void) unq_ptr.release();
+        hld.is_populated = true;
+        return hld;
+    }
+
+    template <typename T>
+    static smart_holder from_shared_ptr(const std::shared_ptr<T> &shd_ptr) {
+        smart_holder hld;
+        hld.vptr = std::static_pointer_cast<void>(shd_ptr);
+        hld.vptr_is_external_shared_ptr = true;
+        hld.is_populated = true;
+        return hld;
+    }
+
+    template <typename T>
+    std::shared_ptr<T> as_shared_ptr() const {
+        return std::static_pointer_cast<T>(vptr);
+    }
+};
+
+PYBIND11_NAMESPACE_END(memory)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/detail/type_caster_base.h b/local_pybind11/pybind11/include/pybind11/detail/type_caster_base.h
new file mode 100644
index 000000000..1b23c5c68
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/type_caster_base.h
@@ -0,0 +1,1591 @@
+/*
+    pybind11/detail/type_caster_base.h (originally first part of pybind11/cast.h)
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include <pybind11/gil.h>
+#include <pybind11/pytypes.h>
+#include <pybind11/trampoline_self_life_support.h>
+
+#include "common.h"
+#include "cpp_conduit.h"
+#include "descr.h"
+#include "dynamic_raw_ptr_cast_if_possible.h"
+#include "internals.h"
+#include "typeid.h"
+#include "using_smart_holder.h"
+#include "value_and_holder.h"
+
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+#include <new>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <typeindex>
+#include <typeinfo>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+/// A life support system for temporary objects created by `type_caster::load()`.
+/// Adding a patient will keep it alive up until the enclosing function returns.
+class loader_life_support {
+private:
+    loader_life_support *parent = nullptr;
+    std::unordered_set<PyObject *> keep_alive;
+
+public:
+    /// A new patient frame is created when a function is entered
+    loader_life_support() {
+        auto &stack_top = get_internals().loader_life_support_tls;
+        parent = stack_top.get();
+        stack_top = this;
+    }
+
+    /// ... and destroyed after it returns
+    ~loader_life_support() {
+        auto &stack_top = get_internals().loader_life_support_tls;
+        if (stack_top.get() != this) {
+            pybind11_fail("loader_life_support: internal error");
+        }
+        stack_top = parent;
+        for (auto *item : keep_alive) {
+            Py_DECREF(item);
+        }
+    }
+
+    /// This can only be used inside a pybind11-bound function, either by `argument_loader`
+    /// at argument preparation time or by `py::cast()` at execution time.
+    PYBIND11_NOINLINE static void add_patient(handle h) {
+        loader_life_support *frame = get_internals().loader_life_support_tls.get();
+        if (!frame) {
+            // NOTE: It would be nice to include the stack frames here, as this indicates
+            // use of pybind11::cast<> outside the normal call framework, finding such
+            // a location is challenging. Developers could consider printing out
+            // stack frame addresses here using something like __builtin_frame_address(0)
+            throw cast_error("When called outside a bound function, py::cast() cannot "
+                             "do Python -> C++ conversions which require the creation "
+                             "of temporary values");
+        }
+
+        if (frame->keep_alive.insert(h.ptr()).second) {
+            Py_INCREF(h.ptr());
+        }
+    }
+};
+
+// Gets the cache entry for the given type, creating it if necessary.  The return value is the pair
+// returned by emplace, i.e. an iterator for the entry and a bool set to `true` if the entry was
+// just created.
+inline std::pair<decltype(internals::registered_types_py)::iterator, bool>
+all_type_info_get_cache(PyTypeObject *type);
+
+// Band-aid workaround to fix a subtle but serious bug in a minimalistic fashion. See PR #4762.
+inline void all_type_info_add_base_most_derived_first(std::vector<type_info *> &bases,
+                                                      type_info *addl_base) {
+    for (auto it = bases.begin(); it != bases.end(); it++) {
+        type_info *existing_base = *it;
+        if (PyType_IsSubtype(addl_base->type, existing_base->type) != 0) {
+            bases.insert(it, addl_base);
+            return;
+        }
+    }
+    bases.push_back(addl_base);
+}
+
+// Populates a just-created cache entry.
+PYBIND11_NOINLINE void all_type_info_populate(PyTypeObject *t, std::vector<type_info *> &bases) {
+    assert(bases.empty());
+    std::vector<PyTypeObject *> check;
+    for (handle parent : reinterpret_borrow<tuple>(t->tp_bases)) {
+        check.push_back((PyTypeObject *) parent.ptr());
+    }
+    auto const &type_dict = get_internals().registered_types_py;
+    for (size_t i = 0; i < check.size(); i++) {
+        auto *type = check[i];
+        // Ignore Python2 old-style class super type:
+        if (!PyType_Check((PyObject *) type)) {
+            continue;
+        }
+
+        // Check `type` in the current set of registered python types:
+        auto it = type_dict.find(type);
+        if (it != type_dict.end()) {
+            // We found a cache entry for it, so it's either pybind-registered or has pre-computed
+            // pybind bases, but we have to make sure we haven't already seen the type(s) before:
+            // we want to follow Python/virtual C++ rules that there should only be one instance of
+            // a common base.
+            for (auto *tinfo : it->second) {
+                // NB: Could use a second set here, rather than doing a linear search, but since
+                // having a large number of immediate pybind11-registered types seems fairly
+                // unlikely, that probably isn't worthwhile.
+                bool found = false;
+                for (auto *known : bases) {
+                    if (known == tinfo) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    all_type_info_add_base_most_derived_first(bases, tinfo);
+                }
+            }
+        } else if (type->tp_bases) {
+            // It's some python type, so keep follow its bases classes to look for one or more
+            // registered types
+            if (i + 1 == check.size()) {
+                // When we're at the end, we can pop off the current element to avoid growing
+                // `check` when adding just one base (which is typical--i.e. when there is no
+                // multiple inheritance)
+                check.pop_back();
+                i--;
+            }
+            for (handle parent : reinterpret_borrow<tuple>(type->tp_bases)) {
+                check.push_back((PyTypeObject *) parent.ptr());
+            }
+        }
+    }
+}
+
+/**
+ * Extracts vector of type_info pointers of pybind-registered roots of the given Python type.  Will
+ * be just 1 pybind type for the Python type of a pybind-registered class, or for any Python-side
+ * derived class that uses single inheritance.  Will contain as many types as required for a Python
+ * class that uses multiple inheritance to inherit (directly or indirectly) from multiple
+ * pybind-registered classes.  Will be empty if neither the type nor any base classes are
+ * pybind-registered.
+ *
+ * The value is cached for the lifetime of the Python type.
+ */
+inline const std::vector<detail::type_info *> &all_type_info(PyTypeObject *type) {
+    return all_type_info_get_cache(type).first->second;
+}
+
+/**
+ * Gets a single pybind11 type info for a python type.  Returns nullptr if neither the type nor any
+ * ancestors are pybind11-registered.  Throws an exception if there are multiple bases--use
+ * `all_type_info` instead if you want to support multiple bases.
+ */
+PYBIND11_NOINLINE detail::type_info *get_type_info(PyTypeObject *type) {
+    const auto &bases = all_type_info(type);
+    if (bases.empty()) {
+        return nullptr;
+    }
+    if (bases.size() > 1) {
+        pybind11_fail(
+            "pybind11::detail::get_type_info: type has multiple pybind11-registered bases");
+    }
+    return bases.front();
+}
+
+inline detail::type_info *get_local_type_info(const std::type_index &tp) {
+    auto &locals = get_local_internals().registered_types_cpp;
+    auto it = locals.find(tp);
+    if (it != locals.end()) {
+        return it->second;
+    }
+    return nullptr;
+}
+
+inline detail::type_info *get_global_type_info(const std::type_index &tp) {
+    return with_internals([&](internals &internals) {
+        detail::type_info *type_info = nullptr;
+        auto &types = internals.registered_types_cpp;
+        auto it = types.find(tp);
+        if (it != types.end()) {
+            type_info = it->second;
+        }
+        return type_info;
+    });
+}
+
+/// Return the type info for a given C++ type; on lookup failure can either throw or return
+/// nullptr.
+PYBIND11_NOINLINE detail::type_info *get_type_info(const std::type_index &tp,
+                                                   bool throw_if_missing = false) {
+    if (auto *ltype = get_local_type_info(tp)) {
+        return ltype;
+    }
+    if (auto *gtype = get_global_type_info(tp)) {
+        return gtype;
+    }
+
+    if (throw_if_missing) {
+        std::string tname = tp.name();
+        detail::clean_type_id(tname);
+        pybind11_fail("pybind11::detail::get_type_info: unable to find type info for \""
+                      + std::move(tname) + '"');
+    }
+    return nullptr;
+}
+
+PYBIND11_NOINLINE handle get_type_handle(const std::type_info &tp, bool throw_if_missing) {
+    detail::type_info *type_info = get_type_info(tp, throw_if_missing);
+    return handle(type_info ? ((PyObject *) type_info->type) : nullptr);
+}
+
+inline bool try_incref(PyObject *obj) {
+    // Tries to increment the reference count of an object if it's not zero.
+    // TODO: Use PyUnstable_TryIncref when available.
+    // See https://github.com/python/cpython/issues/128844
+#ifdef Py_GIL_DISABLED
+    // See
+    // https://github.com/python/cpython/blob/d05140f9f77d7dfc753dd1e5ac3a5962aaa03eff/Include/internal/pycore_object.h#L761
+    uint32_t local = _Py_atomic_load_uint32_relaxed(&obj->ob_ref_local);
+    local += 1;
+    if (local == 0) {
+        // immortal
+        return true;
+    }
+    if (_Py_IsOwnedByCurrentThread(obj)) {
+        _Py_atomic_store_uint32_relaxed(&obj->ob_ref_local, local);
+#    ifdef Py_REF_DEBUG
+        _Py_INCREF_IncRefTotal();
+#    endif
+        return true;
+    }
+    Py_ssize_t shared = _Py_atomic_load_ssize_relaxed(&obj->ob_ref_shared);
+    for (;;) {
+        // If the shared refcount is zero and the object is either merged
+        // or may not have weak references, then we cannot incref it.
+        if (shared == 0 || shared == _Py_REF_MERGED) {
+            return false;
+        }
+
+        if (_Py_atomic_compare_exchange_ssize(
+                &obj->ob_ref_shared, &shared, shared + (1 << _Py_REF_SHARED_SHIFT))) {
+#    ifdef Py_REF_DEBUG
+            _Py_INCREF_IncRefTotal();
+#    endif
+            return true;
+        }
+    }
+#else
+    assert(Py_REFCNT(obj) > 0);
+    Py_INCREF(obj);
+    return true;
+#endif
+}
+
+// Searches the inheritance graph for a registered Python instance, using all_type_info().
+PYBIND11_NOINLINE handle find_registered_python_instance(void *src,
+                                                         const detail::type_info *tinfo) {
+    return with_instance_map(src, [&](instance_map &instances) {
+        auto it_instances = instances.equal_range(src);
+        for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
+            for (auto *instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
+                if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype)) {
+                    auto *wrapper = reinterpret_cast<PyObject *>(it_i->second);
+                    if (try_incref(wrapper)) {
+                        return handle(wrapper);
+                    }
+                }
+            }
+        }
+        return handle();
+    });
+}
+
+// Container for accessing and iterating over an instance's values/holders
+struct values_and_holders {
+private:
+    instance *inst;
+    using type_vec = std::vector<detail::type_info *>;
+    const type_vec &tinfo;
+
+public:
+    explicit values_and_holders(instance *inst)
+        : inst{inst}, tinfo(all_type_info(Py_TYPE(inst))) {}
+
+    explicit values_and_holders(PyObject *obj)
+        : inst{nullptr}, tinfo(all_type_info(Py_TYPE(obj))) {
+        if (!tinfo.empty()) {
+            inst = reinterpret_cast<instance *>(obj);
+        }
+    }
+
+    struct iterator {
+    private:
+        instance *inst = nullptr;
+        const type_vec *types = nullptr;
+        value_and_holder curr;
+        friend struct values_and_holders;
+        iterator(instance *inst, const type_vec *tinfo) : inst{inst}, types{tinfo} {
+            if (inst != nullptr) {
+                assert(!types->empty());
+                curr = value_and_holder(
+                    inst /* instance */,
+                    (*types)[0] /* type info */,
+                    0, /* vpos: (non-simple types only): the first vptr comes first */
+                    0 /* index */);
+            }
+        }
+        // Past-the-end iterator:
+        explicit iterator(size_t end) : curr(end) {}
+
+    public:
+        bool operator==(const iterator &other) const { return curr.index == other.curr.index; }
+        bool operator!=(const iterator &other) const { return curr.index != other.curr.index; }
+        iterator &operator++() {
+            if (!inst->simple_layout) {
+                curr.vh += 1 + (*types)[curr.index]->holder_size_in_ptrs;
+            }
+            ++curr.index;
+            curr.type = curr.index < types->size() ? (*types)[curr.index] : nullptr;
+            return *this;
+        }
+        value_and_holder &operator*() { return curr; }
+        value_and_holder *operator->() { return &curr; }
+    };
+
+    iterator begin() { return iterator(inst, &tinfo); }
+    iterator end() { return iterator(tinfo.size()); }
+
+    iterator find(const type_info *find_type) {
+        auto it = begin(), endit = end();
+        while (it != endit && it->type != find_type) {
+            ++it;
+        }
+        return it;
+    }
+
+    size_t size() { return tinfo.size(); }
+
+    // Band-aid workaround to fix a subtle but serious bug in a minimalistic fashion. See PR #4762.
+    bool is_redundant_value_and_holder(const value_and_holder &vh) {
+        for (size_t i = 0; i < vh.index; i++) {
+            if (PyType_IsSubtype(tinfo[i]->type, tinfo[vh.index]->type) != 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+};
+
+/**
+ * Extracts C++ value and holder pointer references from an instance (which may contain multiple
+ * values/holders for python-side multiple inheritance) that match the given type.  Throws an error
+ * if the given type (or ValueType, if omitted) is not a pybind11 base of the given instance.  If
+ * `find_type` is omitted (or explicitly specified as nullptr) the first value/holder are returned,
+ * regardless of type (and the resulting .type will be nullptr).
+ *
+ * The returned object should be short-lived: in particular, it must not outlive the called-upon
+ * instance.
+ */
+PYBIND11_NOINLINE value_and_holder
+instance::get_value_and_holder(const type_info *find_type /*= nullptr default in common.h*/,
+                               bool throw_if_missing /*= true in common.h*/) {
+    // Optimize common case:
+    if (!find_type || Py_TYPE(this) == find_type->type) {
+        return value_and_holder(this, find_type, 0, 0);
+    }
+
+    detail::values_and_holders vhs(this);
+    auto it = vhs.find(find_type);
+    if (it != vhs.end()) {
+        return *it;
+    }
+
+    if (!throw_if_missing) {
+        return value_and_holder();
+    }
+
+#if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+    pybind11_fail("pybind11::detail::instance::get_value_and_holder: `"
+                  + get_fully_qualified_tp_name(find_type->type)
+                  + "' is not a pybind11 base of the given `"
+                  + get_fully_qualified_tp_name(Py_TYPE(this)) + "' instance");
+#else
+    pybind11_fail(
+        "pybind11::detail::instance::get_value_and_holder: "
+        "type is not a pybind11 base of the given instance "
+        "(#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for type details)");
+#endif
+}
+
+PYBIND11_NOINLINE void instance::allocate_layout() {
+    const auto &tinfo = all_type_info(Py_TYPE(this));
+
+    const size_t n_types = tinfo.size();
+
+    if (n_types == 0) {
+        pybind11_fail(
+            "instance allocation failed: new instance has no pybind11-registered base types");
+    }
+
+    simple_layout
+        = n_types == 1 && tinfo.front()->holder_size_in_ptrs <= instance_simple_holder_in_ptrs();
+
+    // Simple path: no python-side multiple inheritance, and a small-enough holder
+    if (simple_layout) {
+        simple_value_holder[0] = nullptr;
+        simple_holder_constructed = false;
+        simple_instance_registered = false;
+    } else { // multiple base types or a too-large holder
+        // Allocate space to hold: [v1*][h1][v2*][h2]...[bb...] where [vN*] is a value pointer,
+        // [hN] is the (uninitialized) holder instance for value N, and [bb...] is a set of bool
+        // values that tracks whether each associated holder has been initialized.  Each [block] is
+        // padded, if necessary, to an integer multiple of sizeof(void *).
+        size_t space = 0;
+        for (auto *t : tinfo) {
+            space += 1;                      // value pointer
+            space += t->holder_size_in_ptrs; // holder instance
+        }
+        size_t flags_at = space;
+        space += size_in_ptrs(n_types); // status bytes (holder_constructed and
+                                        // instance_registered)
+
+        // Allocate space for flags, values, and holders, and initialize it to 0 (flags and values,
+        // in particular, need to be 0).  Use Python's memory allocation
+        // functions: Python is using pymalloc, which is designed to be
+        // efficient for small allocations like the one we're doing here;
+        // for larger allocations they are just wrappers around malloc.
+        // TODO: is this still true for pure Python 3.6?
+        nonsimple.values_and_holders = (void **) PyMem_Calloc(space, sizeof(void *));
+        if (!nonsimple.values_and_holders) {
+            throw std::bad_alloc();
+        }
+        nonsimple.status
+            = reinterpret_cast<std::uint8_t *>(&nonsimple.values_and_holders[flags_at]);
+    }
+    owned = true;
+}
+
+// NOLINTNEXTLINE(readability-make-member-function-const)
+PYBIND11_NOINLINE void instance::deallocate_layout() {
+    if (!simple_layout) {
+        PyMem_Free(reinterpret_cast<void *>(nonsimple.values_and_holders));
+    }
+}
+
+PYBIND11_NOINLINE bool isinstance_generic(handle obj, const std::type_info &tp) {
+    handle type = detail::get_type_handle(tp, false);
+    if (!type) {
+        return false;
+    }
+    return isinstance(obj, type);
+}
+
+PYBIND11_NOINLINE handle get_object_handle(const void *ptr, const detail::type_info *type) {
+    return with_instance_map(ptr, [&](instance_map &instances) {
+        auto range = instances.equal_range(ptr);
+        for (auto it = range.first; it != range.second; ++it) {
+            for (const auto &vh : values_and_holders(it->second)) {
+                if (vh.type == type) {
+                    return handle((PyObject *) it->second);
+                }
+            }
+        }
+        return handle();
+    });
+}
+
+// Forward declarations
+void keep_alive_impl(handle nurse, handle patient);
+inline PyObject *make_new_instance(PyTypeObject *type);
+
+PYBIND11_WARNING_PUSH
+PYBIND11_WARNING_DISABLE_GCC("-Wredundant-decls")
+
+// PYBIND11:REMINDER: Needs refactoring of existing pybind11 code.
+inline bool deregister_instance(instance *self, void *valptr, const type_info *tinfo);
+
+PYBIND11_WARNING_POP
+
+PYBIND11_NAMESPACE_BEGIN(smart_holder_type_caster_support)
+
+struct value_and_holder_helper {
+    value_and_holder loaded_v_h;
+
+    bool have_holder() const {
+        return loaded_v_h.vh != nullptr && loaded_v_h.holder_constructed();
+    }
+
+    smart_holder &holder() const { return loaded_v_h.holder<smart_holder>(); }
+
+    void throw_if_uninitialized_or_disowned_holder(const char *typeid_name) const {
+        static const std::string missing_value_msg = "Missing value for wrapped C++ type `";
+        if (!holder().is_populated) {
+            throw value_error(missing_value_msg + clean_type_id(typeid_name)
+                              + "`: Python instance is uninitialized.");
+        }
+        if (!holder().has_pointee()) {
+            throw value_error(missing_value_msg + clean_type_id(typeid_name)
+                              + "`: Python instance was disowned.");
+        }
+    }
+
+    void throw_if_uninitialized_or_disowned_holder(const std::type_info &type_info) const {
+        throw_if_uninitialized_or_disowned_holder(type_info.name());
+    }
+
+    // have_holder() must be true or this function will fail.
+    void throw_if_instance_is_currently_owned_by_shared_ptr(const type_info *tinfo) const {
+        auto *vptr_gd_ptr = tinfo->get_memory_guarded_delete(holder().vptr);
+        if (vptr_gd_ptr != nullptr && !vptr_gd_ptr->released_ptr.expired()) {
+            throw value_error("Python instance is currently owned by a std::shared_ptr.");
+        }
+    }
+
+    void *get_void_ptr_or_nullptr() const {
+        if (have_holder()) {
+            auto &hld = holder();
+            if (hld.is_populated && hld.has_pointee()) {
+                return hld.template as_raw_ptr_unowned<void>();
+            }
+        }
+        return nullptr;
+    }
+};
+
+template <typename T, typename D>
+handle smart_holder_from_unique_ptr(std::unique_ptr<T, D> &&src,
+                                    return_value_policy policy,
+                                    handle parent,
+                                    const std::pair<const void *, const type_info *> &st) {
+    if (policy == return_value_policy::copy) {
+        throw cast_error("return_value_policy::copy is invalid for unique_ptr.");
+    }
+    if (!src) {
+        return none().release();
+    }
+    void *src_raw_void_ptr = const_cast<void *>(st.first);
+    assert(st.second != nullptr);
+    const detail::type_info *tinfo = st.second;
+    if (handle existing_inst = find_registered_python_instance(src_raw_void_ptr, tinfo)) {
+        auto *self_life_support = tinfo->get_trampoline_self_life_support(src.get());
+        if (self_life_support != nullptr) {
+            value_and_holder &v_h = self_life_support->v_h;
+            if (v_h.inst != nullptr && v_h.vh != nullptr) {
+                auto &holder = v_h.holder<smart_holder>();
+                if (!holder.is_disowned) {
+                    pybind11_fail("smart_holder_from_unique_ptr: unexpected "
+                                  "smart_holder.is_disowned failure.");
+                }
+                // Critical transfer-of-ownership section. This must stay together.
+                self_life_support->deactivate_life_support();
+                holder.reclaim_disowned(tinfo->get_memory_guarded_delete);
+                (void) src.release();
+                // Critical section end.
+                return existing_inst;
+            }
+        }
+        throw cast_error("Invalid unique_ptr: another instance owns this pointer already.");
+    }
+
+    auto inst = reinterpret_steal<object>(make_new_instance(tinfo->type));
+    auto *inst_raw_ptr = reinterpret_cast<instance *>(inst.ptr());
+    inst_raw_ptr->owned = true;
+    void *&valueptr = values_and_holders(inst_raw_ptr).begin()->value_ptr();
+    valueptr = src_raw_void_ptr;
+
+    if (static_cast<void *>(src.get()) == src_raw_void_ptr) {
+        // This is a multiple-inheritance situation that is incompatible with the current
+        // shared_from_this handling (see PR #3023). Is there a better solution?
+        src_raw_void_ptr = nullptr;
+    }
+    auto smhldr = smart_holder::from_unique_ptr(std::move(src), src_raw_void_ptr);
+    tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
+
+    if (policy == return_value_policy::reference_internal) {
+        keep_alive_impl(inst, parent);
+    }
+
+    return inst.release();
+}
+
+template <typename T, typename D>
+handle smart_holder_from_unique_ptr(std::unique_ptr<T const, D> &&src,
+                                    return_value_policy policy,
+                                    handle parent,
+                                    const std::pair<const void *, const type_info *> &st) {
+    return smart_holder_from_unique_ptr(
+        std::unique_ptr<T, D>(const_cast<T *>(src.release()),
+                              std::move(src.get_deleter())), // Const2Mutbl
+        policy,
+        parent,
+        st);
+}
+
+template <typename T>
+handle smart_holder_from_shared_ptr(const std::shared_ptr<T> &src,
+                                    return_value_policy policy,
+                                    handle parent,
+                                    const std::pair<const void *, const type_info *> &st) {
+    switch (policy) {
+        case return_value_policy::automatic:
+        case return_value_policy::automatic_reference:
+            break;
+        case return_value_policy::take_ownership:
+            throw cast_error("Invalid return_value_policy for shared_ptr (take_ownership).");
+        case return_value_policy::copy:
+        case return_value_policy::move:
+            break;
+        case return_value_policy::reference:
+            throw cast_error("Invalid return_value_policy for shared_ptr (reference).");
+        case return_value_policy::reference_internal:
+            break;
+    }
+    if (!src) {
+        return none().release();
+    }
+
+    auto src_raw_ptr = src.get();
+    assert(st.second != nullptr);
+    void *src_raw_void_ptr = static_cast<void *>(src_raw_ptr);
+    const detail::type_info *tinfo = st.second;
+    if (handle existing_inst = find_registered_python_instance(src_raw_void_ptr, tinfo)) {
+        // PYBIND11:REMINDER: MISSING: Enforcement of consistency with existing smart_holder.
+        // PYBIND11:REMINDER: MISSING: keep_alive.
+        return existing_inst;
+    }
+
+    auto inst = reinterpret_steal<object>(make_new_instance(tinfo->type));
+    auto *inst_raw_ptr = reinterpret_cast<instance *>(inst.ptr());
+    inst_raw_ptr->owned = true;
+    void *&valueptr = values_and_holders(inst_raw_ptr).begin()->value_ptr();
+    valueptr = src_raw_void_ptr;
+
+    auto smhldr
+        = smart_holder::from_shared_ptr(std::shared_ptr<void>(src, const_cast<void *>(st.first)));
+    tinfo->init_instance(inst_raw_ptr, static_cast<const void *>(&smhldr));
+
+    if (policy == return_value_policy::reference_internal) {
+        keep_alive_impl(inst, parent);
+    }
+
+    return inst.release();
+}
+
+template <typename T>
+handle smart_holder_from_shared_ptr(const std::shared_ptr<T const> &src,
+                                    return_value_policy policy,
+                                    handle parent,
+                                    const std::pair<const void *, const type_info *> &st) {
+    return smart_holder_from_shared_ptr(std::const_pointer_cast<T>(src), // Const2Mutbl
+                                        policy,
+                                        parent,
+                                        st);
+}
+
+struct shared_ptr_parent_life_support {
+    PyObject *parent;
+    explicit shared_ptr_parent_life_support(PyObject *parent) : parent{parent} {
+        Py_INCREF(parent);
+    }
+    // NOLINTNEXTLINE(readability-make-member-function-const)
+    void operator()(void *) {
+        gil_scoped_acquire gil;
+        Py_DECREF(parent);
+    }
+};
+
+struct shared_ptr_trampoline_self_life_support {
+    PyObject *self;
+    explicit shared_ptr_trampoline_self_life_support(instance *inst)
+        : self{reinterpret_cast<PyObject *>(inst)} {
+        gil_scoped_acquire gil;
+        Py_INCREF(self);
+    }
+    // NOLINTNEXTLINE(readability-make-member-function-const)
+    void operator()(void *) {
+        gil_scoped_acquire gil;
+        Py_DECREF(self);
+    }
+};
+
+template <typename T,
+          typename D,
+          typename std::enable_if<std::is_default_constructible<D>::value, int>::type = 0>
+inline std::unique_ptr<T, D> unique_with_deleter(T *raw_ptr, std::unique_ptr<D> &&deleter) {
+    if (deleter == nullptr) {
+        return std::unique_ptr<T, D>(raw_ptr);
+    }
+    return std::unique_ptr<T, D>(raw_ptr, std::move(*deleter));
+}
+
+template <typename T,
+          typename D,
+          typename std::enable_if<!std::is_default_constructible<D>::value, int>::type = 0>
+inline std::unique_ptr<T, D> unique_with_deleter(T *raw_ptr, std::unique_ptr<D> &&deleter) {
+    if (deleter == nullptr) {
+        pybind11_fail("smart_holder_type_casters: deleter is not default constructible and no"
+                      " instance available to return.");
+    }
+    return std::unique_ptr<T, D>(raw_ptr, std::move(*deleter));
+}
+
+template <typename T>
+struct load_helper : value_and_holder_helper {
+    bool was_populated = false;
+    bool python_instance_is_alias = false;
+
+    void maybe_set_python_instance_is_alias(handle src) {
+        if (was_populated) {
+            python_instance_is_alias = reinterpret_cast<instance *>(src.ptr())->is_alias;
+        }
+    }
+
+    static std::shared_ptr<T> make_shared_ptr_with_responsible_parent(T *raw_ptr, handle parent) {
+        return std::shared_ptr<T>(raw_ptr, shared_ptr_parent_life_support(parent.ptr()));
+    }
+
+    std::shared_ptr<T> load_as_shared_ptr(const type_info *tinfo,
+                                          void *void_raw_ptr,
+                                          handle responsible_parent = nullptr,
+                                          // to support py::potentially_slicing_weak_ptr
+                                          // with minimal added code complexity:
+                                          bool force_potentially_slicing_shared_ptr
+                                          = false) const {
+        if (!have_holder()) {
+            return nullptr;
+        }
+        throw_if_uninitialized_or_disowned_holder(typeid(T));
+        smart_holder &hld = holder();
+        hld.ensure_is_not_disowned("load_as_shared_ptr");
+        if (hld.vptr_is_using_noop_deleter) {
+            if (responsible_parent) {
+                return make_shared_ptr_with_responsible_parent(static_cast<T *>(void_raw_ptr),
+                                                               responsible_parent);
+            }
+            throw std::runtime_error("Non-owning holder (load_as_shared_ptr).");
+        }
+        auto *type_raw_ptr = static_cast<T *>(void_raw_ptr);
+        if (python_instance_is_alias && !force_potentially_slicing_shared_ptr) {
+            auto *vptr_gd_ptr = tinfo->get_memory_guarded_delete(holder().vptr);
+            if (vptr_gd_ptr != nullptr) {
+                std::shared_ptr<void> released_ptr = vptr_gd_ptr->released_ptr.lock();
+                if (released_ptr) {
+                    return std::shared_ptr<T>(released_ptr, type_raw_ptr);
+                }
+                std::shared_ptr<T> to_be_released(
+                    type_raw_ptr, shared_ptr_trampoline_self_life_support(loaded_v_h.inst));
+                vptr_gd_ptr->released_ptr = to_be_released;
+                return to_be_released;
+            }
+            auto *sptsls_ptr = std::get_deleter<shared_ptr_trampoline_self_life_support>(hld.vptr);
+            if (sptsls_ptr != nullptr) {
+                // This code is reachable only if there are multiple registered_instances for the
+                // same pointee.
+                if (reinterpret_cast<PyObject *>(loaded_v_h.inst) == sptsls_ptr->self) {
+                    pybind11_fail("smart_holder_type_caster_support load_as_shared_ptr failure: "
+                                  "loaded_v_h.inst == sptsls_ptr->self");
+                }
+            }
+            if (sptsls_ptr != nullptr || !memory::type_has_shared_from_this(type_raw_ptr)) {
+                return std::shared_ptr<T>(
+                    type_raw_ptr, shared_ptr_trampoline_self_life_support(loaded_v_h.inst));
+            }
+            if (hld.vptr_is_external_shared_ptr) {
+                pybind11_fail("smart_holder_type_casters load_as_shared_ptr failure: not "
+                              "implemented: trampoline-self-life-support for external shared_ptr "
+                              "to type inheriting from std::enable_shared_from_this.");
+            }
+            pybind11_fail(
+                "smart_holder_type_casters: load_as_shared_ptr failure: internal inconsistency.");
+        }
+        std::shared_ptr<void> void_shd_ptr = hld.template as_shared_ptr<void>();
+        return std::shared_ptr<T>(void_shd_ptr, type_raw_ptr);
+    }
+
+    template <typename D>
+    std::unique_ptr<T, D> load_as_unique_ptr(const type_info *tinfo,
+                                             void *raw_void_ptr,
+                                             const char *context = "load_as_unique_ptr") {
+        if (!have_holder()) {
+            return unique_with_deleter<T, D>(nullptr, std::unique_ptr<D>());
+        }
+        throw_if_uninitialized_or_disowned_holder(typeid(T));
+        throw_if_instance_is_currently_owned_by_shared_ptr(tinfo);
+        holder().ensure_is_not_disowned(context);
+        holder().template ensure_compatible_uqp_del<T, D>(context);
+        holder().ensure_use_count_1(context);
+
+        T *raw_type_ptr = static_cast<T *>(raw_void_ptr);
+
+        auto *self_life_support = tinfo->get_trampoline_self_life_support(raw_type_ptr);
+        // This is enforced indirectly by a static_assert in the class_ implementation:
+        assert(!python_instance_is_alias || self_life_support);
+
+        std::unique_ptr<D> extracted_deleter
+            = holder().template extract_deleter<T, D>(context, tinfo->get_memory_guarded_delete);
+
+        // Critical transfer-of-ownership section. This must stay together.
+        if (self_life_support != nullptr) {
+            holder().disown(tinfo->get_memory_guarded_delete);
+        } else {
+            holder().release_ownership(tinfo->get_memory_guarded_delete);
+        }
+        auto result = unique_with_deleter<T, D>(raw_type_ptr, std::move(extracted_deleter));
+        if (self_life_support != nullptr) {
+            self_life_support->activate_life_support(loaded_v_h);
+        } else {
+            void *value_void_ptr = loaded_v_h.value_ptr();
+            loaded_v_h.value_ptr() = nullptr;
+            deregister_instance(loaded_v_h.inst, value_void_ptr, loaded_v_h.type);
+        }
+        // Critical section end.
+
+        return result;
+    }
+
+    // This assumes load_as_shared_ptr succeeded(), and the returned shared_ptr is still alive.
+    // The returned unique_ptr is meant to never expire (the behavior is undefined otherwise).
+    template <typename D>
+    std::unique_ptr<T, D> load_as_const_unique_ptr(const type_info *tinfo,
+                                                   T *raw_type_ptr,
+                                                   const char *context
+                                                   = "load_as_const_unique_ptr") {
+        if (!have_holder()) {
+            return unique_with_deleter<T, D>(nullptr, std::unique_ptr<D>());
+        }
+        holder().template ensure_compatible_uqp_del<T, D>(context);
+        return unique_with_deleter<T, D>(raw_type_ptr,
+                                         std::move(holder().template extract_deleter<T, D>(
+                                             context, tinfo->get_memory_guarded_delete)));
+    }
+};
+
+PYBIND11_NAMESPACE_END(smart_holder_type_caster_support)
+
+class type_caster_generic {
+public:
+    PYBIND11_NOINLINE explicit type_caster_generic(const std::type_info &type_info)
+        : typeinfo(get_type_info(type_info)), cpptype(&type_info) {}
+
+    explicit type_caster_generic(const type_info *typeinfo)
+        : typeinfo(typeinfo), cpptype(typeinfo ? typeinfo->cpptype : nullptr) {}
+
+    bool load(handle src, bool convert) { return load_impl<type_caster_generic>(src, convert); }
+
+    PYBIND11_NOINLINE static handle cast(const void *_src,
+                                         return_value_policy policy,
+                                         handle parent,
+                                         const detail::type_info *tinfo,
+                                         void *(*copy_constructor)(const void *),
+                                         void *(*move_constructor)(const void *),
+                                         const void *existing_holder = nullptr) {
+        if (!tinfo) { // no type info: error will be set already
+            return handle();
+        }
+
+        void *src = const_cast<void *>(_src);
+        if (src == nullptr) {
+            return none().release();
+        }
+
+        if (handle registered_inst = find_registered_python_instance(src, tinfo)) {
+            return registered_inst;
+        }
+
+        auto inst = reinterpret_steal<object>(make_new_instance(tinfo->type));
+        auto *wrapper = reinterpret_cast<instance *>(inst.ptr());
+        wrapper->owned = false;
+        void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();
+
+        switch (policy) {
+            case return_value_policy::automatic:
+            case return_value_policy::take_ownership:
+                valueptr = src;
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::automatic_reference:
+            case return_value_policy::reference:
+                valueptr = src;
+                wrapper->owned = false;
+                break;
+
+            case return_value_policy::copy:
+                if (copy_constructor) {
+                    valueptr = copy_constructor(src);
+                } else {
+#if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+                    std::string type_name(tinfo->cpptype->name());
+                    detail::clean_type_id(type_name);
+                    throw cast_error("return_value_policy = copy, but type " + type_name
+                                     + " is non-copyable!");
+#else
+                    throw cast_error("return_value_policy = copy, but type is "
+                                     "non-copyable! (#define PYBIND11_DETAILED_ERROR_MESSAGES or "
+                                     "compile in debug mode for details)");
+#endif
+                }
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::move:
+                if (move_constructor) {
+                    valueptr = move_constructor(src);
+                } else if (copy_constructor) {
+                    valueptr = copy_constructor(src);
+                } else {
+#if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+                    std::string type_name(tinfo->cpptype->name());
+                    detail::clean_type_id(type_name);
+                    throw cast_error("return_value_policy = move, but type " + type_name
+                                     + " is neither movable nor copyable!");
+#else
+                    throw cast_error("return_value_policy = move, but type is neither "
+                                     "movable nor copyable! "
+                                     "(#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in "
+                                     "debug mode for details)");
+#endif
+                }
+                wrapper->owned = true;
+                break;
+
+            case return_value_policy::reference_internal:
+                valueptr = src;
+                wrapper->owned = false;
+                keep_alive_impl(inst, parent);
+                break;
+
+            default:
+                throw cast_error("unhandled return_value_policy: should not happen!");
+        }
+
+        tinfo->init_instance(wrapper, existing_holder);
+
+        return inst.release();
+    }
+
+    // Base methods for generic caster; there are overridden in copyable_holder_caster
+    void load_value(value_and_holder &&v_h) {
+        if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
+            smart_holder_type_caster_support::value_and_holder_helper v_h_helper;
+            v_h_helper.loaded_v_h = v_h;
+            if (v_h_helper.have_holder()) {
+                v_h_helper.throw_if_uninitialized_or_disowned_holder(cpptype->name());
+                value = v_h_helper.holder().template as_raw_ptr_unowned<void>();
+                return;
+            }
+        }
+        auto *&vptr = v_h.value_ptr();
+        // Lazy allocation for unallocated values:
+        if (vptr == nullptr) {
+            const auto *type = v_h.type ? v_h.type : typeinfo;
+            if (type->operator_new) {
+                vptr = type->operator_new(type->type_size);
+            } else {
+#if defined(__cpp_aligned_new) && (!defined(_MSC_VER) || _MSC_VER >= 1912)
+                if (type->type_align > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+                    vptr = ::operator new(type->type_size, std::align_val_t(type->type_align));
+                } else {
+                    vptr = ::operator new(type->type_size);
+                }
+#else
+                vptr = ::operator new(type->type_size);
+#endif
+            }
+        }
+        value = vptr;
+    }
+    bool try_implicit_casts(handle src, bool convert) {
+        for (const auto &cast : typeinfo->implicit_casts) {
+            type_caster_generic sub_caster(*cast.first);
+            if (sub_caster.load(src, convert)) {
+                value = cast.second(sub_caster.value);
+                return true;
+            }
+        }
+        return false;
+    }
+    bool try_direct_conversions(handle src) {
+        for (auto &converter : *typeinfo->direct_conversions) {
+            if (converter(src.ptr(), value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    bool try_cpp_conduit(handle src) {
+        value = try_raw_pointer_ephemeral_from_cpp_conduit(src, cpptype);
+        if (value != nullptr) {
+            return true;
+        }
+        return false;
+    }
+    void check_holder_compat() {}
+
+    PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) {
+        auto caster = type_caster_generic(ti);
+        if (caster.load(src, false)) {
+            return caster.value;
+        }
+        return nullptr;
+    }
+
+    /// Try to load with foreign typeinfo, if available. Used when there is no
+    /// native typeinfo, or when the native one wasn't able to produce a value.
+    PYBIND11_NOINLINE bool try_load_foreign_module_local(handle src) {
+        constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID;
+        const auto pytype = type::handle_of(src);
+        if (!hasattr(pytype, local_key)) {
+            return false;
+        }
+
+        type_info *foreign_typeinfo = reinterpret_borrow<capsule>(getattr(pytype, local_key));
+        // Only consider this foreign loader if actually foreign and is a loader of the correct cpp
+        // type
+        if (foreign_typeinfo->module_local_load == &local_load
+            || (cpptype && !same_type(*cpptype, *foreign_typeinfo->cpptype))) {
+            return false;
+        }
+
+        if (auto *result = foreign_typeinfo->module_local_load(src.ptr(), foreign_typeinfo)) {
+            value = result;
+            return true;
+        }
+        return false;
+    }
+
+    // Implementation of `load`; this takes the type of `this` so that it can dispatch the relevant
+    // bits of code between here and copyable_holder_caster where the two classes need different
+    // logic (without having to resort to virtual inheritance).
+    template <typename ThisT>
+    PYBIND11_NOINLINE bool load_impl(handle src, bool convert) {
+        if (!src) {
+            return false;
+        }
+        if (!typeinfo) {
+            return try_load_foreign_module_local(src);
+        }
+
+        auto &this_ = static_cast<ThisT &>(*this);
+        this_.check_holder_compat();
+
+        PyTypeObject *srctype = Py_TYPE(src.ptr());
+
+        // Case 1: If src is an exact type match for the target type then we can reinterpret_cast
+        // the instance's value pointer to the target type:
+        if (srctype == typeinfo->type) {
+            this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
+            return true;
+        }
+        // Case 2: We have a derived class
+        if (PyType_IsSubtype(srctype, typeinfo->type)) {
+            const auto &bases = all_type_info(srctype);
+            bool no_cpp_mi = typeinfo->simple_type;
+
+            // Case 2a: the python type is a Python-inherited derived class that inherits from just
+            // one simple (no MI) pybind11 class, or is an exact match, so the C++ instance is of
+            // the right type and we can use reinterpret_cast.
+            // (This is essentially the same as case 2b, but because not using multiple inheritance
+            // is extremely common, we handle it specially to avoid the loop iterator and type
+            // pointer lookup overhead)
+            if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) {
+                this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
+                return true;
+            }
+            // Case 2b: the python type inherits from multiple C++ bases.  Check the bases to see
+            // if we can find an exact match (or, for a simple C++ type, an inherited match); if
+            // so, we can safely reinterpret_cast to the relevant pointer.
+            if (bases.size() > 1) {
+                for (auto *base : bases) {
+                    if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type)
+                                  : base->type == typeinfo->type) {
+                        this_.load_value(
+                            reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base));
+                        return true;
+                    }
+                }
+            }
+
+            // Case 2c: C++ multiple inheritance is involved and we couldn't find an exact type
+            // match in the registered bases, above, so try implicit casting (needed for proper C++
+            // casting when MI is involved).
+            if (this_.try_implicit_casts(src, convert)) {
+                return true;
+            }
+        }
+
+        // Perform an implicit conversion
+        if (convert) {
+            for (const auto &converter : typeinfo->implicit_conversions) {
+                auto temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
+                if (load_impl<ThisT>(temp, false)) {
+                    loader_life_support::add_patient(temp);
+                    return true;
+                }
+            }
+            if (this_.try_direct_conversions(src)) {
+                return true;
+            }
+        }
+
+        // Failed to match local typeinfo. Try again with global.
+        if (typeinfo->module_local) {
+            if (auto *gtype = get_global_type_info(*typeinfo->cpptype)) {
+                typeinfo = gtype;
+                return load(src, false);
+            }
+        }
+
+        // Global typeinfo has precedence over foreign module_local
+        if (try_load_foreign_module_local(src)) {
+            return true;
+        }
+
+        // Custom converters didn't take None, now we convert None to nullptr.
+        if (src.is_none()) {
+            // Defer accepting None to other overloads (if we aren't in convert mode):
+            if (!convert) {
+                return false;
+            }
+            value = nullptr;
+            return true;
+        }
+
+        if (convert && cpptype && this_.try_cpp_conduit(src)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    // Called to do type lookup and wrap the pointer and type in a pair when a dynamic_cast
+    // isn't needed or can't be used.  If the type is unknown, sets the error and returns a pair
+    // with .second = nullptr.  (p.first = nullptr is not an error: it becomes None).
+    PYBIND11_NOINLINE static std::pair<const void *, const type_info *>
+    src_and_type(const void *src,
+                 const std::type_info &cast_type,
+                 const std::type_info *rtti_type = nullptr) {
+        if (auto *tpi = get_type_info(cast_type)) {
+            return {src, const_cast<const type_info *>(tpi)};
+        }
+
+        // Not found, set error:
+        std::string tname = rtti_type ? rtti_type->name() : cast_type.name();
+        detail::clean_type_id(tname);
+        std::string msg = "Unregistered type : " + tname;
+        set_error(PyExc_TypeError, msg.c_str());
+        return {nullptr, nullptr};
+    }
+
+    const type_info *typeinfo = nullptr;
+    const std::type_info *cpptype = nullptr;
+    void *value = nullptr;
+};
+
+inline object cpp_conduit_method(handle self,
+                                 const bytes &pybind11_platform_abi_id,
+                                 const capsule &cpp_type_info_capsule,
+                                 const bytes &pointer_kind) {
+#ifdef PYBIND11_HAS_STRING_VIEW
+    using cpp_str = std::string_view;
+#else
+    using cpp_str = std::string;
+#endif
+    if (cpp_str(pybind11_platform_abi_id) != PYBIND11_PLATFORM_ABI_ID) {
+        return none();
+    }
+    if (std::strcmp(cpp_type_info_capsule.name(), typeid(std::type_info).name()) != 0) {
+        return none();
+    }
+    if (cpp_str(pointer_kind) != "raw_pointer_ephemeral") {
+        throw std::runtime_error("Invalid pointer_kind: \"" + std::string(pointer_kind) + "\"");
+    }
+    const auto *cpp_type_info = cpp_type_info_capsule.get_pointer<const std::type_info>();
+    type_caster_generic caster(*cpp_type_info);
+    if (!caster.load(self, false)) {
+        return none();
+    }
+    return capsule(caster.value, cpp_type_info->name());
+}
+
+/**
+ * Determine suitable casting operator for pointer-or-lvalue-casting type casters.  The type caster
+ * needs to provide `operator T*()` and `operator T&()` operators.
+ *
+ * If the type supports moving the value away via an `operator T&&() &&` method, it should use
+ * `movable_cast_op_type` instead.
+ */
+template <typename T>
+using cast_op_type = conditional_t<std::is_pointer<remove_reference_t<T>>::value,
+                                   typename std::add_pointer<intrinsic_t<T>>::type,
+                                   typename std::add_lvalue_reference<intrinsic_t<T>>::type>;
+
+/**
+ * Determine suitable casting operator for a type caster with a movable value.  Such a type caster
+ * needs to provide `operator T*()`, `operator T&()`, and `operator T&&() &&`.  The latter will be
+ * called in appropriate contexts where the value can be moved rather than copied.
+ *
+ * These operator are automatically provided when using the PYBIND11_TYPE_CASTER macro.
+ */
+template <typename T>
+using movable_cast_op_type
+    = conditional_t<std::is_pointer<typename std::remove_reference<T>::type>::value,
+                    typename std::add_pointer<intrinsic_t<T>>::type,
+                    conditional_t<std::is_rvalue_reference<T>::value,
+                                  typename std::add_rvalue_reference<intrinsic_t<T>>::type,
+                                  typename std::add_lvalue_reference<intrinsic_t<T>>::type>>;
+
+// Does the container have a mapped type and is it recursive?
+// Implemented by specializations below.
+template <typename Container, typename SFINAE = void>
+struct container_mapped_type_traits {
+    static constexpr bool has_mapped_type = false;
+    static constexpr bool has_recursive_mapped_type = false;
+};
+
+template <typename Container>
+struct container_mapped_type_traits<
+    Container,
+    typename std::enable_if<
+        std::is_same<typename Container::mapped_type, Container>::value>::type> {
+    static constexpr bool has_mapped_type = true;
+    static constexpr bool has_recursive_mapped_type = true;
+};
+
+template <typename Container>
+struct container_mapped_type_traits<
+    Container,
+    typename std::enable_if<
+        negation<std::is_same<typename Container::mapped_type, Container>>::value>::type> {
+    static constexpr bool has_mapped_type = true;
+    static constexpr bool has_recursive_mapped_type = false;
+};
+
+// Does the container have a value type and is it recursive?
+// Implemented by specializations below.
+template <typename Container, typename SFINAE = void>
+struct container_value_type_traits : std::false_type {
+    static constexpr bool has_value_type = false;
+    static constexpr bool has_recursive_value_type = false;
+};
+
+template <typename Container>
+struct container_value_type_traits<
+    Container,
+    typename std::enable_if<
+        std::is_same<typename Container::value_type, Container>::value>::type> {
+    static constexpr bool has_value_type = true;
+    static constexpr bool has_recursive_value_type = true;
+};
+
+template <typename Container>
+struct container_value_type_traits<
+    Container,
+    typename std::enable_if<
+        negation<std::is_same<typename Container::value_type, Container>>::value>::type> {
+    static constexpr bool has_value_type = true;
+    static constexpr bool has_recursive_value_type = false;
+};
+
+/*
+ * Tag to be used for representing the bottom of recursively defined types.
+ * Define this tag so we don't have to use void.
+ */
+struct recursive_bottom {};
+
+/*
+ * Implementation detail of `recursive_container_traits` below.
+ * `T` is the `value_type` of the container, which might need to be modified to
+ * avoid recursive types and const types.
+ */
+template <typename T, bool is_this_a_map>
+struct impl_type_to_check_recursively {
+    /*
+     * If the container is recursive, then no further recursion should be done.
+     */
+    using if_recursive = recursive_bottom;
+    /*
+     * Otherwise yield `T` unchanged.
+     */
+    using if_not_recursive = T;
+};
+
+/*
+ * For pairs - only as value type of a map -, the first type should remove the `const`.
+ * Also, if the map is recursive, then the recursive checking should consider
+ * the first type only.
+ */
+template <typename A, typename B>
+struct impl_type_to_check_recursively<std::pair<A, B>, /* is_this_a_map = */ true> {
+    using if_recursive = typename std::remove_const<A>::type;
+    using if_not_recursive = std::pair<typename std::remove_const<A>::type, B>;
+};
+
+/*
+ * Implementation of `recursive_container_traits` below.
+ */
+template <typename Container, typename SFINAE = void>
+struct impl_recursive_container_traits {
+    using type_to_check_recursively = recursive_bottom;
+};
+
+template <typename Container>
+struct impl_recursive_container_traits<
+    Container,
+    typename std::enable_if<container_value_type_traits<Container>::has_value_type>::type> {
+    static constexpr bool is_recursive
+        = container_mapped_type_traits<Container>::has_recursive_mapped_type
+          || container_value_type_traits<Container>::has_recursive_value_type;
+    /*
+     * This member dictates which type Pybind11 should check recursively in traits
+     * such as `is_move_constructible`, `is_copy_constructible`, `is_move_assignable`, ...
+     * Direct access to `value_type` should be avoided:
+     * 1. `value_type` might recursively contain the type again
+     * 2. `value_type` of STL map types is `std::pair<A const, B>`, the `const`
+     *    should be removed.
+     *
+     */
+    using type_to_check_recursively = typename std::conditional<
+        is_recursive,
+        typename impl_type_to_check_recursively<
+            typename Container::value_type,
+            container_mapped_type_traits<Container>::has_mapped_type>::if_recursive,
+        typename impl_type_to_check_recursively<
+            typename Container::value_type,
+            container_mapped_type_traits<Container>::has_mapped_type>::if_not_recursive>::type;
+};
+
+/*
+ * This trait defines the `type_to_check_recursively` which is needed to properly
+ * handle recursively defined traits such as `is_move_constructible` without going
+ * into an infinite recursion.
+ * Should be used instead of directly accessing the `value_type`.
+ * It cancels the recursion by returning the `recursive_bottom` tag.
+ *
+ * The default definition of `type_to_check_recursively` is as follows:
+ *
+ * 1. By default, it is `recursive_bottom`, so that the recursion is canceled.
+ * 2. If the type is non-recursive and defines a `value_type`, then the `value_type` is used.
+ *    If the `value_type` is a pair and a `mapped_type` is defined,
+ *    then the `const` is removed from the first type.
+ * 3. If the type is recursive and `value_type` is not a pair, then `recursive_bottom` is returned.
+ * 4. If the type is recursive and `value_type` is a pair and a `mapped_type` is defined,
+ *    then `const` is removed from the first type and the first type is returned.
+ *
+ * This behavior can be extended by the user as seen in test_stl_binders.cpp.
+ *
+ * This struct is exactly the same as impl_recursive_container_traits.
+ * The duplication achieves that user-defined specializations don't compete
+ * with internal specializations, but take precedence.
+ */
+template <typename Container, typename SFINAE = void>
+struct recursive_container_traits : impl_recursive_container_traits<Container> {};
+
+template <typename T>
+struct is_move_constructible
+    : all_of<std::is_move_constructible<T>,
+             is_move_constructible<
+                 typename recursive_container_traits<T>::type_to_check_recursively>> {};
+
+template <>
+struct is_move_constructible<recursive_bottom> : std::true_type {};
+
+// Likewise for std::pair
+// (after C++17 it is mandatory that the move constructor not exist when the two types aren't
+// themselves move constructible, but this can not be relied upon when T1 or T2 are themselves
+// containers).
+template <typename T1, typename T2>
+struct is_move_constructible<std::pair<T1, T2>>
+    : all_of<is_move_constructible<T1>, is_move_constructible<T2>> {};
+
+// std::is_copy_constructible isn't quite enough: it lets std::vector<T> (and similar) through when
+// T is non-copyable, but code containing such a copy constructor fails to actually compile.
+template <typename T>
+struct is_copy_constructible
+    : all_of<std::is_copy_constructible<T>,
+             is_copy_constructible<
+                 typename recursive_container_traits<T>::type_to_check_recursively>> {};
+
+template <>
+struct is_copy_constructible<recursive_bottom> : std::true_type {};
+
+// Likewise for std::pair
+// (after C++17 it is mandatory that the copy constructor not exist when the two types aren't
+// themselves copy constructible, but this can not be relied upon when T1 or T2 are themselves
+// containers).
+template <typename T1, typename T2>
+struct is_copy_constructible<std::pair<T1, T2>>
+    : all_of<is_copy_constructible<T1>, is_copy_constructible<T2>> {};
+
+// The same problems arise with std::is_copy_assignable, so we use the same workaround.
+template <typename T>
+struct is_copy_assignable
+    : all_of<
+          std::is_copy_assignable<T>,
+          is_copy_assignable<typename recursive_container_traits<T>::type_to_check_recursively>> {
+};
+
+template <>
+struct is_copy_assignable<recursive_bottom> : std::true_type {};
+
+template <typename T1, typename T2>
+struct is_copy_assignable<std::pair<T1, T2>>
+    : all_of<is_copy_assignable<T1>, is_copy_assignable<T2>> {};
+
+PYBIND11_NAMESPACE_END(detail)
+
+// polymorphic_type_hook<itype>::get(src, tinfo) determines whether the object pointed
+// to by `src` actually is an instance of some class derived from `itype`.
+// If so, it sets `tinfo` to point to the std::type_info representing that derived
+// type, and returns a pointer to the start of the most-derived object of that type
+// (in which `src` is a subobject; this will be the same address as `src` in most
+// single inheritance cases). If not, or if `src` is nullptr, it simply returns `src`
+// and leaves `tinfo` at its default value of nullptr.
+//
+// The default polymorphic_type_hook just returns src. A specialization for polymorphic
+// types determines the runtime type of the passed object and adjusts the this-pointer
+// appropriately via dynamic_cast<void*>. This is what enables a C++ Animal* to appear
+// to Python as a Dog (if Dog inherits from Animal, Animal is polymorphic, Dog is
+// registered with pybind11, and this Animal is in fact a Dog).
+//
+// You may specialize polymorphic_type_hook yourself for types that want to appear
+// polymorphic to Python but do not use C++ RTTI. (This is a not uncommon pattern
+// in performance-sensitive applications, used most notably in LLVM.)
+//
+// polymorphic_type_hook_base allows users to specialize polymorphic_type_hook with
+// std::enable_if. User provided specializations will always have higher priority than
+// the default implementation and specialization provided in polymorphic_type_hook_base.
+template <typename itype, typename SFINAE = void>
+struct polymorphic_type_hook_base {
+    static const void *get(const itype *src, const std::type_info *&) { return src; }
+};
+template <typename itype>
+struct polymorphic_type_hook_base<itype, detail::enable_if_t<std::is_polymorphic<itype>::value>> {
+    static const void *get(const itype *src, const std::type_info *&type) {
+        type = src ? &typeid(*src) : nullptr;
+        return dynamic_cast<const void *>(src);
+    }
+};
+template <typename itype, typename SFINAE = void>
+struct polymorphic_type_hook : public polymorphic_type_hook_base<itype> {};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+/// Generic type caster for objects stored on the heap
+template <typename type>
+class type_caster_base : public type_caster_generic {
+    using itype = intrinsic_t<type>;
+
+public:
+    static constexpr auto name = const_name<type>();
+
+    type_caster_base() : type_caster_base(typeid(type)) {}
+    explicit type_caster_base(const std::type_info &info) : type_caster_generic(info) {}
+
+    static handle cast(const itype &src, return_value_policy policy, handle parent) {
+        if (policy == return_value_policy::automatic
+            || policy == return_value_policy::automatic_reference) {
+            policy = return_value_policy::copy;
+        }
+        return cast(std::addressof(src), policy, parent);
+    }
+
+    static handle cast(itype &&src, return_value_policy, handle parent) {
+        return cast(std::addressof(src), return_value_policy::move, parent);
+    }
+
+    // Returns a (pointer, type_info) pair taking care of necessary type lookup for a
+    // polymorphic type (using RTTI by default, but can be overridden by specializing
+    // polymorphic_type_hook). If the instance isn't derived, returns the base version.
+    static std::pair<const void *, const type_info *> src_and_type(const itype *src) {
+        const auto &cast_type = typeid(itype);
+        const std::type_info *instance_type = nullptr;
+        const void *vsrc = polymorphic_type_hook<itype>::get(src, instance_type);
+        if (instance_type && !same_type(cast_type, *instance_type)) {
+            // This is a base pointer to a derived type. If the derived type is registered
+            // with pybind11, we want to make the full derived object available.
+            // In the typical case where itype is polymorphic, we get the correct
+            // derived pointer (which may be != base pointer) by a dynamic_cast to
+            // most derived type. If itype is not polymorphic, we won't get here
+            // except via a user-provided specialization of polymorphic_type_hook,
+            // and the user has promised that no this-pointer adjustment is
+            // required in that case, so it's OK to use static_cast.
+            if (const auto *tpi = get_type_info(*instance_type)) {
+                return {vsrc, tpi};
+            }
+        }
+        // Otherwise we have either a nullptr, an `itype` pointer, or an unknown derived pointer,
+        // so don't do a cast
+        return type_caster_generic::src_and_type(src, cast_type, instance_type);
+    }
+
+    static handle cast(const itype *src, return_value_policy policy, handle parent) {
+        auto st = src_and_type(src);
+        return type_caster_generic::cast(st.first,
+                                         policy,
+                                         parent,
+                                         st.second,
+                                         make_copy_constructor(src),
+                                         make_move_constructor(src));
+    }
+
+    static handle cast_holder(const itype *src, const void *holder) {
+        auto st = src_and_type(src);
+        return type_caster_generic::cast(st.first,
+                                         return_value_policy::take_ownership,
+                                         {},
+                                         st.second,
+                                         nullptr,
+                                         nullptr,
+                                         holder);
+    }
+
+    template <typename T>
+    using cast_op_type = detail::cast_op_type<T>;
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator itype *() { return (type *) value; }
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator itype &() {
+        if (!value) {
+            throw reference_cast_error();
+        }
+        return *((itype *) value);
+    }
+
+protected:
+    using Constructor = void *(*) (const void *);
+
+    /* Only enabled when the types are {copy,move}-constructible *and* when the type
+       does not have a private operator new implementation. A comma operator is used in the
+       decltype argument to apply SFINAE to the public copy/move constructors.*/
+    template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>>
+    static auto make_copy_constructor(const T *)
+        -> decltype(new T(std::declval<const T>()), Constructor{}) {
+        return [](const void *arg) -> void * { return new T(*reinterpret_cast<const T *>(arg)); };
+    }
+
+    template <typename T, typename = enable_if_t<is_move_constructible<T>::value>>
+    static auto make_move_constructor(const T *)
+        -> decltype(new T(std::declval<T &&>()), Constructor{}) {
+        return [](const void *arg) -> void * {
+            return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
+        };
+    }
+
+    static Constructor make_copy_constructor(...) { return nullptr; }
+    static Constructor make_move_constructor(...) { return nullptr; }
+};
+
+inline std::string quote_cpp_type_name(const std::string &cpp_type_name) {
+    return cpp_type_name; // No-op for now. See PR #4888
+}
+
+PYBIND11_NOINLINE std::string type_info_description(const std::type_info &ti) {
+    if (auto *type_data = get_type_info(ti)) {
+        handle th((PyObject *) type_data->type);
+        return th.attr("__module__").cast<std::string>() + '.'
+               + th.attr("__qualname__").cast<std::string>();
+    }
+    return quote_cpp_type_name(clean_type_id(ti.name()));
+}
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/detail/typeid.h b/local_pybind11/pybind11/include/pybind11/detail/typeid.h
new file mode 100644
index 000000000..a67b52135
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/typeid.h
@@ -0,0 +1,65 @@
+/*
+    pybind11/detail/typeid.h: Compiler-independent access to type identifiers
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include <cstdio>
+#include <cstdlib>
+
+#if defined(__GNUG__)
+#    include <cxxabi.h>
+#endif
+
+#include "common.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+/// Erase all occurrences of a substring
+inline void erase_all(std::string &string, const std::string &search) {
+    for (size_t pos = 0;;) {
+        pos = string.find(search, pos);
+        if (pos == std::string::npos) {
+            break;
+        }
+        string.erase(pos, search.length());
+    }
+}
+
+PYBIND11_NOINLINE void clean_type_id(std::string &name) {
+#if defined(__GNUG__)
+    int status = 0;
+    std::unique_ptr<char, void (*)(void *)> res{
+        abi::__cxa_demangle(name.c_str(), nullptr, nullptr, &status), std::free};
+    if (status == 0) {
+        name = res.get();
+    }
+#else
+    detail::erase_all(name, "class ");
+    detail::erase_all(name, "struct ");
+    detail::erase_all(name, "enum ");
+#endif
+    detail::erase_all(name, "pybind11::");
+}
+
+inline std::string clean_type_id(const char *typeid_name) {
+    std::string name(typeid_name);
+    detail::clean_type_id(name);
+    return name;
+}
+
+PYBIND11_NAMESPACE_END(detail)
+
+/// Return a string representation of a C++ type
+template <typename T>
+static std::string type_id() {
+    return detail::clean_type_id(typeid(T).name());
+}
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/detail/using_smart_holder.h b/local_pybind11/pybind11/include/pybind11/detail/using_smart_holder.h
new file mode 100644
index 000000000..903148962
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/using_smart_holder.h
@@ -0,0 +1,22 @@
+// Copyright (c) 2024 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#pragma once
+
+#include "common.h"
+#include "struct_smart_holder.h"
+
+#include <type_traits>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+using pybind11::memory::smart_holder;
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+template <typename H>
+using is_smart_holder = std::is_same<H, smart_holder>;
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/detail/value_and_holder.h b/local_pybind11/pybind11/include/pybind11/detail/value_and_holder.h
new file mode 100644
index 000000000..87c92f8e4
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/detail/value_and_holder.h
@@ -0,0 +1,90 @@
+// Copyright (c) 2016-2024 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#pragma once
+
+#include "common.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <typeinfo>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+struct value_and_holder {
+    instance *inst = nullptr;
+    size_t index = 0u;
+    const detail::type_info *type = nullptr;
+    void **vh = nullptr;
+
+    // Main constructor for a found value/holder:
+    value_and_holder(instance *i, const detail::type_info *type, size_t vpos, size_t index)
+        : inst{i}, index{index}, type{type},
+          vh{inst->simple_layout ? inst->simple_value_holder
+                                 : &inst->nonsimple.values_and_holders[vpos]} {}
+
+    // Default constructor (used to signal a value-and-holder not found by get_value_and_holder())
+    value_and_holder() = default;
+
+    // Used for past-the-end iterator
+    explicit value_and_holder(size_t index) : index{index} {}
+
+    template <typename V = void>
+    V *&value_ptr() const {
+        return reinterpret_cast<V *&>(vh[0]);
+    }
+    // True if this `value_and_holder` has a non-null value pointer
+    explicit operator bool() const { return value_ptr() != nullptr; }
+
+    template <typename H>
+    H &holder() const {
+        return reinterpret_cast<H &>(vh[1]);
+    }
+    bool holder_constructed() const {
+        return inst->simple_layout
+                   ? inst->simple_holder_constructed
+                   : (inst->nonsimple.status[index] & instance::status_holder_constructed) != 0u;
+    }
+    // NOLINTNEXTLINE(readability-make-member-function-const)
+    void set_holder_constructed(bool v = true) {
+        if (inst->simple_layout) {
+            inst->simple_holder_constructed = v;
+        } else if (v) {
+            inst->nonsimple.status[index] |= instance::status_holder_constructed;
+        } else {
+            inst->nonsimple.status[index] &= (std::uint8_t) ~instance::status_holder_constructed;
+        }
+    }
+    bool instance_registered() const {
+        return inst->simple_layout
+                   ? inst->simple_instance_registered
+                   : ((inst->nonsimple.status[index] & instance::status_instance_registered) != 0);
+    }
+    // NOLINTNEXTLINE(readability-make-member-function-const)
+    void set_instance_registered(bool v = true) {
+        if (inst->simple_layout) {
+            inst->simple_instance_registered = v;
+        } else if (v) {
+            inst->nonsimple.status[index] |= instance::status_instance_registered;
+        } else {
+            inst->nonsimple.status[index] &= (std::uint8_t) ~instance::status_instance_registered;
+        }
+    }
+};
+
+// This is a semi-public API to check if the corresponding instance has been constructed with a
+// holder. That is, if the instance has been constructed with a holder, the `__init__` method is
+// called and the C++ object is valid. Otherwise, the C++ object might only be allocated, but not
+// initialized. This will lead to **SEGMENTATION FAULTS** if the C++ object is used in any way.
+// Example usage: https://pybind11.readthedocs.io/en/stable/advanced/classes.html#custom-type-setup
+//                for `tp_traverse` and `tp_clear` implementations.
+// WARNING: The caller is responsible for ensuring that the `reinterpret_cast` is valid.
+inline bool is_holder_constructed(PyObject *obj) {
+    auto *const instance = reinterpret_cast<pybind11::detail::instance *>(obj);
+    return instance->get_value_and_holder().holder_constructed();
+}
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/eigen.h b/local_pybind11/pybind11/include/pybind11/eigen.h
new file mode 100644
index 000000000..273b9c930
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/eigen.h
@@ -0,0 +1,12 @@
+/*
+    pybind11/eigen.h: Transparent conversion for dense and sparse Eigen matrices
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "eigen/matrix.h"
diff --git a/local_pybind11/pybind11/include/pybind11/eigen/common.h b/local_pybind11/pybind11/include/pybind11/eigen/common.h
new file mode 100644
index 000000000..24f56d158
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/eigen/common.h
@@ -0,0 +1,9 @@
+// Copyright (c) 2023 The pybind Community.
+
+#pragma once
+
+// Common message for `static_assert()`s, which are useful to easily
+// preempt much less obvious errors.
+#define PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED                                    \
+    "Pointer types (in particular `PyObject *`) are not supported as scalar types for Eigen "     \
+    "types."
diff --git a/local_pybind11/pybind11/include/pybind11/eigen/matrix.h b/local_pybind11/pybind11/include/pybind11/eigen/matrix.h
new file mode 100644
index 000000000..ca599c954
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/eigen/matrix.h
@@ -0,0 +1,723 @@
+/*
+    pybind11/eigen/matrix.h: Transparent conversion for dense and sparse Eigen matrices
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include <pybind11/numpy.h>
+
+#include "common.h"
+
+/* HINT: To suppress warnings originating from the Eigen headers, use -isystem.
+   See also:
+       https://stackoverflow.com/questions/2579576/i-dir-vs-isystem-dir
+       https://stackoverflow.com/questions/1741816/isystem-for-ms-visual-studio-c-compiler
+*/
+PYBIND11_WARNING_PUSH
+PYBIND11_WARNING_DISABLE_MSVC(5054) // https://github.com/pybind/pybind11/pull/3741
+//       C5054: operator '&': deprecated between enumerations of different types
+#if defined(__MINGW32__)
+PYBIND11_WARNING_DISABLE_GCC("-Wmaybe-uninitialized")
+#endif
+
+#include <Eigen/Core>
+#include <Eigen/SparseCore>
+
+PYBIND11_WARNING_POP
+
+// Eigen prior to 3.2.7 doesn't have proper move constructors--but worse, some classes get implicit
+// move constructors that break things.  We could detect this an explicitly copy, but an extra copy
+// of matrices seems highly undesirable.
+static_assert(EIGEN_VERSION_AT_LEAST(3, 2, 7),
+              "Eigen matrix support in pybind11 requires Eigen >= 3.2.7");
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+PYBIND11_WARNING_DISABLE_MSVC(4127)
+
+// Provide a convenience alias for easier pass-by-ref usage with fully dynamic strides:
+using EigenDStride = Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>;
+template <typename MatrixType>
+using EigenDRef = Eigen::Ref<MatrixType, 0, EigenDStride>;
+template <typename MatrixType>
+using EigenDMap = Eigen::Map<MatrixType, 0, EigenDStride>;
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+#if EIGEN_VERSION_AT_LEAST(3, 3, 0)
+using EigenIndex = Eigen::Index;
+template <typename Scalar, int Flags, typename StorageIndex>
+using EigenMapSparseMatrix = Eigen::Map<Eigen::SparseMatrix<Scalar, Flags, StorageIndex>>;
+#else
+using EigenIndex = EIGEN_DEFAULT_DENSE_INDEX_TYPE;
+template <typename Scalar, int Flags, typename StorageIndex>
+using EigenMapSparseMatrix = Eigen::MappedSparseMatrix<Scalar, Flags, StorageIndex>;
+#endif
+
+// Matches Eigen::Map, Eigen::Ref, blocks, etc:
+template <typename T>
+using is_eigen_dense_map = all_of<is_template_base_of<Eigen::DenseBase, T>,
+                                  std::is_base_of<Eigen::MapBase<T, Eigen::ReadOnlyAccessors>, T>>;
+template <typename T>
+using is_eigen_mutable_map = std::is_base_of<Eigen::MapBase<T, Eigen::WriteAccessors>, T>;
+template <typename T>
+using is_eigen_dense_plain
+    = all_of<negation<is_eigen_dense_map<T>>, is_template_base_of<Eigen::PlainObjectBase, T>>;
+template <typename T>
+using is_eigen_sparse = is_template_base_of<Eigen::SparseMatrixBase, T>;
+// Test for objects inheriting from EigenBase<Derived> that aren't captured by the above.  This
+// basically covers anything that can be assigned to a dense matrix but that don't have a typical
+// matrix data layout that can be copied from their .data().  For example, DiagonalMatrix and
+// SelfAdjointView fall into this category.
+template <typename T>
+using is_eigen_other
+    = all_of<is_template_base_of<Eigen::EigenBase, T>,
+             negation<any_of<is_eigen_dense_map<T>, is_eigen_dense_plain<T>, is_eigen_sparse<T>>>>;
+
+// Captures numpy/eigen conformability status (returned by EigenProps::conformable()):
+template <bool EigenRowMajor>
+struct EigenConformable {
+    bool conformable = false;
+    EigenIndex rows = 0, cols = 0;
+    EigenDStride stride{0, 0};    // Only valid if negativestrides is false!
+    bool negativestrides = false; // If true, do not use stride!
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    EigenConformable(bool fits = false) : conformable{fits} {}
+    // Matrix type:
+    EigenConformable(EigenIndex r, EigenIndex c, EigenIndex rstride, EigenIndex cstride)
+        : conformable{true}, rows{r}, cols{c},
+          // TODO: when Eigen bug #747 is fixed, remove the tests for non-negativity.
+          // http://eigen.tuxfamily.org/bz/show_bug.cgi?id=747
+          stride{EigenRowMajor ? (rstride > 0 ? rstride : 0)
+                               : (cstride > 0 ? cstride : 0) /* outer stride */,
+                 EigenRowMajor ? (cstride > 0 ? cstride : 0)
+                               : (rstride > 0 ? rstride : 0) /* inner stride */},
+          negativestrides{rstride < 0 || cstride < 0} {}
+    // Vector type:
+    EigenConformable(EigenIndex r, EigenIndex c, EigenIndex stride)
+        : EigenConformable(r, c, r == 1 ? c * stride : stride, c == 1 ? r : r * stride) {}
+
+    template <typename props>
+    bool stride_compatible() const {
+        // To have compatible strides, we need (on both dimensions) one of fully dynamic strides,
+        // matching strides, or a dimension size of 1 (in which case the stride value is
+        // irrelevant). Alternatively, if any dimension size is 0, the strides are not relevant
+        // (and numpy ≥ 1.23 sets the strides to 0 in that case, so we need to check explicitly).
+        if (negativestrides) {
+            return false;
+        }
+        if (rows == 0 || cols == 0) {
+            return true;
+        }
+        return (props::inner_stride == Eigen::Dynamic || props::inner_stride == stride.inner()
+                || (EigenRowMajor ? cols : rows) == 1)
+               && (props::outer_stride == Eigen::Dynamic || props::outer_stride == stride.outer()
+                   || (EigenRowMajor ? rows : cols) == 1);
+    }
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator bool() const { return conformable; }
+};
+
+template <typename Type>
+struct eigen_extract_stride {
+    using type = Type;
+};
+template <typename PlainObjectType, int MapOptions, typename StrideType>
+struct eigen_extract_stride<Eigen::Map<PlainObjectType, MapOptions, StrideType>> {
+    using type = StrideType;
+};
+template <typename PlainObjectType, int Options, typename StrideType>
+struct eigen_extract_stride<Eigen::Ref<PlainObjectType, Options, StrideType>> {
+    using type = StrideType;
+};
+
+// Helper struct for extracting information from an Eigen type
+template <typename Type_>
+struct EigenProps {
+    using Type = Type_;
+    using Scalar = typename Type::Scalar;
+    using StrideType = typename eigen_extract_stride<Type>::type;
+    static constexpr EigenIndex rows = Type::RowsAtCompileTime, cols = Type::ColsAtCompileTime,
+                                size = Type::SizeAtCompileTime;
+    static constexpr bool row_major = Type::IsRowMajor,
+                          vector
+                          = Type::IsVectorAtCompileTime, // At least one dimension has fixed size 1
+        fixed_rows = rows != Eigen::Dynamic, fixed_cols = cols != Eigen::Dynamic,
+                          fixed = size != Eigen::Dynamic, // Fully-fixed size
+        dynamic = !fixed_rows && !fixed_cols;             // Fully-dynamic size
+
+    template <EigenIndex i, EigenIndex ifzero>
+    using if_zero = std::integral_constant<EigenIndex, i == 0 ? ifzero : i>;
+    static constexpr EigenIndex inner_stride
+        = if_zero<StrideType::InnerStrideAtCompileTime, 1>::value,
+        outer_stride = if_zero < StrideType::OuterStrideAtCompileTime,
+        vector      ? size
+        : row_major ? cols
+                    : rows > ::value;
+    static constexpr bool dynamic_stride
+        = inner_stride == Eigen::Dynamic && outer_stride == Eigen::Dynamic;
+    static constexpr bool requires_row_major
+        = !dynamic_stride && !vector && (row_major ? inner_stride : outer_stride) == 1;
+    static constexpr bool requires_col_major
+        = !dynamic_stride && !vector && (row_major ? outer_stride : inner_stride) == 1;
+
+    // Takes an input array and determines whether we can make it fit into the Eigen type.  If
+    // the array is a vector, we attempt to fit it into either an Eigen 1xN or Nx1 vector
+    // (preferring the latter if it will fit in either, i.e. for a fully dynamic matrix type).
+    static EigenConformable<row_major> conformable(const array &a) {
+        const auto dims = a.ndim();
+        if (dims < 1 || dims > 2) {
+            return false;
+        }
+
+        if (dims == 2) { // Matrix type: require exact match (or dynamic)
+
+            EigenIndex np_rows = a.shape(0), np_cols = a.shape(1),
+                       np_rstride = a.strides(0) / static_cast<ssize_t>(sizeof(Scalar)),
+                       np_cstride = a.strides(1) / static_cast<ssize_t>(sizeof(Scalar));
+            if ((fixed_rows && np_rows != rows) || (fixed_cols && np_cols != cols)) {
+                return false;
+            }
+
+            return {np_rows, np_cols, np_rstride, np_cstride};
+        }
+
+        // Otherwise we're storing an n-vector.  Only one of the strides will be used, but
+        // whichever is used, we want the (single) numpy stride value.
+        const EigenIndex n = a.shape(0),
+                         stride = a.strides(0) / static_cast<ssize_t>(sizeof(Scalar));
+
+        if (vector) { // Eigen type is a compile-time vector
+            if (fixed && size != n) {
+                return false; // Vector size mismatch
+            }
+            return {rows == 1 ? 1 : n, cols == 1 ? 1 : n, stride};
+        }
+        if (fixed) {
+            // The type has a fixed size, but is not a vector: abort
+            return false;
+        }
+        if (fixed_cols) {
+            // Since this isn't a vector, cols must be != 1.  We allow this only if it exactly
+            // equals the number of elements (rows is Dynamic, and so 1 row is allowed).
+            if (cols != n) {
+                return false;
+            }
+            return {1, n, stride};
+        } // Otherwise it's either fully dynamic, or column dynamic; both become a column vector
+        if (fixed_rows && rows != n) {
+            return false;
+        }
+        return {n, 1, stride};
+    }
+
+    static constexpr bool show_writeable
+        = is_eigen_dense_map<Type>::value && is_eigen_mutable_map<Type>::value;
+    static constexpr bool show_order = is_eigen_dense_map<Type>::value;
+    static constexpr bool show_c_contiguous = show_order && requires_row_major;
+    static constexpr bool show_f_contiguous
+        = !show_c_contiguous && show_order && requires_col_major;
+
+    static constexpr auto descriptor
+        = const_name("typing.Annotated[")
+          + io_name("numpy.typing.ArrayLike, ", "numpy.typing.NDArray[")
+          + npy_format_descriptor<Scalar>::name + io_name("", "]") + const_name(", \"[")
+          + const_name<fixed_rows>(const_name<(size_t) rows>(), const_name("m")) + const_name(", ")
+          + const_name<fixed_cols>(const_name<(size_t) cols>(), const_name("n"))
+          + const_name("]\"")
+          // For a reference type (e.g. Ref<MatrixXd>) we have other constraints that might need to
+          // be satisfied: writeable=True (for a mutable reference), and, depending on the map's
+          // stride options, possibly f_contiguous or c_contiguous.  We include them in the
+          // descriptor output to provide some hint as to why a TypeError is occurring (otherwise
+          // it can be confusing to see that a function accepts a
+          // 'typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3,2]"]' and an error message
+          // that you *gave* a numpy.ndarray of the right type and dimensions.
+          + const_name<show_writeable>(", \"flags.writeable\"", "")
+          + const_name<show_c_contiguous>(", \"flags.c_contiguous\"", "")
+          + const_name<show_f_contiguous>(", \"flags.f_contiguous\"", "") + const_name("]");
+};
+
+// Casts an Eigen type to numpy array.  If given a base, the numpy array references the src data,
+// otherwise it'll make a copy.  writeable lets you turn off the writeable flag for the array.
+template <typename props>
+handle
+eigen_array_cast(typename props::Type const &src, handle base = handle(), bool writeable = true) {
+    constexpr ssize_t elem_size = sizeof(typename props::Scalar);
+    array a;
+    if (props::vector) {
+        a = array({src.size()}, {elem_size * src.innerStride()}, src.data(), base);
+    } else {
+        a = array({src.rows(), src.cols()},
+                  {elem_size * src.rowStride(), elem_size * src.colStride()},
+                  src.data(),
+                  base);
+    }
+
+    if (!writeable) {
+        array_proxy(a.ptr())->flags &= ~detail::npy_api::NPY_ARRAY_WRITEABLE_;
+    }
+
+    return a.release();
+}
+
+// Takes an lvalue ref to some Eigen type and a (python) base object, creating a numpy array that
+// reference the Eigen object's data with `base` as the python-registered base class (if omitted,
+// the base will be set to None, and lifetime management is up to the caller).  The numpy array is
+// non-writeable if the given type is const.
+template <typename props, typename Type>
+handle eigen_ref_array(Type &src, handle parent = none()) {
+    // none here is to get past array's should-we-copy detection, which currently always
+    // copies when there is no base.  Setting the base to None should be harmless.
+    return eigen_array_cast<props>(src, parent, !std::is_const<Type>::value);
+}
+
+// Takes a pointer to some dense, plain Eigen type, builds a capsule around it, then returns a
+// numpy array that references the encapsulated data with a python-side reference to the capsule to
+// tie its destruction to that of any dependent python objects.  Const-ness is determined by
+// whether or not the Type of the pointer given is const.
+template <typename props, typename Type, typename = enable_if_t<is_eigen_dense_plain<Type>::value>>
+handle eigen_encapsulate(Type *src) {
+    capsule base(src, [](void *o) { delete static_cast<Type *>(o); });
+    return eigen_ref_array<props>(*src, base);
+}
+
+// Type caster for regular, dense matrix types (e.g. MatrixXd), but not maps/refs/etc. of dense
+// types.
+template <typename Type>
+struct type_caster<Type, enable_if_t<is_eigen_dense_plain<Type>::value>> {
+    using Scalar = typename Type::Scalar;
+    static_assert(!std::is_pointer<Scalar>::value,
+                  PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED);
+    using props = EigenProps<Type>;
+
+    bool load(handle src, bool convert) {
+        // If we're in no-convert mode, only load if given an array of the correct type
+        if (!convert && !isinstance<array_t<Scalar>>(src)) {
+            return false;
+        }
+
+        // Coerce into an array, but don't do type conversion yet; the copy below handles it.
+        auto buf = array::ensure(src);
+
+        if (!buf) {
+            return false;
+        }
+
+        auto dims = buf.ndim();
+        if (dims < 1 || dims > 2) {
+            return false;
+        }
+
+        auto fits = props::conformable(buf);
+        if (!fits) {
+            return false;
+        }
+
+        PYBIND11_WARNING_PUSH
+        PYBIND11_WARNING_DISABLE_GCC("-Wmaybe-uninitialized") // See PR #5516
+        // Allocate the new type, then build a numpy reference into it
+        value = Type(fits.rows, fits.cols);
+        PYBIND11_WARNING_POP
+        auto ref = reinterpret_steal<array>(eigen_ref_array<props>(value));
+        if (dims == 1) {
+            ref = ref.squeeze();
+        } else if (ref.ndim() == 1) {
+            buf = buf.squeeze();
+        }
+
+        int result = detail::npy_api::get().PyArray_CopyInto_(ref.ptr(), buf.ptr());
+
+        if (result < 0) { // Copy failed!
+            PyErr_Clear();
+            return false;
+        }
+
+        return true;
+    }
+
+private:
+    // Cast implementation
+    template <typename CType>
+    static handle cast_impl(CType *src, return_value_policy policy, handle parent) {
+        switch (policy) {
+            case return_value_policy::take_ownership:
+            case return_value_policy::automatic:
+                return eigen_encapsulate<props>(src);
+            case return_value_policy::move:
+                return eigen_encapsulate<props>(new CType(std::move(*src)));
+            case return_value_policy::copy:
+                return eigen_array_cast<props>(*src);
+            case return_value_policy::reference:
+            case return_value_policy::automatic_reference:
+                return eigen_ref_array<props>(*src);
+            case return_value_policy::reference_internal:
+                return eigen_ref_array<props>(*src, parent);
+            default:
+                throw cast_error("unhandled return_value_policy: should not happen!");
+        };
+    }
+
+public:
+    // Normal returned non-reference, non-const value:
+    static handle cast(Type &&src, return_value_policy /* policy */, handle parent) {
+        return cast_impl(&src, return_value_policy::move, parent);
+    }
+    // If you return a non-reference const, we mark the numpy array readonly:
+    static handle cast(const Type &&src, return_value_policy /* policy */, handle parent) {
+        return cast_impl(&src, return_value_policy::move, parent);
+    }
+    // lvalue reference return; default (automatic) becomes copy
+    static handle cast(Type &src, return_value_policy policy, handle parent) {
+        if (policy == return_value_policy::automatic
+            || policy == return_value_policy::automatic_reference) {
+            policy = return_value_policy::copy;
+        }
+        return cast_impl(&src, policy, parent);
+    }
+    // const lvalue reference return; default (automatic) becomes copy
+    static handle cast(const Type &src, return_value_policy policy, handle parent) {
+        if (policy == return_value_policy::automatic
+            || policy == return_value_policy::automatic_reference) {
+            policy = return_value_policy::copy;
+        }
+        return cast(&src, policy, parent);
+    }
+    // non-const pointer return
+    static handle cast(Type *src, return_value_policy policy, handle parent) {
+        return cast_impl(src, policy, parent);
+    }
+    // const pointer return
+    static handle cast(const Type *src, return_value_policy policy, handle parent) {
+        return cast_impl(src, policy, parent);
+    }
+
+    static constexpr auto name = props::descriptor;
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator Type *() { return &value; }
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator Type &() { return value; }
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator Type &&() && { return std::move(value); }
+    template <typename T>
+    using cast_op_type = movable_cast_op_type<T>;
+
+private:
+    Type value;
+};
+
+// Base class for casting reference/map/block/etc. objects back to python.
+template <typename MapType>
+struct eigen_map_caster {
+    static_assert(!std::is_pointer<typename MapType::Scalar>::value,
+                  PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED);
+
+private:
+    using props = EigenProps<MapType>;
+
+public:
+    // Directly referencing a ref/map's data is a bit dangerous (whatever the map/ref points to has
+    // to stay around), but we'll allow it under the assumption that you know what you're doing
+    // (and have an appropriate keep_alive in place).  We return a numpy array pointing directly at
+    // the ref's data (The numpy array ends up read-only if the ref was to a const matrix type.)
+    // Note that this means you need to ensure you don't destroy the object in some other way (e.g.
+    // with an appropriate keep_alive, or with a reference to a statically allocated matrix).
+    static handle cast(const MapType &src, return_value_policy policy, handle parent) {
+        switch (policy) {
+            case return_value_policy::copy:
+                return eigen_array_cast<props>(src);
+            case return_value_policy::reference_internal:
+                return eigen_array_cast<props>(src, parent, is_eigen_mutable_map<MapType>::value);
+            case return_value_policy::reference:
+            case return_value_policy::automatic:
+            case return_value_policy::automatic_reference:
+                return eigen_array_cast<props>(src, none(), is_eigen_mutable_map<MapType>::value);
+            default:
+                // move, take_ownership don't make any sense for a ref/map:
+                pybind11_fail("Invalid return_value_policy for Eigen Map/Ref/Block type");
+        }
+    }
+
+    // return_descr forces the use of NDArray instead of ArrayLike in args
+    // since Ref<...> args can only accept arrays.
+    static constexpr auto name = return_descr(props::descriptor);
+
+    // Explicitly delete these: support python -> C++ conversion on these (i.e. these can be return
+    // types but not bound arguments).  We still provide them (with an explicitly delete) so that
+    // you end up here if you try anyway.
+    bool load(handle, bool) = delete;
+    operator MapType() = delete;
+    template <typename>
+    using cast_op_type = MapType;
+};
+
+// We can return any map-like object (but can only load Refs, specialized next):
+template <typename Type>
+struct type_caster<Type, enable_if_t<is_eigen_dense_map<Type>::value>> : eigen_map_caster<Type> {};
+
+// Loader for Ref<...> arguments.  See the documentation for info on how to make this work without
+// copying (it requires some extra effort in many cases).
+template <typename PlainObjectType, typename StrideType>
+struct type_caster<
+    Eigen::Ref<PlainObjectType, 0, StrideType>,
+    enable_if_t<is_eigen_dense_map<Eigen::Ref<PlainObjectType, 0, StrideType>>::value>>
+    : public eigen_map_caster<Eigen::Ref<PlainObjectType, 0, StrideType>> {
+private:
+    using Type = Eigen::Ref<PlainObjectType, 0, StrideType>;
+    using props = EigenProps<Type>;
+    using Scalar = typename props::Scalar;
+    static_assert(!std::is_pointer<Scalar>::value,
+                  PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED);
+    using MapType = Eigen::Map<PlainObjectType, 0, StrideType>;
+    using Array
+        = array_t<Scalar,
+                  array::forcecast
+                      | ((props::row_major ? props::inner_stride : props::outer_stride) == 1
+                             ? array::c_style
+                         : (props::row_major ? props::outer_stride : props::inner_stride) == 1
+                             ? array::f_style
+                             : 0)>;
+    static constexpr bool need_writeable = is_eigen_mutable_map<Type>::value;
+    // Delay construction (these have no default constructor)
+    std::unique_ptr<MapType> map;
+    std::unique_ptr<Type> ref;
+    // Our array.  When possible, this is just a numpy array pointing to the source data, but
+    // sometimes we can't avoid copying (e.g. input is not a numpy array at all, has an
+    // incompatible layout, or is an array of a type that needs to be converted).  Using a numpy
+    // temporary (rather than an Eigen temporary) saves an extra copy when we need both type
+    // conversion and storage order conversion.  (Note that we refuse to use this temporary copy
+    // when loading an argument for a Ref<M> with M non-const, i.e. a read-write reference).
+    Array copy_or_ref;
+
+public:
+    bool load(handle src, bool convert) {
+        // First check whether what we have is already an array of the right type.  If not, we
+        // can't avoid a copy (because the copy is also going to do type conversion).
+        bool need_copy = !isinstance<Array>(src);
+
+        EigenConformable<props::row_major> fits;
+        if (!need_copy) {
+            // We don't need a converting copy, but we also need to check whether the strides are
+            // compatible with the Ref's stride requirements
+            auto aref = reinterpret_borrow<Array>(src);
+
+            if (aref && (!need_writeable || aref.writeable())) {
+                fits = props::conformable(aref);
+                if (!fits) {
+                    return false; // Incompatible dimensions
+                }
+                if (!fits.template stride_compatible<props>()) {
+                    need_copy = true;
+                } else {
+                    copy_or_ref = std::move(aref);
+                }
+            } else {
+                need_copy = true;
+            }
+        }
+
+        if (need_copy) {
+            // We need to copy: If we need a mutable reference, or we're not supposed to convert
+            // (either because we're in the no-convert overload pass, or because we're explicitly
+            // instructed not to copy (via `py::arg().noconvert()`) we have to fail loading.
+            if (!convert || need_writeable) {
+                return false;
+            }
+
+            Array copy = Array::ensure(src);
+            if (!copy) {
+                return false;
+            }
+            fits = props::conformable(copy);
+            if (!fits || !fits.template stride_compatible<props>()) {
+                return false;
+            }
+            copy_or_ref = std::move(copy);
+            loader_life_support::add_patient(copy_or_ref);
+        }
+
+        ref.reset();
+        map.reset(new MapType(data(copy_or_ref),
+                              fits.rows,
+                              fits.cols,
+                              make_stride(fits.stride.outer(), fits.stride.inner())));
+        ref.reset(new Type(*map));
+
+        return true;
+    }
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator Type *() { return ref.get(); }
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator Type &() { return *ref; }
+    template <typename _T>
+    using cast_op_type = pybind11::detail::cast_op_type<_T>;
+
+private:
+    template <typename T = Type, enable_if_t<is_eigen_mutable_map<T>::value, int> = 0>
+    Scalar *data(Array &a) {
+        return a.mutable_data();
+    }
+
+    template <typename T = Type, enable_if_t<!is_eigen_mutable_map<T>::value, int> = 0>
+    const Scalar *data(Array &a) {
+        return a.data();
+    }
+
+    // Attempt to figure out a constructor of `Stride` that will work.
+    // If both strides are fixed, use a default constructor:
+    template <typename S>
+    using stride_ctor_default = bool_constant<S::InnerStrideAtCompileTime != Eigen::Dynamic
+                                              && S::OuterStrideAtCompileTime != Eigen::Dynamic
+                                              && std::is_default_constructible<S>::value>;
+    // Otherwise, if there is a two-index constructor, assume it is (outer,inner) like
+    // Eigen::Stride, and use it:
+    template <typename S>
+    using stride_ctor_dual
+        = bool_constant<!stride_ctor_default<S>::value
+                        && std::is_constructible<S, EigenIndex, EigenIndex>::value>;
+    // Otherwise, if there is a one-index constructor, and just one of the strides is dynamic, use
+    // it (passing whichever stride is dynamic).
+    template <typename S>
+    using stride_ctor_outer
+        = bool_constant<!any_of<stride_ctor_default<S>, stride_ctor_dual<S>>::value
+                        && S::OuterStrideAtCompileTime == Eigen::Dynamic
+                        && S::InnerStrideAtCompileTime != Eigen::Dynamic
+                        && std::is_constructible<S, EigenIndex>::value>;
+    template <typename S>
+    using stride_ctor_inner
+        = bool_constant<!any_of<stride_ctor_default<S>, stride_ctor_dual<S>>::value
+                        && S::InnerStrideAtCompileTime == Eigen::Dynamic
+                        && S::OuterStrideAtCompileTime != Eigen::Dynamic
+                        && std::is_constructible<S, EigenIndex>::value>;
+
+    template <typename S = StrideType, enable_if_t<stride_ctor_default<S>::value, int> = 0>
+    static S make_stride(EigenIndex, EigenIndex) {
+        return S();
+    }
+    template <typename S = StrideType, enable_if_t<stride_ctor_dual<S>::value, int> = 0>
+    static S make_stride(EigenIndex outer, EigenIndex inner) {
+        return S(outer, inner);
+    }
+    template <typename S = StrideType, enable_if_t<stride_ctor_outer<S>::value, int> = 0>
+    static S make_stride(EigenIndex outer, EigenIndex) {
+        return S(outer);
+    }
+    template <typename S = StrideType, enable_if_t<stride_ctor_inner<S>::value, int> = 0>
+    static S make_stride(EigenIndex, EigenIndex inner) {
+        return S(inner);
+    }
+};
+
+// type_caster for special matrix types (e.g. DiagonalMatrix), which are EigenBase, but not
+// EigenDense (i.e. they don't have a data(), at least not with the usual matrix layout).
+// load() is not supported, but we can cast them into the python domain by first copying to a
+// regular Eigen::Matrix, then casting that.
+template <typename Type>
+struct type_caster<Type, enable_if_t<is_eigen_other<Type>::value>> {
+    static_assert(!std::is_pointer<typename Type::Scalar>::value,
+                  PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED);
+
+protected:
+    using Matrix
+        = Eigen::Matrix<typename Type::Scalar, Type::RowsAtCompileTime, Type::ColsAtCompileTime>;
+    using props = EigenProps<Matrix>;
+
+public:
+    static handle cast(const Type &src, return_value_policy /* policy */, handle /* parent */) {
+        handle h = eigen_encapsulate<props>(new Matrix(src));
+        return h;
+    }
+    static handle cast(const Type *src, return_value_policy policy, handle parent) {
+        return cast(*src, policy, parent);
+    }
+
+    static constexpr auto name = props::descriptor;
+
+    // Explicitly delete these: support python -> C++ conversion on these (i.e. these can be return
+    // types but not bound arguments).  We still provide them (with an explicitly delete) so that
+    // you end up here if you try anyway.
+    bool load(handle, bool) = delete;
+    operator Type() = delete;
+    template <typename>
+    using cast_op_type = Type;
+};
+
+template <typename Type>
+struct type_caster<Type, enable_if_t<is_eigen_sparse<Type>::value>> {
+    using Scalar = typename Type::Scalar;
+    static_assert(!std::is_pointer<Scalar>::value,
+                  PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED);
+    using StorageIndex = remove_reference_t<decltype(*std::declval<Type>().outerIndexPtr())>;
+    using Index = typename Type::Index;
+    static constexpr bool rowMajor = Type::IsRowMajor;
+
+    bool load(handle src, bool) {
+        if (!src) {
+            return false;
+        }
+
+        auto obj = reinterpret_borrow<object>(src);
+        object sparse_module = module_::import("scipy.sparse");
+        object matrix_type = sparse_module.attr(rowMajor ? "csr_matrix" : "csc_matrix");
+
+        if (!type::handle_of(obj).is(matrix_type)) {
+            try {
+                obj = matrix_type(obj);
+            } catch (const error_already_set &) {
+                return false;
+            }
+        }
+
+        auto values = array_t<Scalar>((object) obj.attr("data"));
+        auto innerIndices = array_t<StorageIndex>((object) obj.attr("indices"));
+        auto outerIndices = array_t<StorageIndex>((object) obj.attr("indptr"));
+        auto shape = pybind11::tuple((pybind11::object) obj.attr("shape"));
+        auto nnz = obj.attr("nnz").cast<Index>();
+
+        if (!values || !innerIndices || !outerIndices) {
+            return false;
+        }
+
+        value = EigenMapSparseMatrix<Scalar,
+                                     Type::Flags &(Eigen::RowMajor | Eigen::ColMajor),
+                                     StorageIndex>(shape[0].cast<Index>(),
+                                                   shape[1].cast<Index>(),
+                                                   std::move(nnz),
+                                                   outerIndices.mutable_data(),
+                                                   innerIndices.mutable_data(),
+                                                   values.mutable_data());
+
+        return true;
+    }
+
+    static handle cast(const Type &src, return_value_policy /* policy */, handle /* parent */) {
+        const_cast<Type &>(src).makeCompressed();
+
+        object matrix_type
+            = module_::import("scipy.sparse").attr(rowMajor ? "csr_matrix" : "csc_matrix");
+
+        array data(src.nonZeros(), src.valuePtr());
+        array outerIndices((rowMajor ? src.rows() : src.cols()) + 1, src.outerIndexPtr());
+        array innerIndices(src.nonZeros(), src.innerIndexPtr());
+
+        return matrix_type(pybind11::make_tuple(
+                               std::move(data), std::move(innerIndices), std::move(outerIndices)),
+                           pybind11::make_tuple(src.rows(), src.cols()))
+            .release();
+    }
+
+    PYBIND11_TYPE_CASTER(Type,
+                         const_name<(Type::IsRowMajor) != 0>("scipy.sparse.csr_matrix[",
+                                                             "scipy.sparse.csc_matrix[")
+                             + npy_format_descriptor<Scalar>::name + const_name("]"));
+};
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/eigen/tensor.h b/local_pybind11/pybind11/include/pybind11/eigen/tensor.h
new file mode 100644
index 000000000..50e8b50b1
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/eigen/tensor.h
@@ -0,0 +1,521 @@
+/*
+    pybind11/eigen/tensor.h: Transparent conversion for Eigen tensors
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include <pybind11/numpy.h>
+
+#include "common.h"
+
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
+static_assert(__GNUC__ > 5, "Eigen Tensor support in pybind11 requires GCC > 5.0");
+#endif
+
+// Disable warnings for Eigen
+PYBIND11_WARNING_PUSH
+PYBIND11_WARNING_DISABLE_MSVC(4554)
+PYBIND11_WARNING_DISABLE_MSVC(4127)
+#if defined(__MINGW32__)
+PYBIND11_WARNING_DISABLE_GCC("-Wmaybe-uninitialized")
+#endif
+
+#include <unsupported/Eigen/CXX11/Tensor>
+
+PYBIND11_WARNING_POP
+
+static_assert(EIGEN_VERSION_AT_LEAST(3, 3, 0),
+              "Eigen Tensor support in pybind11 requires Eigen >= 3.3.0");
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+PYBIND11_WARNING_DISABLE_MSVC(4127)
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+inline bool is_tensor_aligned(const void *data) {
+    return (reinterpret_cast<std::size_t>(data) % EIGEN_DEFAULT_ALIGN_BYTES) == 0;
+}
+
+template <typename T>
+constexpr int compute_array_flag_from_tensor() {
+    static_assert((static_cast<int>(T::Layout) == static_cast<int>(Eigen::RowMajor))
+                      || (static_cast<int>(T::Layout) == static_cast<int>(Eigen::ColMajor)),
+                  "Layout must be row or column major");
+    return (static_cast<int>(T::Layout) == static_cast<int>(Eigen::RowMajor)) ? array::c_style
+                                                                              : array::f_style;
+}
+
+template <typename T>
+struct eigen_tensor_helper {};
+
+template <typename Scalar_, int NumIndices_, int Options_, typename IndexType>
+struct eigen_tensor_helper<Eigen::Tensor<Scalar_, NumIndices_, Options_, IndexType>> {
+    using Type = Eigen::Tensor<Scalar_, NumIndices_, Options_, IndexType>;
+    using ValidType = void;
+
+    static Eigen::DSizes<typename Type::Index, Type::NumIndices> get_shape(const Type &f) {
+        return f.dimensions();
+    }
+
+    static constexpr bool
+    is_correct_shape(const Eigen::DSizes<typename Type::Index, Type::NumIndices> & /*shape*/) {
+        return true;
+    }
+
+    template <typename T>
+    struct helper {};
+
+    template <size_t... Is>
+    struct helper<index_sequence<Is...>> {
+        static constexpr auto value = ::pybind11::detail::concat(const_name(((void) Is, "?"))...);
+    };
+
+    static constexpr auto dimensions_descriptor
+        = helper<decltype(make_index_sequence<Type::NumIndices>())>::value;
+
+    template <typename... Args>
+    static Type *alloc(Args &&...args) {
+        return new Type(std::forward<Args>(args)...);
+    }
+
+    static void free(Type *tensor) { delete tensor; }
+};
+
+template <typename Scalar_, typename std::ptrdiff_t... Indices, int Options_, typename IndexType>
+struct eigen_tensor_helper<
+    Eigen::TensorFixedSize<Scalar_, Eigen::Sizes<Indices...>, Options_, IndexType>> {
+    using Type = Eigen::TensorFixedSize<Scalar_, Eigen::Sizes<Indices...>, Options_, IndexType>;
+    using ValidType = void;
+
+    static constexpr Eigen::DSizes<typename Type::Index, Type::NumIndices>
+    get_shape(const Type & /*f*/) {
+        return get_shape();
+    }
+
+    static constexpr Eigen::DSizes<typename Type::Index, Type::NumIndices> get_shape() {
+        return Eigen::DSizes<typename Type::Index, Type::NumIndices>(Indices...);
+    }
+
+    static bool
+    is_correct_shape(const Eigen::DSizes<typename Type::Index, Type::NumIndices> &shape) {
+        return get_shape() == shape;
+    }
+
+    static constexpr auto dimensions_descriptor
+        = ::pybind11::detail::concat(const_name<Indices>()...);
+
+    template <typename... Args>
+    static Type *alloc(Args &&...args) {
+        Eigen::aligned_allocator<Type> allocator;
+        return ::new (allocator.allocate(1)) Type(std::forward<Args>(args)...);
+    }
+
+    static void free(Type *tensor) {
+        Eigen::aligned_allocator<Type> allocator;
+        tensor->~Type();
+        allocator.deallocate(tensor, 1);
+    }
+};
+
+template <typename Type, bool ShowDetails, bool NeedsWriteable = false>
+struct get_tensor_descriptor {
+    static constexpr auto details
+        = const_name<NeedsWriteable>(", \"flags.writeable\"", "") + const_name
+              < static_cast<int>(Type::Layout)
+          == static_cast<int>(Eigen::RowMajor)
+                 > (", \"flags.c_contiguous\"", ", \"flags.f_contiguous\"");
+    static constexpr auto value
+        = const_name("typing.Annotated[")
+          + io_name("numpy.typing.ArrayLike, ", "numpy.typing.NDArray[")
+          + npy_format_descriptor<typename Type::Scalar>::name + io_name("", "]")
+          + const_name(", \"[") + eigen_tensor_helper<remove_cv_t<Type>>::dimensions_descriptor
+          + const_name("]\"") + const_name<ShowDetails>(details, const_name("")) + const_name("]");
+};
+
+// When EIGEN_AVOID_STL_ARRAY is defined, Eigen::DSizes<T, 0> does not have the begin() member
+// function. Falling back to a simple loop works around this issue.
+//
+// We need to disable the type-limits warning for the inner loop when size = 0.
+
+PYBIND11_WARNING_PUSH
+PYBIND11_WARNING_DISABLE_GCC("-Wtype-limits")
+
+template <typename T, int size>
+std::vector<T> convert_dsizes_to_vector(const Eigen::DSizes<T, size> &arr) {
+    std::vector<T> result(size);
+
+    for (size_t i = 0; i < size; i++) {
+        result[i] = arr[i];
+    }
+
+    return result;
+}
+
+template <typename T, int size>
+Eigen::DSizes<T, size> get_shape_for_array(const array &arr) {
+    Eigen::DSizes<T, size> result;
+    const T *shape = arr.shape();
+    for (size_t i = 0; i < size; i++) {
+        result[i] = shape[i];
+    }
+
+    return result;
+}
+
+PYBIND11_WARNING_POP
+
+template <typename Type>
+struct type_caster<Type, typename eigen_tensor_helper<Type>::ValidType> {
+    static_assert(!std::is_pointer<typename Type::Scalar>::value,
+                  PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED);
+    using Helper = eigen_tensor_helper<Type>;
+    static constexpr auto temp_name = get_tensor_descriptor<Type, false>::value;
+    PYBIND11_TYPE_CASTER(Type, temp_name);
+
+    bool load(handle src, bool convert) {
+        if (!convert) {
+            if (!isinstance<array>(src)) {
+                return false;
+            }
+            array temp = array::ensure(src);
+            if (!temp) {
+                return false;
+            }
+
+            if (!temp.dtype().is(dtype::of<typename Type::Scalar>())) {
+                return false;
+            }
+        }
+
+        array_t<typename Type::Scalar, compute_array_flag_from_tensor<Type>()> arr(
+            reinterpret_borrow<object>(src));
+
+        if (arr.ndim() != Type::NumIndices) {
+            return false;
+        }
+        auto shape = get_shape_for_array<typename Type::Index, Type::NumIndices>(arr);
+
+        if (!Helper::is_correct_shape(shape)) {
+            return false;
+        }
+
+#if EIGEN_VERSION_AT_LEAST(3, 4, 0)
+        auto data_pointer = arr.data();
+#else
+        // Handle Eigen bug
+        auto data_pointer = const_cast<typename Type::Scalar *>(arr.data());
+#endif
+
+        if (is_tensor_aligned(arr.data())) {
+            value = Eigen::TensorMap<const Type, Eigen::Aligned>(data_pointer, shape);
+        } else {
+            value = Eigen::TensorMap<const Type>(data_pointer, shape);
+        }
+
+        return true;
+    }
+
+    static handle cast(Type &&src, return_value_policy policy, handle parent) {
+        if (policy == return_value_policy::reference
+            || policy == return_value_policy::reference_internal) {
+            pybind11_fail("Cannot use a reference return value policy for an rvalue");
+        }
+        return cast_impl(&src, return_value_policy::move, parent);
+    }
+
+    static handle cast(const Type &&src, return_value_policy policy, handle parent) {
+        if (policy == return_value_policy::reference
+            || policy == return_value_policy::reference_internal) {
+            pybind11_fail("Cannot use a reference return value policy for an rvalue");
+        }
+        return cast_impl(&src, return_value_policy::move, parent);
+    }
+
+    static handle cast(Type &src, return_value_policy policy, handle parent) {
+        if (policy == return_value_policy::automatic
+            || policy == return_value_policy::automatic_reference) {
+            policy = return_value_policy::copy;
+        }
+        return cast_impl(&src, policy, parent);
+    }
+
+    static handle cast(const Type &src, return_value_policy policy, handle parent) {
+        if (policy == return_value_policy::automatic
+            || policy == return_value_policy::automatic_reference) {
+            policy = return_value_policy::copy;
+        }
+        return cast(&src, policy, parent);
+    }
+
+    static handle cast(Type *src, return_value_policy policy, handle parent) {
+        if (policy == return_value_policy::automatic) {
+            policy = return_value_policy::take_ownership;
+        } else if (policy == return_value_policy::automatic_reference) {
+            policy = return_value_policy::reference;
+        }
+        return cast_impl(src, policy, parent);
+    }
+
+    static handle cast(const Type *src, return_value_policy policy, handle parent) {
+        if (policy == return_value_policy::automatic) {
+            policy = return_value_policy::take_ownership;
+        } else if (policy == return_value_policy::automatic_reference) {
+            policy = return_value_policy::reference;
+        }
+        return cast_impl(src, policy, parent);
+    }
+
+    template <typename C>
+    static handle cast_impl(C *src, return_value_policy policy, handle parent) {
+        object parent_object;
+        bool writeable = false;
+        switch (policy) {
+            case return_value_policy::move:
+                if (std::is_const<C>::value) {
+                    pybind11_fail("Cannot move from a constant reference");
+                }
+
+                src = Helper::alloc(std::move(*src));
+
+                parent_object
+                    = capsule(src, [](void *ptr) { Helper::free(reinterpret_cast<Type *>(ptr)); });
+                writeable = true;
+                break;
+
+            case return_value_policy::take_ownership:
+                if (std::is_const<C>::value) {
+                    // This cast is ugly, and might be UB in some cases, but we don't have an
+                    // alternative here as we must free that memory
+                    Helper::free(const_cast<Type *>(src));
+                    pybind11_fail("Cannot take ownership of a const reference");
+                }
+
+                parent_object
+                    = capsule(src, [](void *ptr) { Helper::free(reinterpret_cast<Type *>(ptr)); });
+                writeable = true;
+                break;
+
+            case return_value_policy::copy:
+                writeable = true;
+                break;
+
+            case return_value_policy::reference:
+                parent_object = none();
+                writeable = !std::is_const<C>::value;
+                break;
+
+            case return_value_policy::reference_internal:
+                // Default should do the right thing
+                if (!parent) {
+                    pybind11_fail("Cannot use reference internal when there is no parent");
+                }
+                parent_object = reinterpret_borrow<object>(parent);
+                writeable = !std::is_const<C>::value;
+                break;
+
+            default:
+                pybind11_fail("pybind11 bug in eigen.h, please file a bug report");
+        }
+
+        auto result = array_t<typename Type::Scalar, compute_array_flag_from_tensor<Type>()>(
+            convert_dsizes_to_vector(Helper::get_shape(*src)), src->data(), parent_object);
+
+        if (!writeable) {
+            array_proxy(result.ptr())->flags &= ~detail::npy_api::NPY_ARRAY_WRITEABLE_;
+        }
+
+        return result.release();
+    }
+};
+
+template <typename StoragePointerType,
+          bool needs_writeable,
+          enable_if_t<!needs_writeable, bool> = true>
+StoragePointerType get_array_data_for_type(array &arr) {
+#if EIGEN_VERSION_AT_LEAST(3, 4, 0)
+    return reinterpret_cast<StoragePointerType>(arr.data());
+#else
+    // Handle Eigen bug
+    return reinterpret_cast<StoragePointerType>(const_cast<void *>(arr.data()));
+#endif
+}
+
+template <typename StoragePointerType,
+          bool needs_writeable,
+          enable_if_t<needs_writeable, bool> = true>
+StoragePointerType get_array_data_for_type(array &arr) {
+    return reinterpret_cast<StoragePointerType>(arr.mutable_data());
+}
+
+template <typename T, typename = void>
+struct get_storage_pointer_type;
+
+template <typename MapType>
+struct get_storage_pointer_type<MapType, void_t<typename MapType::StoragePointerType>> {
+    using SPT = typename MapType::StoragePointerType;
+};
+
+template <typename MapType>
+struct get_storage_pointer_type<MapType, void_t<typename MapType::PointerArgType>> {
+    using SPT = typename MapType::PointerArgType;
+};
+
+template <typename Type, int Options>
+struct type_caster<Eigen::TensorMap<Type, Options>,
+                   typename eigen_tensor_helper<remove_cv_t<Type>>::ValidType> {
+    static_assert(!std::is_pointer<typename Type::Scalar>::value,
+                  PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED);
+    using MapType = Eigen::TensorMap<Type, Options>;
+    using Helper = eigen_tensor_helper<remove_cv_t<Type>>;
+
+    bool load(handle src, bool /*convert*/) {
+        // Note that we have a lot more checks here as we want to make sure to avoid copies
+        if (!isinstance<array>(src)) {
+            return false;
+        }
+        auto arr = reinterpret_borrow<array>(src);
+        if ((arr.flags() & compute_array_flag_from_tensor<Type>()) == 0) {
+            return false;
+        }
+
+        if (!arr.dtype().is(dtype::of<typename Type::Scalar>())) {
+            return false;
+        }
+
+        if (arr.ndim() != Type::NumIndices) {
+            return false;
+        }
+
+        constexpr bool is_aligned = (Options & Eigen::Aligned) != 0;
+
+        if (is_aligned && !is_tensor_aligned(arr.data())) {
+            return false;
+        }
+
+        auto shape = get_shape_for_array<typename Type::Index, Type::NumIndices>(arr);
+
+        if (!Helper::is_correct_shape(shape)) {
+            return false;
+        }
+
+        if (needs_writeable && !arr.writeable()) {
+            return false;
+        }
+
+        auto result = get_array_data_for_type<typename get_storage_pointer_type<MapType>::SPT,
+                                              needs_writeable>(arr);
+
+        value.reset(new MapType(std::move(result), std::move(shape)));
+
+        return true;
+    }
+
+    static handle cast(MapType &&src, return_value_policy policy, handle parent) {
+        return cast_impl(&src, policy, parent);
+    }
+
+    static handle cast(const MapType &&src, return_value_policy policy, handle parent) {
+        return cast_impl(&src, policy, parent);
+    }
+
+    static handle cast(MapType &src, return_value_policy policy, handle parent) {
+        if (policy == return_value_policy::automatic
+            || policy == return_value_policy::automatic_reference) {
+            policy = return_value_policy::copy;
+        }
+        return cast_impl(&src, policy, parent);
+    }
+
+    static handle cast(const MapType &src, return_value_policy policy, handle parent) {
+        if (policy == return_value_policy::automatic
+            || policy == return_value_policy::automatic_reference) {
+            policy = return_value_policy::copy;
+        }
+        return cast(&src, policy, parent);
+    }
+
+    static handle cast(MapType *src, return_value_policy policy, handle parent) {
+        if (policy == return_value_policy::automatic) {
+            policy = return_value_policy::take_ownership;
+        } else if (policy == return_value_policy::automatic_reference) {
+            policy = return_value_policy::reference;
+        }
+        return cast_impl(src, policy, parent);
+    }
+
+    static handle cast(const MapType *src, return_value_policy policy, handle parent) {
+        if (policy == return_value_policy::automatic) {
+            policy = return_value_policy::take_ownership;
+        } else if (policy == return_value_policy::automatic_reference) {
+            policy = return_value_policy::reference;
+        }
+        return cast_impl(src, policy, parent);
+    }
+
+    template <typename C>
+    static handle cast_impl(C *src, return_value_policy policy, handle parent) {
+        object parent_object;
+        constexpr bool writeable = !std::is_const<C>::value;
+        switch (policy) {
+            case return_value_policy::reference:
+                parent_object = none();
+                break;
+
+            case return_value_policy::reference_internal:
+                // Default should do the right thing
+                if (!parent) {
+                    pybind11_fail("Cannot use reference internal when there is no parent");
+                }
+                parent_object = reinterpret_borrow<object>(parent);
+                break;
+
+            default:
+                // move, take_ownership don't make any sense for a ref/map:
+                pybind11_fail("Invalid return_value_policy for Eigen Map type, must be either "
+                              "reference or reference_internal");
+        }
+
+        auto result = array_t<typename Type::Scalar, compute_array_flag_from_tensor<Type>()>(
+            convert_dsizes_to_vector(Helper::get_shape(*src)),
+            src->data(),
+            std::move(parent_object));
+
+        if (!writeable) {
+            array_proxy(result.ptr())->flags &= ~detail::npy_api::NPY_ARRAY_WRITEABLE_;
+        }
+
+        return result.release();
+    }
+
+#if EIGEN_VERSION_AT_LEAST(3, 4, 0)
+
+    static constexpr bool needs_writeable = !std::is_const<typename std::remove_pointer<
+        typename get_storage_pointer_type<MapType>::SPT>::type>::value;
+#else
+    // Handle Eigen bug
+    static constexpr bool needs_writeable = !std::is_const<Type>::value;
+#endif
+
+protected:
+    // TODO: Move to std::optional once std::optional has more support
+    std::unique_ptr<MapType> value;
+
+public:
+    // return_descr forces the use of NDArray instead of ArrayLike since refs can only reference
+    // arrays
+    static constexpr auto name
+        = return_descr(get_tensor_descriptor<Type, true, needs_writeable>::value);
+    explicit operator MapType *() { return value.get(); }
+    explicit operator MapType &() { return *value; }
+    explicit operator MapType &&() && { return std::move(*value); }
+
+    template <typename T_>
+    using cast_op_type = ::pybind11::detail::movable_cast_op_type<T_>;
+};
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/embed.h b/local_pybind11/pybind11/include/pybind11/embed.h
new file mode 100644
index 000000000..a820bfbfc
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/embed.h
@@ -0,0 +1,320 @@
+/*
+    pybind11/embed.h: Support for embedding the interpreter
+
+    Copyright (c) 2017 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "pybind11.h"
+#include "eval.h"
+
+#include <memory>
+#include <vector>
+
+#if defined(PYPY_VERSION)
+#    error Embedding the interpreter is not supported with PyPy
+#endif
+
+#define PYBIND11_EMBEDDED_MODULE_IMPL(name)                                                       \
+    extern "C" PyObject *pybind11_init_impl_##name();                                             \
+    extern "C" PyObject *pybind11_init_impl_##name() { return pybind11_init_wrapper_##name(); }
+
+/** \rst
+    Add a new module to the table of builtins for the interpreter. Must be
+    defined in global scope. The first macro parameter is the name of the
+    module (without quotes). The second parameter is the variable which will
+    be used as the interface to add functions and classes to the module.
+
+    .. code-block:: cpp
+
+        PYBIND11_EMBEDDED_MODULE(example, m) {
+            // ... initialize functions and classes here
+            m.def("foo", []() {
+                return "Hello, World!";
+            });
+        }
+
+    The third and subsequent macro arguments are optional, and can be used to
+    mark the module as supporting various Python features.
+
+    - ``mod_gil_not_used()``
+    - ``multiple_interpreters::per_interpreter_gil()``
+    - ``multiple_interpreters::shared_gil()``
+    - ``multiple_interpreters::not_supported()``
+
+    .. code-block:: cpp
+
+        PYBIND11_EMBEDDED_MODULE(example, m, py::mod_gil_not_used()) {
+            m.def("foo", []() {
+                return "Hello, Free-threaded World!";
+            });
+        }
+
+ \endrst */
+PYBIND11_WARNING_PUSH
+PYBIND11_WARNING_DISABLE_CLANG("-Wgnu-zero-variadic-macro-arguments")
+#define PYBIND11_EMBEDDED_MODULE(name, variable, ...)                                             \
+    PYBIND11_MODULE_PYINIT(name, {}, ##__VA_ARGS__)                                               \
+    ::pybind11::detail::embedded_module PYBIND11_CONCAT(pybind11_module_, name)(                  \
+        PYBIND11_TOSTRING(name), PYBIND11_CONCAT(PyInit_, name));                                 \
+    PYBIND11_MODULE_EXEC(name, variable)
+PYBIND11_WARNING_POP
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+/// Python 2.7/3.x compatible version of `PyImport_AppendInittab` and error checks.
+struct embedded_module {
+    using init_t = PyObject *(*) ();
+    embedded_module(const char *name, init_t init) {
+        if (Py_IsInitialized() != 0) {
+            pybind11_fail("Can't add new modules after the interpreter has been initialized");
+        }
+
+        auto result = PyImport_AppendInittab(name, init);
+        if (result == -1) {
+            pybind11_fail("Insufficient memory to add a new module");
+        }
+    }
+};
+
+struct wide_char_arg_deleter {
+    void operator()(wchar_t *ptr) const {
+        // API docs: https://docs.python.org/3/c-api/sys.html#c.Py_DecodeLocale
+        PyMem_RawFree(ptr);
+    }
+};
+
+inline wchar_t *widen_chars(const char *safe_arg) {
+    wchar_t *widened_arg = Py_DecodeLocale(safe_arg, nullptr);
+    return widened_arg;
+}
+
+inline void precheck_interpreter() {
+    if (Py_IsInitialized() != 0) {
+        pybind11_fail("The interpreter is already running");
+    }
+}
+
+#if !defined(PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX)
+#    define PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX (0x03080000)
+#endif
+
+#if PY_VERSION_HEX < PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX
+inline void initialize_interpreter_pre_pyconfig(bool init_signal_handlers,
+                                                int argc,
+                                                const char *const *argv,
+                                                bool add_program_dir_to_path) {
+    detail::precheck_interpreter();
+    Py_InitializeEx(init_signal_handlers ? 1 : 0);
+
+    auto argv_size = static_cast<size_t>(argc);
+    // SetArgv* on python 3 takes wchar_t, so we have to convert.
+    std::unique_ptr<wchar_t *[]> widened_argv(new wchar_t *[argv_size]);
+    std::vector<std::unique_ptr<wchar_t[], detail::wide_char_arg_deleter>> widened_argv_entries;
+    widened_argv_entries.reserve(argv_size);
+    for (size_t ii = 0; ii < argv_size; ++ii) {
+        widened_argv_entries.emplace_back(detail::widen_chars(argv[ii]));
+        if (!widened_argv_entries.back()) {
+            // A null here indicates a character-encoding failure or the python
+            // interpreter out of memory. Give up.
+            return;
+        }
+        widened_argv[ii] = widened_argv_entries.back().get();
+    }
+
+    auto *pysys_argv = widened_argv.get();
+
+    PySys_SetArgvEx(argc, pysys_argv, static_cast<int>(add_program_dir_to_path));
+}
+#endif
+
+PYBIND11_NAMESPACE_END(detail)
+
+#if PY_VERSION_HEX >= PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX
+inline void initialize_interpreter(PyConfig *config,
+                                   int argc = 0,
+                                   const char *const *argv = nullptr,
+                                   bool add_program_dir_to_path = true) {
+    detail::precheck_interpreter();
+    PyStatus status = PyConfig_SetBytesArgv(config, argc, const_cast<char *const *>(argv));
+    if (PyStatus_Exception(status) != 0) {
+        // A failure here indicates a character-encoding failure or the python
+        // interpreter out of memory. Give up.
+        PyConfig_Clear(config);
+        throw std::runtime_error(PyStatus_IsError(status) != 0 ? status.err_msg
+                                                               : "Failed to prepare CPython");
+    }
+    status = Py_InitializeFromConfig(config);
+    if (PyStatus_Exception(status) != 0) {
+        PyConfig_Clear(config);
+        throw std::runtime_error(PyStatus_IsError(status) != 0 ? status.err_msg
+                                                               : "Failed to init CPython");
+    }
+    if (add_program_dir_to_path) {
+        PyRun_SimpleString("import sys, os.path; "
+                           "sys.path.insert(0, "
+                           "os.path.abspath(os.path.dirname(sys.argv[0])) "
+                           "if sys.argv and os.path.exists(sys.argv[0]) else '')");
+    }
+    PyConfig_Clear(config);
+}
+#endif
+
+/** \rst
+    Initialize the Python interpreter. No other pybind11 or CPython API functions can be
+    called before this is done; with the exception of `PYBIND11_EMBEDDED_MODULE`. The
+    optional `init_signal_handlers` parameter can be used to skip the registration of
+    signal handlers (see the `Python documentation`_ for details). Calling this function
+    again after the interpreter has already been initialized is a fatal error.
+
+    If initializing the Python interpreter fails, then the program is terminated.  (This
+    is controlled by the CPython runtime and is an exception to pybind11's normal behavior
+    of throwing exceptions on errors.)
+
+    The remaining optional parameters, `argc`, `argv`, and `add_program_dir_to_path` are
+    used to populate ``sys.argv`` and ``sys.path``.
+    See the |PySys_SetArgvEx documentation|_ for details.
+
+    .. _Python documentation: https://docs.python.org/3/c-api/init.html#c.Py_InitializeEx
+    .. |PySys_SetArgvEx documentation| replace:: ``PySys_SetArgvEx`` documentation
+    .. _PySys_SetArgvEx documentation: https://docs.python.org/3/c-api/init.html#c.PySys_SetArgvEx
+ \endrst */
+inline void initialize_interpreter(bool init_signal_handlers = true,
+                                   int argc = 0,
+                                   const char *const *argv = nullptr,
+                                   bool add_program_dir_to_path = true) {
+#if PY_VERSION_HEX < PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX
+    detail::initialize_interpreter_pre_pyconfig(
+        init_signal_handlers, argc, argv, add_program_dir_to_path);
+#else
+    PyConfig config;
+    PyConfig_InitPythonConfig(&config);
+    // See PR #4473 for background
+    config.parse_argv = 0;
+
+    config.install_signal_handlers = init_signal_handlers ? 1 : 0;
+    initialize_interpreter(&config, argc, argv, add_program_dir_to_path);
+#endif
+
+    // There is exactly one interpreter alive currently.
+    detail::get_num_interpreters_seen() = 1;
+}
+
+/** \rst
+    Shut down the Python interpreter. No pybind11 or CPython API functions can be called
+    after this. In addition, pybind11 objects must not outlive the interpreter:
+
+    .. code-block:: cpp
+
+        { // BAD
+            py::initialize_interpreter();
+            auto hello = py::str("Hello, World!");
+            py::finalize_interpreter();
+        } // <-- BOOM, hello's destructor is called after interpreter shutdown
+
+        { // GOOD
+            py::initialize_interpreter();
+            { // scoped
+                auto hello = py::str("Hello, World!");
+            } // <-- OK, hello is cleaned up properly
+            py::finalize_interpreter();
+        }
+
+        { // BETTER
+            py::scoped_interpreter guard{};
+            auto hello = py::str("Hello, World!");
+        }
+
+    .. warning::
+
+        The interpreter can be restarted by calling `initialize_interpreter` again.
+        Modules created using pybind11 can be safely re-initialized. However, Python
+        itself cannot completely unload binary extension modules and there are several
+        caveats with regard to interpreter restarting. All the details can be found
+        in the CPython documentation. In short, not all interpreter memory may be
+        freed, either due to reference cycles or user-created global data.
+
+ \endrst */
+inline void finalize_interpreter() {
+    // get rid of any thread-local interpreter cache that currently exists
+    if (detail::get_num_interpreters_seen() > 1) {
+        detail::get_internals_pp_manager().unref();
+        detail::get_local_internals_pp_manager().unref();
+
+        // We know there can be no other interpreter alive now, so we can lower the count
+        detail::get_num_interpreters_seen() = 1;
+    }
+
+    // Re-fetch the internals pointer-to-pointer (but not the internals itself, which might not
+    // exist). It's possible for the  internals to be created during Py_Finalize() (e.g. if a
+    // py::capsule calls `get_internals()` during destruction), so we get the pointer-pointer here
+    // and check it after Py_Finalize().
+    detail::get_internals_pp_manager().get_pp();
+    detail::get_local_internals_pp_manager().get_pp();
+
+    Py_Finalize();
+
+    detail::get_internals_pp_manager().destroy();
+
+    // Local internals contains data managed by the current interpreter, so we must clear them to
+    // avoid undefined behaviors when initializing another interpreter
+    detail::get_local_internals_pp_manager().destroy();
+
+    // We know there is no interpreter alive now, so we can reset the count
+    detail::get_num_interpreters_seen() = 0;
+}
+
+/** \rst
+    Scope guard version of `initialize_interpreter` and `finalize_interpreter`.
+    This a move-only guard and only a single instance can exist.
+
+    See `initialize_interpreter` for a discussion of its constructor arguments.
+
+    .. code-block:: cpp
+
+        #include <pybind11/embed.h>
+
+        int main() {
+            py::scoped_interpreter guard{};
+            py::print(Hello, World!);
+        } // <-- interpreter shutdown
+ \endrst */
+class scoped_interpreter {
+public:
+    explicit scoped_interpreter(bool init_signal_handlers = true,
+                                int argc = 0,
+                                const char *const *argv = nullptr,
+                                bool add_program_dir_to_path = true) {
+        initialize_interpreter(init_signal_handlers, argc, argv, add_program_dir_to_path);
+    }
+
+#if PY_VERSION_HEX >= PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX
+    explicit scoped_interpreter(PyConfig *config,
+                                int argc = 0,
+                                const char *const *argv = nullptr,
+                                bool add_program_dir_to_path = true) {
+        initialize_interpreter(config, argc, argv, add_program_dir_to_path);
+    }
+#endif
+
+    scoped_interpreter(const scoped_interpreter &) = delete;
+    scoped_interpreter(scoped_interpreter &&other) noexcept { other.is_valid = false; }
+    scoped_interpreter &operator=(const scoped_interpreter &) = delete;
+    scoped_interpreter &operator=(scoped_interpreter &&) = delete;
+
+    ~scoped_interpreter() {
+        if (is_valid) {
+            finalize_interpreter();
+        }
+    }
+
+private:
+    bool is_valid = true;
+};
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/eval.h b/local_pybind11/pybind11/include/pybind11/eval.h
new file mode 100644
index 000000000..a58872918
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/eval.h
@@ -0,0 +1,161 @@
+/*
+    pybind11/eval.h: Support for evaluating Python expressions and statements
+    from strings and files
+
+    Copyright (c) 2016 Klemens Morgenstern <klemens.morgenstern@ed-chemnitz.de> and
+                       Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "pybind11.h"
+
+#include <utility>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+inline void ensure_builtins_in_globals(object &global) {
+#if defined(PYPY_VERSION)
+    // Running exec and eval adds `builtins` module under `__builtins__` key to
+    // globals if not yet present.  Python 3.8 made PyRun_String behave
+    // similarly. Let's also do that for older versions, for consistency. This
+    // was missing from PyPy3.8 7.3.7.
+    if (!global.contains("__builtins__"))
+        global["__builtins__"] = module_::import(PYBIND11_BUILTINS_MODULE);
+#else
+    (void) global;
+#endif
+}
+
+PYBIND11_NAMESPACE_END(detail)
+
+enum eval_mode {
+    /// Evaluate a string containing an isolated expression
+    eval_expr,
+
+    /// Evaluate a string containing a single statement. Returns \c none
+    eval_single_statement,
+
+    /// Evaluate a string containing a sequence of statement. Returns \c none
+    eval_statements
+};
+
+template <eval_mode mode = eval_expr>
+object eval(const str &expr, object global = globals(), object local = object()) {
+    if (!local) {
+        local = global;
+    }
+
+    detail::ensure_builtins_in_globals(global);
+
+    /* PyRun_String does not accept a PyObject / encoding specifier,
+       this seems to be the only alternative */
+    std::string buffer = "# -*- coding: utf-8 -*-\n" + (std::string) expr;
+
+    int start = 0;
+    switch (mode) {
+        case eval_expr:
+            start = Py_eval_input;
+            break;
+        case eval_single_statement:
+            start = Py_single_input;
+            break;
+        case eval_statements:
+            start = Py_file_input;
+            break;
+        default:
+            pybind11_fail("invalid evaluation mode");
+    }
+
+    PyObject *result = PyRun_String(buffer.c_str(), start, global.ptr(), local.ptr());
+    if (!result) {
+        throw error_already_set();
+    }
+    return reinterpret_steal<object>(result);
+}
+
+template <eval_mode mode = eval_expr, size_t N>
+object eval(const char (&s)[N], object global = globals(), object local = object()) {
+    /* Support raw string literals by removing common leading whitespace */
+    auto expr = (s[0] == '\n') ? str(module_::import("textwrap").attr("dedent")(s)) : str(s);
+    return eval<mode>(expr, std::move(global), std::move(local));
+}
+
+inline void exec(const str &expr, object global = globals(), object local = object()) {
+    eval<eval_statements>(expr, std::move(global), std::move(local));
+}
+
+template <size_t N>
+void exec(const char (&s)[N], object global = globals(), object local = object()) {
+    eval<eval_statements>(s, std::move(global), std::move(local));
+}
+
+#if defined(PYPY_VERSION) || defined(GRAALVM_PYTHON)
+template <eval_mode mode = eval_statements>
+object eval_file(str, object, object) {
+    pybind11_fail("eval_file not supported in this interpreter. Use eval");
+}
+template <eval_mode mode = eval_statements>
+object eval_file(str, object) {
+    pybind11_fail("eval_file not supported in this interpreter. Use eval");
+}
+template <eval_mode mode = eval_statements>
+object eval_file(str) {
+    pybind11_fail("eval_file not supported in this interpreter. Use eval");
+}
+#else
+template <eval_mode mode = eval_statements>
+object eval_file(str fname, object global = globals(), object local = object()) {
+    if (!local) {
+        local = global;
+    }
+
+    detail::ensure_builtins_in_globals(global);
+
+    int start = 0;
+    switch (mode) {
+        case eval_expr:
+            start = Py_eval_input;
+            break;
+        case eval_single_statement:
+            start = Py_single_input;
+            break;
+        case eval_statements:
+            start = Py_file_input;
+            break;
+        default:
+            pybind11_fail("invalid evaluation mode");
+    }
+
+    int closeFile = 1;
+    std::string fname_str = (std::string) fname;
+    FILE *f =
+#    if PY_VERSION_HEX >= 0x030E0000
+        Py_fopen(fname.ptr(), "r");
+#    else
+        _Py_fopen_obj(fname.ptr(), "r");
+#    endif
+    if (!f) {
+        PyErr_Clear();
+        pybind11_fail("File \"" + fname_str + "\" could not be opened!");
+    }
+
+    if (!global.contains("__file__")) {
+        global["__file__"] = std::move(fname);
+    }
+
+    PyObject *result
+        = PyRun_FileEx(f, fname_str.c_str(), start, global.ptr(), local.ptr(), closeFile);
+
+    if (!result) {
+        throw error_already_set();
+    }
+    return reinterpret_steal<object>(result);
+}
+#endif
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/functional.h b/local_pybind11/pybind11/include/pybind11/functional.h
new file mode 100644
index 000000000..8f59f5fe5
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/functional.h
@@ -0,0 +1,147 @@
+/*
+    pybind11/functional.h: std::function<> support
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "pybind11.h"
+
+#include <functional>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+PYBIND11_NAMESPACE_BEGIN(type_caster_std_function_specializations)
+
+// ensure GIL is held during functor destruction
+struct func_handle {
+    function f;
+#if !(defined(_MSC_VER) && _MSC_VER == 1916 && defined(PYBIND11_CPP17))
+    // This triggers a syntax error under very special conditions (very weird indeed).
+    explicit
+#endif
+        func_handle(function &&f_) noexcept
+        : f(std::move(f_)) {
+    }
+    func_handle(const func_handle &f_) { operator=(f_); }
+    func_handle &operator=(const func_handle &f_) {
+        gil_scoped_acquire acq;
+        f = f_.f;
+        return *this;
+    }
+    ~func_handle() {
+        gil_scoped_acquire acq;
+        function kill_f(std::move(f));
+    }
+};
+
+// to emulate 'move initialization capture' in C++11
+struct func_wrapper_base {
+    func_handle hfunc;
+    explicit func_wrapper_base(func_handle &&hf) noexcept : hfunc(hf) {}
+};
+
+template <typename Return, typename... Args>
+struct func_wrapper : func_wrapper_base {
+    using func_wrapper_base::func_wrapper_base;
+    Return operator()(Args... args) const { // NOLINT(performance-unnecessary-value-param)
+        gil_scoped_acquire acq;
+        // casts the returned object as a rvalue to the return type
+        return hfunc.f(std::forward<Args>(args)...).template cast<Return>();
+    }
+};
+
+PYBIND11_NAMESPACE_END(type_caster_std_function_specializations)
+
+template <typename Return, typename... Args>
+struct type_caster<std::function<Return(Args...)>> {
+    using type = std::function<Return(Args...)>;
+    using retval_type = conditional_t<std::is_same<Return, void>::value, void_type, Return>;
+    using function_type = Return (*)(Args...);
+
+public:
+    bool load(handle src, bool convert) {
+        if (src.is_none()) {
+            // Defer accepting None to other overloads (if we aren't in convert mode):
+            if (!convert) {
+                return false;
+            }
+            return true;
+        }
+
+        if (!isinstance<function>(src)) {
+            return false;
+        }
+
+        auto func = reinterpret_borrow<function>(src);
+
+        /*
+           When passing a C++ function as an argument to another C++
+           function via Python, every function call would normally involve
+           a full C++ -> Python -> C++ roundtrip, which can be prohibitive.
+           Here, we try to at least detect the case where the function is
+           stateless (i.e. function pointer or lambda function without
+           captured variables), in which case the roundtrip can be avoided.
+         */
+        if (auto cfunc = func.cpp_function()) {
+            auto *cfunc_self = PyCFunction_GET_SELF(cfunc.ptr());
+            if (cfunc_self == nullptr) {
+                PyErr_Clear();
+            } else {
+                function_record *rec = function_record_ptr_from_PyObject(cfunc_self);
+                while (rec != nullptr) {
+                    if (rec->is_stateless
+                        && same_type(typeid(function_type),
+                                     *reinterpret_cast<const std::type_info *>(rec->data[1]))) {
+                        struct capture {
+                            function_type f;
+
+                            static capture *from_data(void **data) {
+                                return PYBIND11_STD_LAUNDER(reinterpret_cast<capture *>(data));
+                            }
+                        };
+                        PYBIND11_ENSURE_PRECONDITION_FOR_FUNCTIONAL_H_PERFORMANCE_OPTIMIZATIONS(
+                            std::is_standard_layout<capture>::value);
+                        value = capture::from_data(rec->data)->f;
+                        return true;
+                    }
+                    rec = rec->next;
+                }
+            }
+            // PYPY segfaults here when passing builtin function like sum.
+            // Raising an fail exception here works to prevent the segfault, but only on gcc.
+            // See PR #1413 for full details
+        }
+
+        value = type_caster_std_function_specializations::func_wrapper<Return, Args...>(
+            type_caster_std_function_specializations::func_handle(std::move(func)));
+        return true;
+    }
+
+    template <typename Func>
+    static handle cast(Func &&f_, return_value_policy policy, handle /* parent */) {
+        if (!f_) {
+            return none().release();
+        }
+
+        auto result = f_.template target<function_type>();
+        if (result) {
+            return cpp_function(*result, policy).release();
+        }
+        return cpp_function(std::forward<Func>(f_), policy).release();
+    }
+
+    PYBIND11_TYPE_CASTER(
+        type,
+        const_name("collections.abc.Callable[[")
+            + ::pybind11::detail::concat(::pybind11::detail::arg_descr(make_caster<Args>::name)...)
+            + const_name("], ") + ::pybind11::detail::return_descr(make_caster<retval_type>::name)
+            + const_name("]"));
+};
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/gil.h b/local_pybind11/pybind11/include/pybind11/gil.h
new file mode 100644
index 000000000..4222a035f
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/gil.h
@@ -0,0 +1,199 @@
+/*
+    pybind11/gil.h: RAII helpers for managing the GIL
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#if defined(PYBIND11_SIMPLE_GIL_MANAGEMENT)
+
+#    include "detail/common.h"
+#    include "gil_simple.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+using gil_scoped_acquire = gil_scoped_acquire_simple;
+using gil_scoped_release = gil_scoped_release_simple;
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
+
+#else
+
+#    include "detail/common.h"
+#    include "detail/internals.h"
+
+#    include <cassert>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+PYBIND11_WARNING_PUSH
+PYBIND11_WARNING_DISABLE_GCC("-Wredundant-decls")
+
+// forward declarations
+PyThreadState *get_thread_state_unchecked();
+
+PYBIND11_WARNING_POP
+
+PYBIND11_NAMESPACE_END(detail)
+
+/* The functions below essentially reproduce the PyGILState_* API using a RAII
+ * pattern, but there are a few important differences:
+ *
+ * 1. When acquiring the GIL from an non-main thread during the finalization
+ *    phase, the GILState API blindly terminates the calling thread, which
+ *    is often not what is wanted. This API does not do this.
+ *
+ * 2. The gil_scoped_release function can optionally cut the relationship
+ *    of a PyThreadState and its associated thread, which allows moving it to
+ *    another thread (this is a fairly rare/advanced use case).
+ *
+ * 3. The reference count of an acquired thread state can be controlled. This
+ *    can be handy to prevent cases where callbacks issued from an external
+ *    thread would otherwise constantly construct and destroy thread state data
+ *    structures.
+ *
+ * See the Python bindings of NanoGUI (http://github.com/wjakob/nanogui) for an
+ * example which uses features 2 and 3 to migrate the Python thread of
+ * execution to another thread (to run the event loop on the original thread,
+ * in this case).
+ */
+
+class gil_scoped_acquire {
+public:
+    PYBIND11_NOINLINE gil_scoped_acquire() {
+        auto &internals = detail::get_internals();
+        tstate = internals.tstate.get();
+
+        if (!tstate) {
+            /* Check if the GIL was acquired using the PyGILState_* API instead (e.g. if
+               calling from a Python thread). Since we use a different key, this ensures
+               we don't create a new thread state and deadlock in PyEval_AcquireThread
+               below. Note we don't save this state with internals.tstate, since we don't
+               create it we would fail to clear it (its reference count should be > 0). */
+            tstate = PyGILState_GetThisThreadState();
+        }
+
+        if (!tstate) {
+            tstate = PyThreadState_New(internals.istate);
+#    if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+            if (!tstate) {
+                pybind11_fail("scoped_acquire: could not create thread state!");
+            }
+#    endif
+            tstate->gilstate_counter = 0;
+            internals.tstate = tstate;
+        } else {
+            release = detail::get_thread_state_unchecked() != tstate;
+        }
+
+        if (release) {
+            PyEval_AcquireThread(tstate);
+        }
+
+        inc_ref();
+    }
+
+    gil_scoped_acquire(const gil_scoped_acquire &) = delete;
+    gil_scoped_acquire &operator=(const gil_scoped_acquire &) = delete;
+
+    void inc_ref() { ++tstate->gilstate_counter; }
+
+    PYBIND11_NOINLINE void dec_ref() {
+        --tstate->gilstate_counter;
+#    if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+        if (detail::get_thread_state_unchecked() != tstate) {
+            pybind11_fail("scoped_acquire::dec_ref(): thread state must be current!");
+        }
+        if (tstate->gilstate_counter < 0) {
+            pybind11_fail("scoped_acquire::dec_ref(): reference count underflow!");
+        }
+#    endif
+        if (tstate->gilstate_counter == 0) {
+#    if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+            if (!release) {
+                pybind11_fail("scoped_acquire::dec_ref(): internal error!");
+            }
+#    endif
+            PyThreadState_Clear(tstate);
+            if (active) {
+                PyThreadState_DeleteCurrent();
+            }
+            detail::get_internals().tstate.reset();
+            release = false;
+        }
+    }
+
+    /// This method will disable the PyThreadState_DeleteCurrent call and the
+    /// GIL won't be released. This method should be used if the interpreter
+    /// could be shutting down when this is called, as thread deletion is not
+    /// allowed during shutdown. Check _Py_IsFinalizing() on Python 3.7+, and
+    /// protect subsequent code.
+    PYBIND11_NOINLINE void disarm() { active = false; }
+
+    PYBIND11_NOINLINE ~gil_scoped_acquire() {
+        dec_ref();
+        if (release) {
+            PyEval_SaveThread();
+        }
+    }
+
+private:
+    PyThreadState *tstate = nullptr;
+    bool release = true;
+    bool active = true;
+};
+
+class gil_scoped_release {
+public:
+    // PRECONDITION: The GIL must be held when this constructor is called.
+    explicit gil_scoped_release(bool disassoc = false) : disassoc(disassoc) {
+        assert(PyGILState_Check());
+        // `get_internals()` must be called here unconditionally in order to initialize
+        // `internals.tstate` for subsequent `gil_scoped_acquire` calls. Otherwise, an
+        // initialization race could occur as multiple threads try `gil_scoped_acquire`.
+        auto &internals = detail::get_internals();
+        // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
+        tstate = PyEval_SaveThread();
+        if (disassoc) {
+            internals.tstate.reset();
+        }
+    }
+
+    gil_scoped_release(const gil_scoped_release &) = delete;
+    gil_scoped_release &operator=(const gil_scoped_release &) = delete;
+
+    /// This method will disable the PyThreadState_DeleteCurrent call and the
+    /// GIL won't be acquired. This method should be used if the interpreter
+    /// could be shutting down when this is called, as thread deletion is not
+    /// allowed during shutdown. Check _Py_IsFinalizing() on Python 3.7+, and
+    /// protect subsequent code.
+    PYBIND11_NOINLINE void disarm() { active = false; }
+
+    ~gil_scoped_release() {
+        if (!tstate) {
+            return;
+        }
+        // `PyEval_RestoreThread()` should not be called if runtime is finalizing
+        if (active) {
+            PyEval_RestoreThread(tstate);
+        }
+        if (disassoc) {
+            detail::get_internals().tstate = tstate;
+        }
+    }
+
+private:
+    PyThreadState *tstate;
+    bool disassoc;
+    bool active = true;
+};
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
+
+#endif // !PYBIND11_SIMPLE_GIL_MANAGEMENT
diff --git a/local_pybind11/pybind11/include/pybind11/gil_safe_call_once.h b/local_pybind11/pybind11/include/pybind11/gil_safe_call_once.h
new file mode 100644
index 000000000..44e68f029
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/gil_safe_call_once.h
@@ -0,0 +1,102 @@
+// Copyright (c) 2023 The pybind Community.
+
+#pragma once
+
+#include "detail/common.h"
+#include "gil.h"
+
+#include <cassert>
+#include <mutex>
+
+#ifdef Py_GIL_DISABLED
+#    include <atomic>
+#endif
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+// Use the `gil_safe_call_once_and_store` class below instead of the naive
+//
+//   static auto imported_obj = py::module_::import("module_name"); // BAD, DO NOT USE!
+//
+// which has two serious issues:
+//
+//     1. Py_DECREF() calls potentially after the Python interpreter was finalized already, and
+//     2. deadlocks in multi-threaded processes (because of missing lock ordering).
+//
+// The following alternative avoids both problems:
+//
+//   PYBIND11_CONSTINIT static py::gil_safe_call_once_and_store<py::object> storage;
+//   auto &imported_obj = storage // Do NOT make this `static`!
+//       .call_once_and_store_result([]() {
+//           return py::module_::import("module_name");
+//       })
+//       .get_stored();
+//
+// The parameter of `call_once_and_store_result()` must be callable. It can make
+// CPython API calls, and in particular, it can temporarily release the GIL.
+//
+// `T` can be any C++ type, it does not have to involve CPython API types.
+//
+// The behavior with regard to signals, e.g. `SIGINT` (`KeyboardInterrupt`),
+// is not ideal. If the main thread is the one to actually run the `Callable`,
+// then a `KeyboardInterrupt` will interrupt it if it is running normal Python
+// code. The situation is different if a non-main thread runs the
+// `Callable`, and then the main thread starts waiting for it to complete:
+// a `KeyboardInterrupt` will not interrupt the non-main thread, but it will
+// get processed only when it is the main thread's turn again and it is running
+// normal Python code. However, this will be unnoticeable for quick call-once
+// functions, which is usually the case.
+//
+// For in-depth background, see docs/advanced/deadlock.md
+template <typename T>
+class gil_safe_call_once_and_store {
+public:
+    // PRECONDITION: The GIL must be held when `call_once_and_store_result()` is called.
+    template <typename Callable>
+    gil_safe_call_once_and_store &call_once_and_store_result(Callable &&fn) {
+        if (!is_initialized_) { // This read is guarded by the GIL.
+            // Multiple threads may enter here, because the GIL is released in the next line and
+            // CPython API calls in the `fn()` call below may release and reacquire the GIL.
+            gil_scoped_release gil_rel; // Needed to establish lock ordering.
+            std::call_once(once_flag_, [&] {
+                // Only one thread will ever enter here.
+                gil_scoped_acquire gil_acq;
+                ::new (storage_) T(fn()); // fn may release, but will reacquire, the GIL.
+                is_initialized_ = true;   // This write is guarded by the GIL.
+            });
+            // All threads will observe `is_initialized_` as true here.
+        }
+        // Intentionally not returning `T &` to ensure the calling code is self-documenting.
+        return *this;
+    }
+
+    // This must only be called after `call_once_and_store_result()` was called.
+    T &get_stored() {
+        assert(is_initialized_);
+        PYBIND11_WARNING_PUSH
+#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ < 5
+        // Needed for gcc 4.8.5
+        PYBIND11_WARNING_DISABLE_GCC("-Wstrict-aliasing")
+#endif
+        return *reinterpret_cast<T *>(storage_);
+        PYBIND11_WARNING_POP
+    }
+
+    constexpr gil_safe_call_once_and_store() = default;
+    PYBIND11_DTOR_CONSTEXPR ~gil_safe_call_once_and_store() = default;
+
+private:
+    alignas(T) char storage_[sizeof(T)] = {};
+    std::once_flag once_flag_ = {};
+#ifdef Py_GIL_DISABLED
+    std::atomic_bool
+#else
+    bool
+#endif
+        is_initialized_{false};
+    // The `is_initialized_`-`storage_` pair is very similar to `std::optional`,
+    // but the latter does not have the triviality properties of former,
+    // therefore `std::optional` is not a viable alternative here.
+};
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/gil_simple.h b/local_pybind11/pybind11/include/pybind11/gil_simple.h
new file mode 100644
index 000000000..9ff428ad8
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/gil_simple.h
@@ -0,0 +1,37 @@
+// Copyright (c) 2016-2025 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#pragma once
+
+#include "detail/common.h"
+
+#include <cassert>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+class gil_scoped_acquire_simple {
+    PyGILState_STATE state;
+
+public:
+    gil_scoped_acquire_simple() : state{PyGILState_Ensure()} {}
+    gil_scoped_acquire_simple(const gil_scoped_acquire_simple &) = delete;
+    gil_scoped_acquire_simple &operator=(const gil_scoped_acquire_simple &) = delete;
+    ~gil_scoped_acquire_simple() { PyGILState_Release(state); }
+};
+
+class gil_scoped_release_simple {
+    PyThreadState *state;
+
+public:
+    // PRECONDITION: The GIL must be held when this constructor is called.
+    gil_scoped_release_simple() {
+        assert(PyGILState_Check());
+        state = PyEval_SaveThread();
+    }
+    gil_scoped_release_simple(const gil_scoped_release_simple &) = delete;
+    gil_scoped_release_simple &operator=(const gil_scoped_release_simple &) = delete;
+    ~gil_scoped_release_simple() { PyEval_RestoreThread(state); }
+};
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/iostream.h b/local_pybind11/pybind11/include/pybind11/iostream.h
new file mode 100644
index 000000000..1878089e3
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/iostream.h
@@ -0,0 +1,265 @@
+/*
+    pybind11/iostream.h -- Tools to assist with redirecting cout and cerr to Python
+
+    Copyright (c) 2017 Henry F. Schreiner
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+
+    WARNING: The implementation in this file is NOT thread safe. Multiple
+    threads writing to a redirected ostream concurrently cause data races
+    and potentially buffer overflows. Therefore it is currently a requirement
+    that all (possibly) concurrent redirected ostream writes are protected by
+    a mutex.
+    #HelpAppreciated: Work on iostream.h thread safety.
+    For more background see the discussions under
+    https://github.com/pybind/pybind11/pull/2982 and
+    https://github.com/pybind/pybind11/pull/2995.
+*/
+
+#pragma once
+
+#include "pybind11.h"
+
+#include <algorithm>
+#include <cstring>
+#include <iostream>
+#include <iterator>
+#include <memory>
+#include <ostream>
+#include <streambuf>
+#include <string>
+#include <utility>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+// Buffer that writes to Python instead of C++
+class pythonbuf : public std::streambuf {
+private:
+    using traits_type = std::streambuf::traits_type;
+
+    const size_t buf_size;
+    std::unique_ptr<char[]> d_buffer;
+    object pywrite;
+    object pyflush;
+
+    int overflow(int c) override {
+        if (!traits_type::eq_int_type(c, traits_type::eof())) {
+            *pptr() = traits_type::to_char_type(c);
+            pbump(1);
+        }
+        return sync() == 0 ? traits_type::not_eof(c) : traits_type::eof();
+    }
+
+    // Computes how many bytes at the end of the buffer are part of an
+    // incomplete sequence of UTF-8 bytes.
+    // Precondition: pbase() < pptr()
+    size_t utf8_remainder() const {
+        const auto rbase = std::reverse_iterator<char *>(pbase());
+        const auto rpptr = std::reverse_iterator<char *>(pptr());
+        auto is_ascii = [](char c) { return (static_cast<unsigned char>(c) & 0x80) == 0x00; };
+        auto is_leading = [](char c) { return (static_cast<unsigned char>(c) & 0xC0) == 0xC0; };
+        auto is_leading_2b = [](char c) { return static_cast<unsigned char>(c) <= 0xDF; };
+        auto is_leading_3b = [](char c) { return static_cast<unsigned char>(c) <= 0xEF; };
+        // If the last character is ASCII, there are no incomplete code points
+        if (is_ascii(*rpptr)) {
+            return 0;
+        }
+        // Otherwise, work back from the end of the buffer and find the first
+        // UTF-8 leading byte
+        const auto rpend = rbase - rpptr >= 3 ? rpptr + 3 : rbase;
+        const auto leading = std::find_if(rpptr, rpend, is_leading);
+        if (leading == rbase) {
+            return 0;
+        }
+        const auto dist = static_cast<size_t>(leading - rpptr);
+        size_t remainder = 0;
+
+        if (dist == 0) {
+            remainder = 1; // 1-byte code point is impossible
+        } else if (dist == 1) {
+            remainder = is_leading_2b(*leading) ? 0 : dist + 1;
+        } else if (dist == 2) {
+            remainder = is_leading_3b(*leading) ? 0 : dist + 1;
+        }
+        // else if (dist >= 3), at least 4 bytes before encountering an UTF-8
+        // leading byte, either no remainder or invalid UTF-8.
+        // Invalid UTF-8 will cause an exception later when converting
+        // to a Python string, so that's not handled here.
+        return remainder;
+    }
+
+    // This function must be non-virtual to be called in a destructor.
+    int _sync() {
+        if (pbase() != pptr()) { // If buffer is not empty
+            gil_scoped_acquire tmp;
+            // This subtraction cannot be negative, so dropping the sign.
+            auto size = static_cast<size_t>(pptr() - pbase());
+            size_t remainder = utf8_remainder();
+
+            if (size > remainder) {
+                str line(pbase(), size - remainder);
+                pywrite(std::move(line));
+                pyflush();
+            }
+
+            // Copy the remainder at the end of the buffer to the beginning:
+            if (remainder > 0) {
+                std::memmove(pbase(), pptr() - remainder, remainder);
+            }
+            setp(pbase(), epptr());
+            pbump(static_cast<int>(remainder));
+        }
+        return 0;
+    }
+
+    int sync() override { return _sync(); }
+
+public:
+    explicit pythonbuf(const object &pyostream, size_t buffer_size = 1024)
+        : buf_size(buffer_size), d_buffer(new char[buf_size]), pywrite(pyostream.attr("write")),
+          pyflush(pyostream.attr("flush")) {
+        setp(d_buffer.get(), d_buffer.get() + buf_size - 1);
+    }
+
+    pythonbuf(pythonbuf &&) = default;
+
+    /// Sync before destroy
+    ~pythonbuf() override { _sync(); }
+};
+
+PYBIND11_NAMESPACE_END(detail)
+
+/** \rst
+    This a move-only guard that redirects output.
+
+    .. code-block:: cpp
+
+        #include <pybind11/iostream.h>
+
+        ...
+
+        {
+            py::scoped_ostream_redirect output;
+            std::cout << "Hello, World!"; // Python stdout
+        } // <-- return std::cout to normal
+
+    You can explicitly pass the c++ stream and the python object,
+    for example to guard stderr instead.
+
+    .. code-block:: cpp
+
+        {
+            py::scoped_ostream_redirect output{
+                std::cerr, py::module::import("sys").attr("stderr")};
+            std::cout << "Hello, World!";
+        }
+ \endrst */
+class scoped_ostream_redirect {
+protected:
+    std::streambuf *old;
+    std::ostream &costream;
+    detail::pythonbuf buffer;
+
+public:
+    explicit scoped_ostream_redirect(std::ostream &costream = std::cout,
+                                     const object &pyostream
+                                     = module_::import("sys").attr("stdout"))
+        : costream(costream), buffer(pyostream) {
+        old = costream.rdbuf(&buffer);
+    }
+
+    ~scoped_ostream_redirect() { costream.rdbuf(old); }
+
+    scoped_ostream_redirect(const scoped_ostream_redirect &) = delete;
+    scoped_ostream_redirect(scoped_ostream_redirect &&other) = default;
+    scoped_ostream_redirect &operator=(const scoped_ostream_redirect &) = delete;
+    scoped_ostream_redirect &operator=(scoped_ostream_redirect &&) = delete;
+};
+
+/** \rst
+    Like `scoped_ostream_redirect`, but redirects cerr by default. This class
+    is provided primary to make ``py::call_guard`` easier to make.
+
+    .. code-block:: cpp
+
+     m.def("noisy_func", &noisy_func,
+           py::call_guard<scoped_ostream_redirect,
+                          scoped_estream_redirect>());
+
+\endrst */
+class scoped_estream_redirect : public scoped_ostream_redirect {
+public:
+    explicit scoped_estream_redirect(std::ostream &costream = std::cerr,
+                                     const object &pyostream
+                                     = module_::import("sys").attr("stderr"))
+        : scoped_ostream_redirect(costream, pyostream) {}
+};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+// Class to redirect output as a context manager. C++ backend.
+class OstreamRedirect {
+    bool do_stdout_;
+    bool do_stderr_;
+    std::unique_ptr<scoped_ostream_redirect> redirect_stdout;
+    std::unique_ptr<scoped_estream_redirect> redirect_stderr;
+
+public:
+    explicit OstreamRedirect(bool do_stdout = true, bool do_stderr = true)
+        : do_stdout_(do_stdout), do_stderr_(do_stderr) {}
+
+    void enter() {
+        if (do_stdout_) {
+            redirect_stdout.reset(new scoped_ostream_redirect());
+        }
+        if (do_stderr_) {
+            redirect_stderr.reset(new scoped_estream_redirect());
+        }
+    }
+
+    void exit() {
+        redirect_stdout.reset();
+        redirect_stderr.reset();
+    }
+};
+
+PYBIND11_NAMESPACE_END(detail)
+
+/** \rst
+    This is a helper function to add a C++ redirect context manager to Python
+    instead of using a C++ guard. To use it, add the following to your binding code:
+
+    .. code-block:: cpp
+
+        #include <pybind11/iostream.h>
+
+        ...
+
+        py::add_ostream_redirect(m, "ostream_redirect");
+
+    You now have a Python context manager that redirects your output:
+
+    .. code-block:: python
+
+        with m.ostream_redirect():
+            m.print_to_cout_function()
+
+    This manager can optionally be told which streams to operate on:
+
+    .. code-block:: python
+
+        with m.ostream_redirect(stdout=true, stderr=true):
+            m.noisy_function_with_error_printing()
+
+ \endrst */
+inline class_<detail::OstreamRedirect>
+add_ostream_redirect(module_ m, const std::string &name = "ostream_redirect") {
+    return class_<detail::OstreamRedirect>(std::move(m), name.c_str(), module_local())
+        .def(init<bool, bool>(), arg("stdout") = true, arg("stderr") = true)
+        .def("__enter__", &detail::OstreamRedirect::enter)
+        .def("__exit__", [](detail::OstreamRedirect &self_, const args &) { self_.exit(); });
+}
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/native_enum.h b/local_pybind11/pybind11/include/pybind11/native_enum.h
new file mode 100644
index 000000000..5537218f2
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/native_enum.h
@@ -0,0 +1,67 @@
+// Copyright (c) 2022-2025 The pybind Community.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#pragma once
+
+#include "detail/common.h"
+#include "detail/native_enum_data.h"
+#include "detail/type_caster_base.h"
+#include "cast.h"
+
+#include <cassert>
+#include <limits>
+#include <type_traits>
+#include <typeindex>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+/// Conversions between Python's native (stdlib) enum types and C++ enums.
+template <typename EnumType>
+class native_enum : public detail::native_enum_data {
+public:
+    using Underlying = typename std::underlying_type<EnumType>::type;
+
+    native_enum(const object &parent_scope,
+                const char *name,
+                const char *native_type_name,
+                const char *class_doc = "")
+        : detail::native_enum_data(
+              parent_scope, name, native_type_name, class_doc, std::type_index(typeid(EnumType))) {
+        if (detail::get_local_type_info(typeid(EnumType)) != nullptr
+            || detail::get_global_type_info(typeid(EnumType)) != nullptr) {
+            pybind11_fail(
+                "pybind11::native_enum<...>(\"" + enum_name_encoded
+                + "\") is already registered as a `pybind11::enum_` or `pybind11::class_`!");
+        }
+        if (detail::global_internals_native_enum_type_map_contains(enum_type_index)) {
+            pybind11_fail("pybind11::native_enum<...>(\"" + enum_name_encoded
+                          + "\") is already registered!");
+        }
+        arm_finalize_check();
+    }
+
+    /// Export enumeration entries into the parent scope
+    native_enum &export_values() {
+        assert(!export_values_flag); // Catch redundant calls.
+        export_values_flag = true;
+        return *this;
+    }
+
+    /// Add an enumeration entry
+    native_enum &value(char const *name, EnumType value, const char *doc = nullptr) {
+        // Disarm for the case that the native_enum_data dtor runs during exception unwinding.
+        disarm_finalize_check("value after finalize");
+        members.append(make_tuple(name, static_cast<Underlying>(value)));
+        if (doc) {
+            member_docs.append(make_tuple(name, doc));
+        }
+        arm_finalize_check(); // There was no exception.
+        return *this;
+    }
+
+    native_enum(const native_enum &) = delete;
+    native_enum &operator=(const native_enum &) = delete;
+};
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/numpy.h b/local_pybind11/pybind11/include/pybind11/numpy.h
new file mode 100644
index 000000000..7f62157f5
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/numpy.h
@@ -0,0 +1,2312 @@
+/*
+    pybind11/numpy.h: Basic NumPy support, vectorize() wrapper
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "pybind11.h"
+#include "detail/common.h"
+#include "complex.h"
+#include "gil_safe_call_once.h"
+#include "pytypes.h"
+
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <functional>
+#include <numeric>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <typeindex>
+#include <utility>
+#include <vector>
+
+#if defined(PYBIND11_NUMPY_1_ONLY)
+#    error "PYBIND11_NUMPY_1_ONLY is no longer supported (see PR #5595)."
+#endif
+
+/* This will be true on all flat address space platforms and allows us to reduce the
+   whole npy_intp / ssize_t / Py_intptr_t business down to just ssize_t for all size
+   and dimension types (e.g. shape, strides, indexing), instead of inflicting this
+   upon the library user.
+   Note that NumPy 2 now uses ssize_t for `npy_intp` to simplify this. */
+static_assert(sizeof(::pybind11::ssize_t) == sizeof(Py_intptr_t), "ssize_t != Py_intptr_t");
+static_assert(std::is_signed<Py_intptr_t>::value, "Py_intptr_t must be signed");
+// We now can reinterpret_cast between py::ssize_t and Py_intptr_t (MSVC + PyPy cares)
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+PYBIND11_WARNING_DISABLE_MSVC(4127)
+
+class dtype; // Forward declaration
+class array; // Forward declaration
+
+template <typename>
+struct numpy_scalar; // Forward declaration
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+template <>
+struct handle_type_name<dtype> {
+    static constexpr auto name = const_name("numpy.dtype");
+};
+
+template <>
+struct handle_type_name<array> {
+    static constexpr auto name = const_name("numpy.ndarray");
+};
+
+template <typename type, typename SFINAE = void>
+struct npy_format_descriptor;
+
+/* NumPy 1 proxy (always includes legacy fields) */
+struct PyArrayDescr1_Proxy {
+    PyObject_HEAD
+    PyObject *typeobj;
+    char kind;
+    char type;
+    char byteorder;
+    char flags;
+    int type_num;
+    int elsize;
+    int alignment;
+    char *subarray;
+    PyObject *fields;
+    PyObject *names;
+};
+
+struct PyArrayDescr_Proxy {
+    PyObject_HEAD
+    PyObject *typeobj;
+    char kind;
+    char type;
+    char byteorder;
+    char _former_flags;
+    int type_num;
+    /* Additional fields are NumPy version specific. */
+};
+
+/* NumPy 2 proxy, including legacy fields */
+struct PyArrayDescr2_Proxy {
+    PyObject_HEAD
+    PyObject *typeobj;
+    char kind;
+    char type;
+    char byteorder;
+    char _former_flags;
+    int type_num;
+    std::uint64_t flags;
+    ssize_t elsize;
+    ssize_t alignment;
+    PyObject *metadata;
+    Py_hash_t hash;
+    void *reserved_null[2];
+    /* The following fields only exist if 0 <= type_num < 2056 */
+    char *subarray;
+    PyObject *fields;
+    PyObject *names;
+};
+
+struct PyArray_Proxy {
+    PyObject_HEAD
+    char *data;
+    int nd;
+    ssize_t *dimensions;
+    ssize_t *strides;
+    PyObject *base;
+    PyObject *descr;
+    int flags;
+};
+
+struct PyVoidScalarObject_Proxy {
+    PyObject_VAR_HEAD char *obval;
+    PyArrayDescr_Proxy *descr;
+    int flags;
+    PyObject *base;
+};
+
+struct numpy_type_info {
+    PyObject *dtype_ptr;
+    std::string format_str;
+};
+
+struct numpy_internals {
+    std::unordered_map<std::type_index, numpy_type_info> registered_dtypes;
+
+    numpy_type_info *get_type_info(const std::type_info &tinfo, bool throw_if_missing = true) {
+        auto it = registered_dtypes.find(std::type_index(tinfo));
+        if (it != registered_dtypes.end()) {
+            return &(it->second);
+        }
+        if (throw_if_missing) {
+            pybind11_fail(std::string("NumPy type info missing for ") + tinfo.name());
+        }
+        return nullptr;
+    }
+
+    template <typename T>
+    numpy_type_info *get_type_info(bool throw_if_missing = true) {
+        return get_type_info(typeid(typename std::remove_cv<T>::type), throw_if_missing);
+    }
+};
+
+PYBIND11_NOINLINE void load_numpy_internals(numpy_internals *&ptr) {
+    ptr = &get_or_create_shared_data<numpy_internals>("_numpy_internals");
+}
+
+inline numpy_internals &get_numpy_internals() {
+    static numpy_internals *ptr = nullptr;
+    if (!ptr) {
+        load_numpy_internals(ptr);
+    }
+    return *ptr;
+}
+
+PYBIND11_NOINLINE module_ import_numpy_core_submodule(const char *submodule_name) {
+    module_ numpy = module_::import("numpy");
+    str version_string = numpy.attr("__version__");
+    module_ numpy_lib = module_::import("numpy.lib");
+    object numpy_version = numpy_lib.attr("NumpyVersion")(version_string);
+    int major_version = numpy_version.attr("major").cast<int>();
+
+    /* `numpy.core` was renamed to `numpy._core` in NumPy 2.0 as it officially
+        became a private module. */
+    std::string numpy_core_path = major_version >= 2 ? "numpy._core" : "numpy.core";
+    return module_::import((numpy_core_path + "." + submodule_name).c_str());
+}
+
+template <typename T>
+struct same_size {
+    template <typename U>
+    using as = bool_constant<sizeof(T) == sizeof(U)>;
+};
+
+template <typename Concrete>
+constexpr int platform_lookup() {
+    return -1;
+}
+
+// Lookup a type according to its size, and return a value corresponding to the NumPy typenum.
+template <typename Concrete, typename T, typename... Ts, typename... Ints>
+constexpr int platform_lookup(int I, Ints... Is) {
+    return sizeof(Concrete) == sizeof(T) ? I : platform_lookup<Concrete, Ts...>(Is...);
+}
+
+struct npy_api {
+    // If you change this code, please review `normalized_dtype_num` below.
+    enum constants {
+        NPY_ARRAY_C_CONTIGUOUS_ = 0x0001,
+        NPY_ARRAY_F_CONTIGUOUS_ = 0x0002,
+        NPY_ARRAY_OWNDATA_ = 0x0004,
+        NPY_ARRAY_FORCECAST_ = 0x0010,
+        NPY_ARRAY_ENSUREARRAY_ = 0x0040,
+        NPY_ARRAY_ALIGNED_ = 0x0100,
+        NPY_ARRAY_WRITEABLE_ = 0x0400,
+        NPY_BOOL_ = 0,
+        NPY_BYTE_,
+        NPY_UBYTE_,
+        NPY_SHORT_,
+        NPY_USHORT_,
+        NPY_INT_,
+        NPY_UINT_,
+        NPY_LONG_,
+        NPY_ULONG_,
+        NPY_LONGLONG_,
+        NPY_ULONGLONG_,
+        NPY_FLOAT_,
+        NPY_DOUBLE_,
+        NPY_LONGDOUBLE_,
+        NPY_CFLOAT_,
+        NPY_CDOUBLE_,
+        NPY_CLONGDOUBLE_,
+        NPY_OBJECT_ = 17,
+        NPY_STRING_,
+        NPY_UNICODE_,
+        NPY_VOID_,
+        // Platform-dependent normalization
+        NPY_INT8_ = NPY_BYTE_,
+        NPY_UINT8_ = NPY_UBYTE_,
+        NPY_INT16_ = NPY_SHORT_,
+        NPY_UINT16_ = NPY_USHORT_,
+        // `npy_common.h` defines the integer aliases. In order, it checks:
+        // NPY_BITSOF_LONG, NPY_BITSOF_LONGLONG, NPY_BITSOF_INT, NPY_BITSOF_SHORT, NPY_BITSOF_CHAR
+        // and assigns the alias to the first matching size, so we should check in this order.
+        NPY_INT32_
+        = platform_lookup<std::int32_t, long, int, short>(NPY_LONG_, NPY_INT_, NPY_SHORT_),
+        NPY_UINT32_ = platform_lookup<std::uint32_t, unsigned long, unsigned int, unsigned short>(
+            NPY_ULONG_, NPY_UINT_, NPY_USHORT_),
+        NPY_INT64_
+        = platform_lookup<std::int64_t, long, long long, int>(NPY_LONG_, NPY_LONGLONG_, NPY_INT_),
+        NPY_UINT64_
+        = platform_lookup<std::uint64_t, unsigned long, unsigned long long, unsigned int>(
+            NPY_ULONG_, NPY_ULONGLONG_, NPY_UINT_),
+        NPY_FLOAT32_ = platform_lookup<float, double, float, long double>(
+            NPY_DOUBLE_, NPY_FLOAT_, NPY_LONGDOUBLE_),
+        NPY_FLOAT64_ = platform_lookup<double, double, float, long double>(
+            NPY_DOUBLE_, NPY_FLOAT_, NPY_LONGDOUBLE_),
+        NPY_COMPLEX64_
+        = platform_lookup<std::complex<float>,
+                          std::complex<double>,
+                          std::complex<float>,
+                          std::complex<long double>>(NPY_DOUBLE_, NPY_FLOAT_, NPY_LONGDOUBLE_),
+        NPY_COMPLEX128_
+        = platform_lookup<std::complex<double>,
+                          std::complex<double>,
+                          std::complex<float>,
+                          std::complex<long double>>(NPY_DOUBLE_, NPY_FLOAT_, NPY_LONGDOUBLE_),
+        NPY_CHAR_ = std::is_signed<char>::value ? NPY_BYTE_ : NPY_UBYTE_,
+    };
+
+    unsigned int PyArray_RUNTIME_VERSION_;
+
+    struct PyArray_Dims {
+        Py_intptr_t *ptr;
+        int len;
+    };
+
+    static npy_api &get() {
+        PYBIND11_CONSTINIT static gil_safe_call_once_and_store<npy_api> storage;
+        return storage.call_once_and_store_result(lookup).get_stored();
+    }
+
+    bool PyArray_Check_(PyObject *obj) const {
+        return PyObject_TypeCheck(obj, PyArray_Type_) != 0;
+    }
+    bool PyArrayDescr_Check_(PyObject *obj) const {
+        return PyObject_TypeCheck(obj, PyArrayDescr_Type_) != 0;
+    }
+
+    unsigned int (*PyArray_GetNDArrayCFeatureVersion_)();
+    PyObject *(*PyArray_DescrFromType_)(int);
+    PyObject *(*PyArray_TypeObjectFromType_)(int);
+    PyObject *(*PyArray_NewFromDescr_)(PyTypeObject *,
+                                       PyObject *,
+                                       int,
+                                       Py_intptr_t const *,
+                                       Py_intptr_t const *,
+                                       void *,
+                                       int,
+                                       PyObject *);
+    // Unused. Not removed because that affects ABI of the class.
+    PyObject *(*PyArray_DescrNewFromType_)(int);
+    int (*PyArray_CopyInto_)(PyObject *, PyObject *);
+    PyObject *(*PyArray_NewCopy_)(PyObject *, int);
+    PyTypeObject *PyArray_Type_;
+    PyTypeObject *PyVoidArrType_Type_;
+    PyTypeObject *PyArrayDescr_Type_;
+    PyObject *(*PyArray_DescrFromScalar_)(PyObject *);
+    PyObject *(*PyArray_Scalar_)(void *, PyObject *, PyObject *);
+    void (*PyArray_ScalarAsCtype_)(PyObject *, void *);
+    PyObject *(*PyArray_FromAny_)(PyObject *, PyObject *, int, int, int, PyObject *);
+    int (*PyArray_DescrConverter_)(PyObject *, PyObject **);
+    bool (*PyArray_EquivTypes_)(PyObject *, PyObject *);
+    PyObject *(*PyArray_Squeeze_)(PyObject *);
+    // Unused. Not removed because that affects ABI of the class.
+    int (*PyArray_SetBaseObject_)(PyObject *, PyObject *);
+    PyObject *(*PyArray_Resize_)(PyObject *, PyArray_Dims *, int, int);
+    PyObject *(*PyArray_Newshape_)(PyObject *, PyArray_Dims *, int);
+    PyObject *(*PyArray_View_)(PyObject *, PyObject *, PyObject *);
+
+private:
+    enum functions {
+        API_PyArray_GetNDArrayCFeatureVersion = 211,
+        API_PyArray_Type = 2,
+        API_PyArrayDescr_Type = 3,
+        API_PyVoidArrType_Type = 39,
+        API_PyArray_DescrFromType = 45,
+        API_PyArray_TypeObjectFromType = 46,
+        API_PyArray_DescrFromScalar = 57,
+        API_PyArray_Scalar = 60,
+        API_PyArray_ScalarAsCtype = 62,
+        API_PyArray_FromAny = 69,
+        API_PyArray_Resize = 80,
+        // CopyInto was slot 82 and 50 was effectively an alias. NumPy 2 removed 82.
+        API_PyArray_CopyInto = 50,
+        API_PyArray_NewCopy = 85,
+        API_PyArray_NewFromDescr = 94,
+        API_PyArray_DescrNewFromType = 96,
+        API_PyArray_Newshape = 135,
+        API_PyArray_Squeeze = 136,
+        API_PyArray_View = 137,
+        API_PyArray_DescrConverter = 174,
+        API_PyArray_EquivTypes = 182,
+        API_PyArray_SetBaseObject = 282
+    };
+
+    static npy_api lookup() {
+        module_ m = detail::import_numpy_core_submodule("multiarray");
+        auto c = m.attr("_ARRAY_API");
+        void **api_ptr = (void **) PyCapsule_GetPointer(c.ptr(), nullptr);
+        if (api_ptr == nullptr) {
+            raise_from(PyExc_SystemError, "FAILURE obtaining numpy _ARRAY_API pointer.");
+            throw error_already_set();
+        }
+        npy_api api;
+#define DECL_NPY_API(Func) api.Func##_ = (decltype(api.Func##_)) api_ptr[API_##Func];
+        DECL_NPY_API(PyArray_GetNDArrayCFeatureVersion);
+        api.PyArray_RUNTIME_VERSION_ = api.PyArray_GetNDArrayCFeatureVersion_();
+        if (api.PyArray_RUNTIME_VERSION_ < 0x7) {
+            pybind11_fail("pybind11 numpy support requires numpy >= 1.7.0");
+        }
+        DECL_NPY_API(PyArray_Type);
+        DECL_NPY_API(PyVoidArrType_Type);
+        DECL_NPY_API(PyArrayDescr_Type);
+        DECL_NPY_API(PyArray_DescrFromType);
+        DECL_NPY_API(PyArray_TypeObjectFromType);
+        DECL_NPY_API(PyArray_DescrFromScalar);
+        DECL_NPY_API(PyArray_Scalar);
+        DECL_NPY_API(PyArray_ScalarAsCtype);
+        DECL_NPY_API(PyArray_FromAny);
+        DECL_NPY_API(PyArray_Resize);
+        DECL_NPY_API(PyArray_CopyInto);
+        DECL_NPY_API(PyArray_NewCopy);
+        DECL_NPY_API(PyArray_NewFromDescr);
+        DECL_NPY_API(PyArray_DescrNewFromType);
+        DECL_NPY_API(PyArray_Newshape);
+        DECL_NPY_API(PyArray_Squeeze);
+        DECL_NPY_API(PyArray_View);
+        DECL_NPY_API(PyArray_DescrConverter);
+        DECL_NPY_API(PyArray_EquivTypes);
+        DECL_NPY_API(PyArray_SetBaseObject);
+
+#undef DECL_NPY_API
+        return api;
+    }
+};
+
+template <typename T>
+struct is_complex : std::false_type {};
+template <typename T>
+struct is_complex<std::complex<T>> : std::true_type {};
+
+template <typename T, typename = void>
+struct npy_format_descriptor_name;
+
+template <typename T>
+struct npy_format_descriptor_name<T, enable_if_t<std::is_integral<T>::value>> {
+    static constexpr auto name = const_name<std::is_same<T, bool>::value>(
+        const_name("numpy.bool"),
+        const_name<std::is_signed<T>::value>("numpy.int", "numpy.uint")
+            + const_name<sizeof(T) * 8>());
+};
+
+template <typename T>
+struct npy_format_descriptor_name<T, enable_if_t<std::is_floating_point<T>::value>> {
+    static constexpr auto name = const_name < std::is_same<T, float>::value
+                                 || std::is_same<T, const float>::value
+                                 || std::is_same<T, double>::value
+                                 || std::is_same<T, const double>::value
+                                        > (const_name("numpy.float") + const_name<sizeof(T) * 8>(),
+                                           const_name("numpy.longdouble"));
+};
+
+template <typename T>
+struct npy_format_descriptor_name<T, enable_if_t<is_complex<T>::value>> {
+    static constexpr auto name = const_name < std::is_same<typename T::value_type, float>::value
+                                 || std::is_same<typename T::value_type, const float>::value
+                                 || std::is_same<typename T::value_type, double>::value
+                                 || std::is_same<typename T::value_type, const double>::value
+                                        > (const_name("numpy.complex")
+                                               + const_name<sizeof(typename T::value_type) * 16>(),
+                                           const_name("numpy.longcomplex"));
+};
+
+template <typename T>
+struct numpy_scalar_info {};
+
+#define PYBIND11_NUMPY_SCALAR_IMPL(ctype_, typenum_)                                              \
+    template <>                                                                                   \
+    struct numpy_scalar_info<ctype_> {                                                            \
+        static constexpr auto name = npy_format_descriptor_name<ctype_>::name;                    \
+        static constexpr int typenum = npy_api::typenum_##_;                                      \
+    }
+
+// boolean type
+PYBIND11_NUMPY_SCALAR_IMPL(bool, NPY_BOOL);
+
+// character types
+PYBIND11_NUMPY_SCALAR_IMPL(char, NPY_CHAR);
+PYBIND11_NUMPY_SCALAR_IMPL(signed char, NPY_BYTE);
+PYBIND11_NUMPY_SCALAR_IMPL(unsigned char, NPY_UBYTE);
+
+// signed integer types
+PYBIND11_NUMPY_SCALAR_IMPL(std::int16_t, NPY_INT16);
+PYBIND11_NUMPY_SCALAR_IMPL(std::int32_t, NPY_INT32);
+PYBIND11_NUMPY_SCALAR_IMPL(std::int64_t, NPY_INT64);
+
+// unsigned integer types
+PYBIND11_NUMPY_SCALAR_IMPL(std::uint16_t, NPY_UINT16);
+PYBIND11_NUMPY_SCALAR_IMPL(std::uint32_t, NPY_UINT32);
+PYBIND11_NUMPY_SCALAR_IMPL(std::uint64_t, NPY_UINT64);
+
+// floating point types
+PYBIND11_NUMPY_SCALAR_IMPL(float, NPY_FLOAT);
+PYBIND11_NUMPY_SCALAR_IMPL(double, NPY_DOUBLE);
+PYBIND11_NUMPY_SCALAR_IMPL(long double, NPY_LONGDOUBLE);
+
+// complex types
+PYBIND11_NUMPY_SCALAR_IMPL(std::complex<float>, NPY_CFLOAT);
+PYBIND11_NUMPY_SCALAR_IMPL(std::complex<double>, NPY_CDOUBLE);
+PYBIND11_NUMPY_SCALAR_IMPL(std::complex<long double>, NPY_CLONGDOUBLE);
+
+#undef PYBIND11_NUMPY_SCALAR_IMPL
+
+// This table normalizes typenums by mapping NPY_INT_, NPY_LONG, ... to NPY_INT32_, NPY_INT64, ...
+// This is needed to correctly handle situations where multiple typenums map to the same type,
+// e.g. NPY_LONG_ may be equivalent to NPY_INT_ or NPY_LONGLONG_ despite having a different
+// typenum. The normalized typenum should always match the values used in npy_format_descriptor.
+// If you change this code, please review `enum constants` above.
+static constexpr int normalized_dtype_num[npy_api::NPY_VOID_ + 1] = {
+    // NPY_BOOL_ =>
+    npy_api::NPY_BOOL_,
+    // NPY_BYTE_ =>
+    npy_api::NPY_BYTE_,
+    // NPY_UBYTE_ =>
+    npy_api::NPY_UBYTE_,
+    // NPY_SHORT_ =>
+    npy_api::NPY_INT16_,
+    // NPY_USHORT_ =>
+    npy_api::NPY_UINT16_,
+    // NPY_INT_ =>
+    sizeof(int) == sizeof(std::int16_t)   ? npy_api::NPY_INT16_
+    : sizeof(int) == sizeof(std::int32_t) ? npy_api::NPY_INT32_
+    : sizeof(int) == sizeof(std::int64_t) ? npy_api::NPY_INT64_
+                                          : npy_api::NPY_INT_,
+    // NPY_UINT_ =>
+    sizeof(unsigned int) == sizeof(std::uint16_t)   ? npy_api::NPY_UINT16_
+    : sizeof(unsigned int) == sizeof(std::uint32_t) ? npy_api::NPY_UINT32_
+    : sizeof(unsigned int) == sizeof(std::uint64_t) ? npy_api::NPY_UINT64_
+                                                    : npy_api::NPY_UINT_,
+    // NPY_LONG_ =>
+    sizeof(long) == sizeof(std::int16_t)   ? npy_api::NPY_INT16_
+    : sizeof(long) == sizeof(std::int32_t) ? npy_api::NPY_INT32_
+    : sizeof(long) == sizeof(std::int64_t) ? npy_api::NPY_INT64_
+                                           : npy_api::NPY_LONG_,
+    // NPY_ULONG_ =>
+    sizeof(unsigned long) == sizeof(std::uint16_t)   ? npy_api::NPY_UINT16_
+    : sizeof(unsigned long) == sizeof(std::uint32_t) ? npy_api::NPY_UINT32_
+    : sizeof(unsigned long) == sizeof(std::uint64_t) ? npy_api::NPY_UINT64_
+                                                     : npy_api::NPY_ULONG_,
+    // NPY_LONGLONG_ =>
+    sizeof(long long) == sizeof(std::int16_t)   ? npy_api::NPY_INT16_
+    : sizeof(long long) == sizeof(std::int32_t) ? npy_api::NPY_INT32_
+    : sizeof(long long) == sizeof(std::int64_t) ? npy_api::NPY_INT64_
+                                                : npy_api::NPY_LONGLONG_,
+    // NPY_ULONGLONG_ =>
+    sizeof(unsigned long long) == sizeof(std::uint16_t)   ? npy_api::NPY_UINT16_
+    : sizeof(unsigned long long) == sizeof(std::uint32_t) ? npy_api::NPY_UINT32_
+    : sizeof(unsigned long long) == sizeof(std::uint64_t) ? npy_api::NPY_UINT64_
+                                                          : npy_api::NPY_ULONGLONG_,
+    // NPY_FLOAT_ =>
+    npy_api::NPY_FLOAT_,
+    // NPY_DOUBLE_ =>
+    npy_api::NPY_DOUBLE_,
+    // NPY_LONGDOUBLE_ =>
+    npy_api::NPY_LONGDOUBLE_,
+    // NPY_CFLOAT_ =>
+    npy_api::NPY_CFLOAT_,
+    // NPY_CDOUBLE_ =>
+    npy_api::NPY_CDOUBLE_,
+    // NPY_CLONGDOUBLE_ =>
+    npy_api::NPY_CLONGDOUBLE_,
+    // NPY_OBJECT_ =>
+    npy_api::NPY_OBJECT_,
+    // NPY_STRING_ =>
+    npy_api::NPY_STRING_,
+    // NPY_UNICODE_ =>
+    npy_api::NPY_UNICODE_,
+    // NPY_VOID_ =>
+    npy_api::NPY_VOID_,
+};
+
+inline PyArray_Proxy *array_proxy(void *ptr) { return reinterpret_cast<PyArray_Proxy *>(ptr); }
+
+inline const PyArray_Proxy *array_proxy(const void *ptr) {
+    return reinterpret_cast<const PyArray_Proxy *>(ptr);
+}
+
+inline PyArrayDescr_Proxy *array_descriptor_proxy(PyObject *ptr) {
+    return reinterpret_cast<PyArrayDescr_Proxy *>(ptr);
+}
+
+inline const PyArrayDescr_Proxy *array_descriptor_proxy(const PyObject *ptr) {
+    return reinterpret_cast<const PyArrayDescr_Proxy *>(ptr);
+}
+
+inline const PyArrayDescr1_Proxy *array_descriptor1_proxy(const PyObject *ptr) {
+    return reinterpret_cast<const PyArrayDescr1_Proxy *>(ptr);
+}
+
+inline const PyArrayDescr2_Proxy *array_descriptor2_proxy(const PyObject *ptr) {
+    return reinterpret_cast<const PyArrayDescr2_Proxy *>(ptr);
+}
+
+inline bool check_flags(const void *ptr, int flag) {
+    return (flag == (array_proxy(ptr)->flags & flag));
+}
+
+template <typename T>
+struct is_std_array : std::false_type {};
+template <typename T, size_t N>
+struct is_std_array<std::array<T, N>> : std::true_type {};
+
+template <typename T>
+struct array_info_scalar {
+    using type = T;
+    static constexpr bool is_array = false;
+    static constexpr bool is_empty = false;
+    static constexpr auto extents = const_name("");
+    static void append_extents(list & /* shape */) {}
+};
+// Computes underlying type and a comma-separated list of extents for array
+// types (any mix of std::array and built-in arrays). An array of char is
+// treated as scalar because it gets special handling.
+template <typename T>
+struct array_info : array_info_scalar<T> {};
+template <typename T, size_t N>
+struct array_info<std::array<T, N>> {
+    using type = typename array_info<T>::type;
+    static constexpr bool is_array = true;
+    static constexpr bool is_empty = (N == 0) || array_info<T>::is_empty;
+    static constexpr size_t extent = N;
+
+    // appends the extents to shape
+    static void append_extents(list &shape) {
+        shape.append(N);
+        array_info<T>::append_extents(shape);
+    }
+
+    static constexpr auto extents = const_name<array_info<T>::is_array>(
+        ::pybind11::detail::concat(const_name<N>(), array_info<T>::extents), const_name<N>());
+};
+// For numpy we have special handling for arrays of characters, so we don't include
+// the size in the array extents.
+template <size_t N>
+struct array_info<char[N]> : array_info_scalar<char[N]> {};
+template <size_t N>
+struct array_info<std::array<char, N>> : array_info_scalar<std::array<char, N>> {};
+template <typename T, size_t N>
+struct array_info<T[N]> : array_info<std::array<T, N>> {};
+template <typename T>
+using remove_all_extents_t = typename array_info<T>::type;
+
+template <typename T>
+using is_pod_struct
+    = all_of<std::is_standard_layout<T>, // since we're accessing directly in memory
+                                         // we need a standard layout type
+#if defined(__GLIBCXX__)                                                                          \
+    && (__GLIBCXX__ < 20150422 || __GLIBCXX__ == 20150426 || __GLIBCXX__ == 20150623              \
+        || __GLIBCXX__ == 20150626 || __GLIBCXX__ == 20160803)
+             // libstdc++ < 5 (including versions 4.8.5, 4.9.3 and 4.9.4 which were released after
+             // 5) don't implement is_trivially_copyable, so approximate it
+             std::is_trivially_destructible<T>,
+             satisfies_any_of<T, std::has_trivial_copy_constructor, std::has_trivial_copy_assign>,
+#else
+             std::is_trivially_copyable<T>,
+#endif
+             satisfies_none_of<T,
+                               std::is_reference,
+                               std::is_array,
+                               is_std_array,
+                               std::is_arithmetic,
+                               is_complex,
+                               std::is_enum>>;
+
+// Replacement for std::is_pod (deprecated in C++20)
+template <typename T>
+using is_pod = all_of<std::is_standard_layout<T>, std::is_trivial<T>>;
+
+template <ssize_t Dim = 0, typename Strides>
+ssize_t byte_offset_unsafe(const Strides &) {
+    return 0;
+}
+template <ssize_t Dim = 0, typename Strides, typename... Ix>
+ssize_t byte_offset_unsafe(const Strides &strides, ssize_t i, Ix... index) {
+    return i * strides[Dim] + byte_offset_unsafe<Dim + 1>(strides, index...);
+}
+
+/**
+ * Proxy class providing unsafe, unchecked const access to array data.  This is constructed through
+ * the `unchecked<T, N>()` method of `array` or the `unchecked<N>()` method of `array_t<T>`. `Dims`
+ * will be -1 for dimensions determined at runtime.
+ */
+template <typename T, ssize_t Dims>
+class unchecked_reference {
+protected:
+    static constexpr bool Dynamic = Dims < 0;
+    const unsigned char *data_;
+    // Storing the shape & strides in local variables (i.e. these arrays) allows the compiler to
+    // make large performance gains on big, nested loops, but requires compile-time dimensions
+    conditional_t<Dynamic, const ssize_t *, std::array<ssize_t, (size_t) Dims>> shape_, strides_;
+    const ssize_t dims_;
+
+    friend class pybind11::array;
+    // Constructor for compile-time dimensions:
+    template <bool Dyn = Dynamic>
+    unchecked_reference(const void *data,
+                        const ssize_t *shape,
+                        const ssize_t *strides,
+                        enable_if_t<!Dyn, ssize_t>)
+        : data_{reinterpret_cast<const unsigned char *>(data)}, dims_{Dims} {
+        for (size_t i = 0; i < (size_t) dims_; i++) {
+            shape_[i] = shape[i];
+            strides_[i] = strides[i];
+        }
+    }
+    // Constructor for runtime dimensions:
+    template <bool Dyn = Dynamic>
+    unchecked_reference(const void *data,
+                        const ssize_t *shape,
+                        const ssize_t *strides,
+                        enable_if_t<Dyn, ssize_t> dims)
+        : data_{reinterpret_cast<const unsigned char *>(data)}, shape_{shape}, strides_{strides},
+          dims_{dims} {}
+
+public:
+    /**
+     * Unchecked const reference access to data at the given indices.  For a compile-time known
+     * number of dimensions, this requires the correct number of arguments; for run-time
+     * dimensionality, this is not checked (and so is up to the caller to use safely).
+     */
+    template <typename... Ix>
+    const T &operator()(Ix... index) const {
+        static_assert(ssize_t{sizeof...(Ix)} == Dims || Dynamic,
+                      "Invalid number of indices for unchecked array reference");
+        return *reinterpret_cast<const T *>(data_
+                                            + byte_offset_unsafe(strides_, ssize_t(index)...));
+    }
+    /**
+     * Unchecked const reference access to data; this operator only participates if the reference
+     * is to a 1-dimensional array.  When present, this is exactly equivalent to `obj(index)`.
+     */
+    template <ssize_t D = Dims, typename = enable_if_t<D == 1 || Dynamic>>
+    const T &operator[](ssize_t index) const {
+        return operator()(index);
+    }
+
+    /// Pointer access to the data at the given indices.
+    template <typename... Ix>
+    const T *data(Ix... ix) const {
+        return &operator()(ssize_t(ix)...);
+    }
+
+    /// Returns the item size, i.e. sizeof(T)
+    constexpr static ssize_t itemsize() { return sizeof(T); }
+
+    /// Returns the shape (i.e. size) of dimension `dim`
+    ssize_t shape(ssize_t dim) const { return shape_[(size_t) dim]; }
+
+    /// Returns the number of dimensions of the array
+    ssize_t ndim() const { return dims_; }
+
+    /// Returns the total number of elements in the referenced array, i.e. the product of the
+    /// shapes
+    template <bool Dyn = Dynamic>
+    enable_if_t<!Dyn, ssize_t> size() const {
+        return std::accumulate(
+            shape_.begin(), shape_.end(), (ssize_t) 1, std::multiplies<ssize_t>());
+    }
+    template <bool Dyn = Dynamic>
+    enable_if_t<Dyn, ssize_t> size() const {
+        return std::accumulate(shape_, shape_ + ndim(), (ssize_t) 1, std::multiplies<ssize_t>());
+    }
+
+    /// Returns the total number of bytes used by the referenced data.  Note that the actual span
+    /// in memory may be larger if the referenced array has non-contiguous strides (e.g. for a
+    /// slice).
+    ssize_t nbytes() const { return size() * itemsize(); }
+};
+
+template <typename T, ssize_t Dims>
+class unchecked_mutable_reference : public unchecked_reference<T, Dims> {
+    friend class pybind11::array;
+    using ConstBase = unchecked_reference<T, Dims>;
+    using ConstBase::ConstBase;
+    using ConstBase::Dynamic;
+
+public:
+    // Bring in const-qualified versions from base class
+    using ConstBase::operator();
+    using ConstBase::operator[];
+
+    /// Mutable, unchecked access to data at the given indices.
+    template <typename... Ix>
+    T &operator()(Ix... index) {
+        static_assert(ssize_t{sizeof...(Ix)} == Dims || Dynamic,
+                      "Invalid number of indices for unchecked array reference");
+        return const_cast<T &>(ConstBase::operator()(index...));
+    }
+    /**
+     * Mutable, unchecked access data at the given index; this operator only participates if the
+     * reference is to a 1-dimensional array (or has runtime dimensions).  When present, this is
+     * exactly equivalent to `obj(index)`.
+     */
+    template <ssize_t D = Dims, typename = enable_if_t<D == 1 || Dynamic>>
+    T &operator[](ssize_t index) {
+        return operator()(index);
+    }
+
+    /// Mutable pointer access to the data at the given indices.
+    template <typename... Ix>
+    T *mutable_data(Ix... ix) {
+        return &operator()(ssize_t(ix)...);
+    }
+};
+
+template <typename T, ssize_t Dim>
+struct type_caster<unchecked_reference<T, Dim>> {
+    static_assert(Dim == 0 && Dim > 0 /* always fail */,
+                  "unchecked array proxy object is not castable");
+};
+template <typename T, ssize_t Dim>
+struct type_caster<unchecked_mutable_reference<T, Dim>>
+    : type_caster<unchecked_reference<T, Dim>> {};
+
+template <typename T>
+struct type_caster<numpy_scalar<T>> {
+    using value_type = T;
+    using type_info = numpy_scalar_info<T>;
+
+    PYBIND11_TYPE_CASTER(numpy_scalar<T>, type_info::name);
+
+    static handle &target_type() {
+        static handle tp = npy_api::get().PyArray_TypeObjectFromType_(type_info::typenum);
+        return tp;
+    }
+
+    static handle &target_dtype() {
+        static handle tp = npy_api::get().PyArray_DescrFromType_(type_info::typenum);
+        return tp;
+    }
+
+    bool load(handle src, bool) {
+        if (isinstance(src, target_type())) {
+            npy_api::get().PyArray_ScalarAsCtype_(src.ptr(), &value.value);
+            return true;
+        }
+        return false;
+    }
+
+    static handle cast(numpy_scalar<T> src, return_value_policy, handle) {
+        return npy_api::get().PyArray_Scalar_(&src.value, target_dtype().ptr(), nullptr);
+    }
+};
+
+PYBIND11_NAMESPACE_END(detail)
+
+template <typename T>
+struct numpy_scalar {
+    using value_type = T;
+
+    value_type value;
+
+    numpy_scalar() = default;
+    explicit numpy_scalar(value_type value) : value(value) {}
+
+    explicit operator value_type() const { return value; }
+    numpy_scalar &operator=(value_type value) {
+        this->value = value;
+        return *this;
+    }
+
+    friend bool operator==(const numpy_scalar &a, const numpy_scalar &b) {
+        return a.value == b.value;
+    }
+
+    friend bool operator!=(const numpy_scalar &a, const numpy_scalar &b) { return !(a == b); }
+};
+
+template <typename T>
+numpy_scalar<T> make_scalar(T value) {
+    return numpy_scalar<T>(value);
+}
+
+class dtype : public object {
+public:
+    PYBIND11_OBJECT_DEFAULT(dtype, object, detail::npy_api::get().PyArrayDescr_Check_)
+
+    explicit dtype(const buffer_info &info) {
+        dtype descr(_dtype_from_pep3118()(pybind11::str(info.format)));
+        // If info.itemsize == 0, use the value calculated from the format string
+        m_ptr = descr.strip_padding(info.itemsize != 0 ? info.itemsize : descr.itemsize())
+                    .release()
+                    .ptr();
+    }
+
+    explicit dtype(const pybind11::str &format) : dtype(from_args(format)) {}
+
+    explicit dtype(const std::string &format) : dtype(pybind11::str(format)) {}
+
+    explicit dtype(const char *format) : dtype(pybind11::str(format)) {}
+
+    dtype(list names, list formats, list offsets, ssize_t itemsize) {
+        dict args;
+        args["names"] = std::move(names);
+        args["formats"] = std::move(formats);
+        args["offsets"] = std::move(offsets);
+        args["itemsize"] = pybind11::int_(itemsize);
+        m_ptr = from_args(args).release().ptr();
+    }
+
+    /// Return dtype for the given typenum (one of the NPY_TYPES).
+    /// https://numpy.org/devdocs/reference/c-api/array.html#c.PyArray_DescrFromType
+    explicit dtype(int typenum)
+        : object(detail::npy_api::get().PyArray_DescrFromType_(typenum), stolen_t{}) {
+        if (m_ptr == nullptr) {
+            throw error_already_set();
+        }
+    }
+
+    /// This is essentially the same as calling numpy.dtype(args) in Python.
+    static dtype from_args(const object &args) {
+        PyObject *ptr = nullptr;
+        if ((detail::npy_api::get().PyArray_DescrConverter_(args.ptr(), &ptr) == 0) || !ptr) {
+            throw error_already_set();
+        }
+        return reinterpret_steal<dtype>(ptr);
+    }
+
+    /// Return dtype associated with a C++ type.
+    template <typename T>
+    static dtype of() {
+        return detail::npy_format_descriptor<typename std::remove_cv<T>::type>::dtype();
+    }
+
+    /// Return the type number associated with a C++ type.
+    /// This is the constexpr equivalent of `dtype::of<T>().num()`.
+    template <typename T>
+    static constexpr int num_of() {
+        return detail::npy_format_descriptor<typename std::remove_cv<T>::type>::value;
+    }
+
+    /// Size of the data type in bytes.
+    ssize_t itemsize() const {
+        if (detail::npy_api::get().PyArray_RUNTIME_VERSION_ < 0x12) {
+            return detail::array_descriptor1_proxy(m_ptr)->elsize;
+        }
+        return detail::array_descriptor2_proxy(m_ptr)->elsize;
+    }
+
+    /// Returns true for structured data types.
+    bool has_fields() const {
+        if (detail::npy_api::get().PyArray_RUNTIME_VERSION_ < 0x12) {
+            return detail::array_descriptor1_proxy(m_ptr)->names != nullptr;
+        }
+        const auto *proxy = detail::array_descriptor2_proxy(m_ptr);
+        if (proxy->type_num < 0 || proxy->type_num >= 2056) {
+            return false;
+        }
+        return proxy->names != nullptr;
+    }
+
+    /// Single-character code for dtype's kind.
+    /// For example, floating point types are 'f' and integral types are 'i'.
+    char kind() const { return detail::array_descriptor_proxy(m_ptr)->kind; }
+
+    /// Single-character for dtype's type.
+    /// For example, ``float`` is 'f', ``double`` 'd', ``int`` 'i', and ``long`` 'l'.
+    char char_() const {
+        // Note: The signature, `dtype::char_` follows the naming of NumPy's
+        // public Python API (i.e., ``dtype.char``), rather than its internal
+        // C API (``PyArray_Descr::type``).
+        return detail::array_descriptor_proxy(m_ptr)->type;
+    }
+
+    /// Type number of dtype. Note that different values may be returned for equivalent types,
+    /// e.g. even though ``long`` may be equivalent to ``int`` or ``long long``, they still have
+    /// different type numbers. Consider using `normalized_num` to avoid this.
+    int num() const {
+        // Note: The signature, `dtype::num` follows the naming of NumPy's public
+        // Python API (i.e., ``dtype.num``), rather than its internal
+        // C API (``PyArray_Descr::type_num``).
+        return detail::array_descriptor_proxy(m_ptr)->type_num;
+    }
+
+    /// Type number of dtype, normalized to match the return value of `num_of` for equivalent
+    /// types. This function can be used to write switch statements that correctly handle
+    /// equivalent types with different type numbers.
+    int normalized_num() const {
+        int value = num();
+        if (value >= 0 && value <= detail::npy_api::NPY_VOID_) {
+            return detail::normalized_dtype_num[value];
+        }
+        return value;
+    }
+
+    /// Single character for byteorder
+    char byteorder() const { return detail::array_descriptor_proxy(m_ptr)->byteorder; }
+
+    /// Alignment of the data type
+    ssize_t alignment() const {
+        if (detail::npy_api::get().PyArray_RUNTIME_VERSION_ < 0x12) {
+            return detail::array_descriptor1_proxy(m_ptr)->alignment;
+        }
+        return detail::array_descriptor2_proxy(m_ptr)->alignment;
+    }
+
+    /// Flags for the array descriptor
+    std::uint64_t flags() const {
+        if (detail::npy_api::get().PyArray_RUNTIME_VERSION_ < 0x12) {
+            return (unsigned char) detail::array_descriptor1_proxy(m_ptr)->flags;
+        }
+        return detail::array_descriptor2_proxy(m_ptr)->flags;
+    }
+
+private:
+    static object &_dtype_from_pep3118() {
+        PYBIND11_CONSTINIT static gil_safe_call_once_and_store<object> storage;
+        return storage
+            .call_once_and_store_result([]() {
+                return detail::import_numpy_core_submodule("_internal")
+                    .attr("_dtype_from_pep3118");
+            })
+            .get_stored();
+    }
+
+    dtype strip_padding(ssize_t itemsize) {
+        // Recursively strip all void fields with empty names that are generated for
+        // padding fields (as of NumPy v1.11).
+        if (!has_fields()) {
+            return *this;
+        }
+
+        struct field_descr {
+            pybind11::str name;
+            object format;
+            pybind11::int_ offset;
+            field_descr(pybind11::str &&name, object &&format, pybind11::int_ &&offset)
+                : name{std::move(name)}, format{std::move(format)}, offset{std::move(offset)} {};
+        };
+        auto field_dict = attr("fields").cast<dict>();
+        std::vector<field_descr> field_descriptors;
+        field_descriptors.reserve(field_dict.size());
+
+        for (auto field : field_dict.attr("items")()) {
+            auto spec = field.cast<tuple>();
+            auto name = spec[0].cast<pybind11::str>();
+            auto spec_fo = spec[1].cast<tuple>();
+            auto format = spec_fo[0].cast<dtype>();
+            auto offset = spec_fo[1].cast<pybind11::int_>();
+            if ((len(name) == 0u) && format.kind() == 'V') {
+                continue;
+            }
+            field_descriptors.emplace_back(
+                std::move(name), format.strip_padding(format.itemsize()), std::move(offset));
+        }
+
+        std::sort(field_descriptors.begin(),
+                  field_descriptors.end(),
+                  [](const field_descr &a, const field_descr &b) {
+                      return a.offset.cast<int>() < b.offset.cast<int>();
+                  });
+
+        list names, formats, offsets;
+        for (auto &descr : field_descriptors) {
+            names.append(std::move(descr.name));
+            formats.append(std::move(descr.format));
+            offsets.append(std::move(descr.offset));
+        }
+        return dtype(std::move(names), std::move(formats), std::move(offsets), itemsize);
+    }
+};
+
+class array : public buffer {
+public:
+    PYBIND11_OBJECT_CVT(array, buffer, detail::npy_api::get().PyArray_Check_, raw_array)
+
+    enum {
+        c_style = detail::npy_api::NPY_ARRAY_C_CONTIGUOUS_,
+        f_style = detail::npy_api::NPY_ARRAY_F_CONTIGUOUS_,
+        forcecast = detail::npy_api::NPY_ARRAY_FORCECAST_
+    };
+
+    array() : array(0, static_cast<const double *>(nullptr)) {}
+
+    using ShapeContainer = detail::any_container<ssize_t>;
+    using StridesContainer = detail::any_container<ssize_t>;
+
+    // Constructs an array taking shape/strides from arbitrary container types
+    array(const pybind11::dtype &dt,
+          ShapeContainer shape,
+          StridesContainer strides,
+          const void *ptr = nullptr,
+          handle base = handle()) {
+
+        if (strides->empty()) {
+            *strides = detail::c_strides(*shape, dt.itemsize());
+        }
+
+        auto ndim = shape->size();
+        if (ndim != strides->size()) {
+            pybind11_fail("NumPy: shape ndim doesn't match strides ndim");
+        }
+        auto descr = dt;
+
+        int flags = 0;
+        if (base && ptr) {
+            if (isinstance<array>(base)) {
+                /* Copy flags from base (except ownership bit) */
+                flags = reinterpret_borrow<array>(base).flags()
+                        & ~detail::npy_api::NPY_ARRAY_OWNDATA_;
+            } else {
+                /* Writable by default, easy to downgrade later on if needed */
+                flags = detail::npy_api::NPY_ARRAY_WRITEABLE_;
+            }
+        }
+
+        auto &api = detail::npy_api::get();
+        auto tmp = reinterpret_steal<object>(api.PyArray_NewFromDescr_(
+            api.PyArray_Type_,
+            descr.release().ptr(),
+            (int) ndim,
+            // Use reinterpret_cast for PyPy on Windows (remove if fixed, checked on 7.3.1)
+            reinterpret_cast<Py_intptr_t *>(shape->data()),
+            reinterpret_cast<Py_intptr_t *>(strides->data()),
+            const_cast<void *>(ptr),
+            flags,
+            nullptr));
+        if (!tmp) {
+            throw error_already_set();
+        }
+        if (ptr) {
+            if (base) {
+                api.PyArray_SetBaseObject_(tmp.ptr(), base.inc_ref().ptr());
+            } else {
+                tmp = reinterpret_steal<object>(
+                    api.PyArray_NewCopy_(tmp.ptr(), -1 /* any order */));
+            }
+        }
+        m_ptr = tmp.release().ptr();
+    }
+
+    array(const pybind11::dtype &dt,
+          ShapeContainer shape,
+          const void *ptr = nullptr,
+          handle base = handle())
+        : array(dt, std::move(shape), {}, ptr, base) {}
+
+    template <typename T,
+              typename
+              = detail::enable_if_t<std::is_integral<T>::value && !std::is_same<bool, T>::value>>
+    array(const pybind11::dtype &dt, T count, const void *ptr = nullptr, handle base = handle())
+        : array(dt, {{count}}, ptr, base) {}
+
+    template <typename T>
+    array(ShapeContainer shape, StridesContainer strides, const T *ptr, handle base = handle())
+        : array(pybind11::dtype::of<T>(),
+                std::move(shape),
+                std::move(strides),
+                reinterpret_cast<const void *>(ptr),
+                base) {}
+
+    template <typename T>
+    array(ShapeContainer shape, const T *ptr, handle base = handle())
+        : array(std::move(shape), {}, ptr, base) {}
+
+    template <typename T>
+    explicit array(ssize_t count, const T *ptr, handle base = handle())
+        : array({count}, {}, ptr, base) {}
+
+    explicit array(const buffer_info &info, handle base = handle())
+        : array(pybind11::dtype(info), info.shape, info.strides, info.ptr, base) {}
+
+    /// Array descriptor (dtype)
+    pybind11::dtype dtype() const {
+        return reinterpret_borrow<pybind11::dtype>(detail::array_proxy(m_ptr)->descr);
+    }
+
+    /// Total number of elements
+    ssize_t size() const {
+        return std::accumulate(shape(), shape() + ndim(), (ssize_t) 1, std::multiplies<ssize_t>());
+    }
+
+    /// Byte size of a single element
+    ssize_t itemsize() const { return dtype().itemsize(); }
+
+    /// Total number of bytes
+    ssize_t nbytes() const { return size() * itemsize(); }
+
+    /// Number of dimensions
+    ssize_t ndim() const { return detail::array_proxy(m_ptr)->nd; }
+
+    /// Base object
+    object base() const { return reinterpret_borrow<object>(detail::array_proxy(m_ptr)->base); }
+
+    /// Dimensions of the array
+    const ssize_t *shape() const { return detail::array_proxy(m_ptr)->dimensions; }
+
+    /// Dimension along a given axis
+    ssize_t shape(ssize_t dim) const {
+        if (dim >= ndim()) {
+            fail_dim_check(dim, "invalid axis");
+        }
+        return shape()[dim];
+    }
+
+    /// Strides of the array
+    const ssize_t *strides() const { return detail::array_proxy(m_ptr)->strides; }
+
+    /// Stride along a given axis
+    ssize_t strides(ssize_t dim) const {
+        if (dim >= ndim()) {
+            fail_dim_check(dim, "invalid axis");
+        }
+        return strides()[dim];
+    }
+
+    /// Return the NumPy array flags
+    int flags() const { return detail::array_proxy(m_ptr)->flags; }
+
+    /// If set, the array is writeable (otherwise the buffer is read-only)
+    bool writeable() const {
+        return detail::check_flags(m_ptr, detail::npy_api::NPY_ARRAY_WRITEABLE_);
+    }
+
+    /// If set, the array owns the data (will be freed when the array is deleted)
+    bool owndata() const {
+        return detail::check_flags(m_ptr, detail::npy_api::NPY_ARRAY_OWNDATA_);
+    }
+
+    /// Pointer to the contained data. If index is not provided, points to the
+    /// beginning of the buffer. May throw if the index would lead to out of bounds access.
+    template <typename... Ix>
+    const void *data(Ix... index) const {
+        return static_cast<const void *>(detail::array_proxy(m_ptr)->data + offset_at(index...));
+    }
+
+    /// Mutable pointer to the contained data. If index is not provided, points to the
+    /// beginning of the buffer. May throw if the index would lead to out of bounds access.
+    /// May throw if the array is not writeable.
+    template <typename... Ix>
+    void *mutable_data(Ix... index) {
+        check_writeable();
+        return static_cast<void *>(detail::array_proxy(m_ptr)->data + offset_at(index...));
+    }
+
+    /// Byte offset from beginning of the array to a given index (full or partial).
+    /// May throw if the index would lead to out of bounds access.
+    template <typename... Ix>
+    ssize_t offset_at(Ix... index) const {
+        if ((ssize_t) sizeof...(index) > ndim()) {
+            fail_dim_check(sizeof...(index), "too many indices for an array");
+        }
+        return byte_offset(ssize_t(index)...);
+    }
+
+    ssize_t offset_at() const { return 0; }
+
+    /// Item count from beginning of the array to a given index (full or partial).
+    /// May throw if the index would lead to out of bounds access.
+    template <typename... Ix>
+    ssize_t index_at(Ix... index) const {
+        return offset_at(index...) / itemsize();
+    }
+
+    /**
+     * Returns a proxy object that provides access to the array's data without bounds or
+     * dimensionality checking.  Will throw if the array is missing the `writeable` flag.  Use with
+     * care: the array must not be destroyed or reshaped for the duration of the returned object,
+     * and the caller must take care not to access invalid dimensions or dimension indices.
+     */
+    template <typename T, ssize_t Dims = -1>
+    detail::unchecked_mutable_reference<T, Dims> mutable_unchecked() & {
+        if (Dims >= 0 && ndim() != Dims) {
+            throw std::domain_error("array has incorrect number of dimensions: "
+                                    + std::to_string(ndim()) + "; expected "
+                                    + std::to_string(Dims));
+        }
+        return detail::unchecked_mutable_reference<T, Dims>(
+            mutable_data(), shape(), strides(), ndim());
+    }
+
+    /**
+     * Returns a proxy object that provides const access to the array's data without bounds or
+     * dimensionality checking.  Unlike `mutable_unchecked()`, this does not require that the
+     * underlying array have the `writable` flag.  Use with care: the array must not be destroyed
+     * or reshaped for the duration of the returned object, and the caller must take care not to
+     * access invalid dimensions or dimension indices.
+     */
+    template <typename T, ssize_t Dims = -1>
+    detail::unchecked_reference<T, Dims> unchecked() const & {
+        if (Dims >= 0 && ndim() != Dims) {
+            throw std::domain_error("array has incorrect number of dimensions: "
+                                    + std::to_string(ndim()) + "; expected "
+                                    + std::to_string(Dims));
+        }
+        return detail::unchecked_reference<T, Dims>(data(), shape(), strides(), ndim());
+    }
+
+    /// Return a new view with all of the dimensions of length 1 removed
+    array squeeze() {
+        auto &api = detail::npy_api::get();
+        return reinterpret_steal<array>(api.PyArray_Squeeze_(m_ptr));
+    }
+
+    /// Resize array to given shape
+    /// If refcheck is true and more that one reference exist to this array
+    /// then resize will succeed only if it makes a reshape, i.e. original size doesn't change
+    void resize(ShapeContainer new_shape, bool refcheck = true) {
+        detail::npy_api::PyArray_Dims d
+            = {// Use reinterpret_cast for PyPy on Windows (remove if fixed, checked on 7.3.1)
+               reinterpret_cast<Py_intptr_t *>(new_shape->data()),
+               int(new_shape->size())};
+        // try to resize, set ordering param to -1 cause it's not used anyway
+        auto new_array = reinterpret_steal<object>(
+            detail::npy_api::get().PyArray_Resize_(m_ptr, &d, int(refcheck), -1));
+        if (!new_array) {
+            throw error_already_set();
+        }
+        if (isinstance<array>(new_array)) {
+            *this = std::move(new_array);
+        }
+    }
+
+    /// Optional `order` parameter omitted, to be added as needed.
+    array reshape(ShapeContainer new_shape) {
+        detail::npy_api::PyArray_Dims d
+            = {reinterpret_cast<Py_intptr_t *>(new_shape->data()), int(new_shape->size())};
+        auto new_array
+            = reinterpret_steal<array>(detail::npy_api::get().PyArray_Newshape_(m_ptr, &d, 0));
+        if (!new_array) {
+            throw error_already_set();
+        }
+        return new_array;
+    }
+
+    /// Create a view of an array in a different data type.
+    /// This function may fundamentally reinterpret the data in the array.
+    /// It is the responsibility of the caller to ensure that this is safe.
+    /// Only supports the `dtype` argument, the `type` argument is omitted,
+    /// to be added as needed.
+    array view(const std::string &dtype) {
+        auto &api = detail::npy_api::get();
+        auto new_view = reinterpret_steal<array>(api.PyArray_View_(
+            m_ptr, dtype::from_args(pybind11::str(dtype)).release().ptr(), nullptr));
+        if (!new_view) {
+            throw error_already_set();
+        }
+        return new_view;
+    }
+
+    /// Ensure that the argument is a NumPy array
+    /// In case of an error, nullptr is returned and the Python error is cleared.
+    static array ensure(handle h, int ExtraFlags = 0) {
+        auto result = reinterpret_steal<array>(raw_array(h.ptr(), ExtraFlags));
+        if (!result) {
+            PyErr_Clear();
+        }
+        return result;
+    }
+
+protected:
+    template <typename, typename>
+    friend struct detail::npy_format_descriptor;
+
+    void fail_dim_check(ssize_t dim, const std::string &msg) const {
+        throw index_error(msg + ": " + std::to_string(dim) + " (ndim = " + std::to_string(ndim())
+                          + ')');
+    }
+
+    template <typename... Ix>
+    ssize_t byte_offset(Ix... index) const {
+        check_dimensions(index...);
+        return detail::byte_offset_unsafe(strides(), ssize_t(index)...);
+    }
+
+    void check_writeable() const {
+        if (!writeable()) {
+            throw std::domain_error("array is not writeable");
+        }
+    }
+
+    template <typename... Ix>
+    void check_dimensions(Ix... index) const {
+        check_dimensions_impl(ssize_t(0), shape(), ssize_t(index)...);
+    }
+
+    void check_dimensions_impl(ssize_t, const ssize_t *) const {}
+
+    template <typename... Ix>
+    void check_dimensions_impl(ssize_t axis, const ssize_t *shape, ssize_t i, Ix... index) const {
+        if (i >= *shape) {
+            throw index_error(std::string("index ") + std::to_string(i)
+                              + " is out of bounds for axis " + std::to_string(axis)
+                              + " with size " + std::to_string(*shape));
+        }
+        check_dimensions_impl(axis + 1, shape + 1, index...);
+    }
+
+    /// Create array from any object -- always returns a new reference
+    static PyObject *raw_array(PyObject *ptr, int ExtraFlags = 0) {
+        if (ptr == nullptr) {
+            set_error(PyExc_ValueError, "cannot create a pybind11::array from a nullptr");
+            return nullptr;
+        }
+        return detail::npy_api::get().PyArray_FromAny_(
+            ptr, nullptr, 0, 0, detail::npy_api::NPY_ARRAY_ENSUREARRAY_ | ExtraFlags, nullptr);
+    }
+};
+
+template <typename T, int ExtraFlags = array::forcecast>
+class array_t : public array {
+private:
+    struct private_ctor {};
+    // Delegating constructor needed when both moving and accessing in the same constructor
+    array_t(private_ctor,
+            ShapeContainer &&shape,
+            StridesContainer &&strides,
+            const T *ptr,
+            handle base)
+        : array(std::move(shape), std::move(strides), ptr, base) {}
+
+public:
+    static_assert(!detail::array_info<T>::is_array, "Array types cannot be used with array_t");
+
+    using value_type = T;
+
+    array_t() : array(0, static_cast<const T *>(nullptr)) {}
+    array_t(handle h, borrowed_t) : array(h, borrowed_t{}) {}
+    array_t(handle h, stolen_t) : array(h, stolen_t{}) {}
+
+    PYBIND11_DEPRECATED("Use array_t<T>::ensure() instead")
+    array_t(handle h, bool is_borrowed) : array(raw_array_t(h.ptr()), stolen_t{}) {
+        if (!m_ptr) {
+            PyErr_Clear();
+        }
+        if (!is_borrowed) {
+            Py_XDECREF(h.ptr());
+        }
+    }
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    array_t(const object &o) : array(raw_array_t(o.ptr()), stolen_t{}) {
+        if (!m_ptr) {
+            throw error_already_set();
+        }
+    }
+
+    explicit array_t(const buffer_info &info, handle base = handle()) : array(info, base) {}
+
+    array_t(ShapeContainer shape,
+            StridesContainer strides,
+            const T *ptr = nullptr,
+            handle base = handle())
+        : array(std::move(shape), std::move(strides), ptr, base) {}
+
+    explicit array_t(ShapeContainer shape, const T *ptr = nullptr, handle base = handle())
+        : array_t(private_ctor{},
+                  std::move(shape),
+                  (ExtraFlags & f_style) != 0 ? detail::f_strides(*shape, itemsize())
+                                              : detail::c_strides(*shape, itemsize()),
+                  ptr,
+                  base) {}
+
+    explicit array_t(ssize_t count, const T *ptr = nullptr, handle base = handle())
+        : array({count}, {}, ptr, base) {}
+
+    constexpr ssize_t itemsize() const { return sizeof(T); }
+
+    template <typename... Ix>
+    ssize_t index_at(Ix... index) const {
+        return offset_at(index...) / itemsize();
+    }
+
+    template <typename... Ix>
+    const T *data(Ix... index) const {
+        return static_cast<const T *>(array::data(index...));
+    }
+
+    template <typename... Ix>
+    T *mutable_data(Ix... index) {
+        return static_cast<T *>(array::mutable_data(index...));
+    }
+
+    // Reference to element at a given index
+    template <typename... Ix>
+    const T &at(Ix... index) const {
+        if ((ssize_t) sizeof...(index) != ndim()) {
+            fail_dim_check(sizeof...(index), "index dimension mismatch");
+        }
+        return *(static_cast<const T *>(array::data())
+                 + byte_offset(ssize_t(index)...) / itemsize());
+    }
+
+    // Mutable reference to element at a given index
+    template <typename... Ix>
+    T &mutable_at(Ix... index) {
+        if ((ssize_t) sizeof...(index) != ndim()) {
+            fail_dim_check(sizeof...(index), "index dimension mismatch");
+        }
+        return *(static_cast<T *>(array::mutable_data())
+                 + byte_offset(ssize_t(index)...) / itemsize());
+    }
+
+    /**
+     * Returns a proxy object that provides access to the array's data without bounds or
+     * dimensionality checking.  Will throw if the array is missing the `writeable` flag.  Use with
+     * care: the array must not be destroyed or reshaped for the duration of the returned object,
+     * and the caller must take care not to access invalid dimensions or dimension indices.
+     */
+    template <ssize_t Dims = -1>
+    detail::unchecked_mutable_reference<T, Dims> mutable_unchecked() & {
+        return array::mutable_unchecked<T, Dims>();
+    }
+
+    /**
+     * Returns a proxy object that provides const access to the array's data without bounds or
+     * dimensionality checking.  Unlike `mutable_unchecked()`, this does not require that the
+     * underlying array have the `writable` flag.  Use with care: the array must not be destroyed
+     * or reshaped for the duration of the returned object, and the caller must take care not to
+     * access invalid dimensions or dimension indices.
+     */
+    template <ssize_t Dims = -1>
+    detail::unchecked_reference<T, Dims> unchecked() const & {
+        return array::unchecked<T, Dims>();
+    }
+
+    /// Ensure that the argument is a NumPy array of the correct dtype (and if not, try to convert
+    /// it).  In case of an error, nullptr is returned and the Python error is cleared.
+    static array_t ensure(handle h) {
+        auto result = reinterpret_steal<array_t>(raw_array_t(h.ptr()));
+        if (!result) {
+            PyErr_Clear();
+        }
+        return result;
+    }
+
+    static bool check_(handle h) {
+        const auto &api = detail::npy_api::get();
+        return api.PyArray_Check_(h.ptr())
+               && api.PyArray_EquivTypes_(detail::array_proxy(h.ptr())->descr,
+                                          dtype::of<T>().ptr())
+               && detail::check_flags(h.ptr(), ExtraFlags & (array::c_style | array::f_style));
+    }
+
+protected:
+    /// Create array from any object -- always returns a new reference
+    static PyObject *raw_array_t(PyObject *ptr) {
+        if (ptr == nullptr) {
+            set_error(PyExc_ValueError, "cannot create a pybind11::array_t from a nullptr");
+            return nullptr;
+        }
+        return detail::npy_api::get().PyArray_FromAny_(ptr,
+                                                       dtype::of<T>().release().ptr(),
+                                                       0,
+                                                       0,
+                                                       detail::npy_api::NPY_ARRAY_ENSUREARRAY_
+                                                           | ExtraFlags,
+                                                       nullptr);
+    }
+};
+
+template <typename T>
+struct format_descriptor<T, detail::enable_if_t<detail::is_pod_struct<T>::value>> {
+    static std::string format() {
+        return detail::npy_format_descriptor<typename std::remove_cv<T>::type>::format();
+    }
+};
+
+template <size_t N>
+struct format_descriptor<char[N]> {
+    static std::string format() { return std::to_string(N) + 's'; }
+};
+template <size_t N>
+struct format_descriptor<std::array<char, N>> {
+    static std::string format() { return std::to_string(N) + 's'; }
+};
+
+template <typename T>
+struct format_descriptor<T, detail::enable_if_t<std::is_enum<T>::value>> {
+    static std::string format() {
+        return format_descriptor<
+            typename std::remove_cv<typename std::underlying_type<T>::type>::type>::format();
+    }
+};
+
+template <typename T>
+struct format_descriptor<T, detail::enable_if_t<detail::array_info<T>::is_array>> {
+    static std::string format() {
+        using namespace detail;
+        static constexpr auto extents = const_name("(") + array_info<T>::extents + const_name(")");
+        return extents.text + format_descriptor<remove_all_extents_t<T>>::format();
+    }
+};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+template <typename T, int ExtraFlags>
+struct pyobject_caster<array_t<T, ExtraFlags>> {
+    using type = array_t<T, ExtraFlags>;
+
+    bool load(handle src, bool convert) {
+        if (!convert && !type::check_(src)) {
+            return false;
+        }
+        value = type::ensure(src);
+        return static_cast<bool>(value);
+    }
+
+    static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) {
+        return src.inc_ref();
+    }
+    PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name);
+};
+
+template <typename T>
+struct compare_buffer_info<T, detail::enable_if_t<detail::is_pod_struct<T>::value>> {
+    static bool compare(const buffer_info &b) {
+        return npy_api::get().PyArray_EquivTypes_(dtype::of<T>().ptr(), dtype(b).ptr());
+    }
+};
+
+template <typename T>
+struct npy_format_descriptor<
+    T,
+    enable_if_t<satisfies_any_of<T, std::is_arithmetic, is_complex>::value>>
+    : npy_format_descriptor_name<T> {
+private:
+    // NB: the order here must match the one in common.h
+    constexpr static const int values[15] = {npy_api::NPY_BOOL_,
+                                             npy_api::NPY_BYTE_,
+                                             npy_api::NPY_UBYTE_,
+                                             npy_api::NPY_INT16_,
+                                             npy_api::NPY_UINT16_,
+                                             npy_api::NPY_INT32_,
+                                             npy_api::NPY_UINT32_,
+                                             npy_api::NPY_INT64_,
+                                             npy_api::NPY_UINT64_,
+                                             npy_api::NPY_FLOAT_,
+                                             npy_api::NPY_DOUBLE_,
+                                             npy_api::NPY_LONGDOUBLE_,
+                                             npy_api::NPY_CFLOAT_,
+                                             npy_api::NPY_CDOUBLE_,
+                                             npy_api::NPY_CLONGDOUBLE_};
+
+public:
+    static constexpr int value = values[detail::is_fmt_numeric<T>::index];
+
+    static pybind11::dtype dtype() { return pybind11::dtype(/*typenum*/ value); }
+};
+
+template <typename T>
+struct npy_format_descriptor<
+    T,
+    enable_if_t<is_same_ignoring_cvref<T, PyObject *>::value
+                || ((std::is_same<T, handle>::value || std::is_same<T, object>::value)
+                    && sizeof(T) == sizeof(PyObject *))>> {
+    static constexpr auto name = const_name("numpy.object_");
+
+    static constexpr int value = npy_api::NPY_OBJECT_;
+
+    static pybind11::dtype dtype() { return pybind11::dtype(/*typenum*/ value); }
+};
+
+#define PYBIND11_DECL_CHAR_FMT                                                                    \
+    static constexpr auto name = const_name("S") + const_name<N>();                               \
+    static pybind11::dtype dtype() {                                                              \
+        return pybind11::dtype(std::string("S") + std::to_string(N));                             \
+    }
+template <size_t N>
+struct npy_format_descriptor<char[N]> {
+    PYBIND11_DECL_CHAR_FMT
+};
+template <size_t N>
+struct npy_format_descriptor<std::array<char, N>> {
+    PYBIND11_DECL_CHAR_FMT
+};
+#undef PYBIND11_DECL_CHAR_FMT
+
+template <typename T>
+struct npy_format_descriptor<T, enable_if_t<array_info<T>::is_array>> {
+private:
+    using base_descr = npy_format_descriptor<typename array_info<T>::type>;
+
+public:
+    static_assert(!array_info<T>::is_empty, "Zero-sized arrays are not supported");
+
+    static constexpr auto name
+        = const_name("(") + array_info<T>::extents + const_name(")") + base_descr::name;
+    static pybind11::dtype dtype() {
+        list shape;
+        array_info<T>::append_extents(shape);
+        return pybind11::dtype::from_args(
+            pybind11::make_tuple(base_descr::dtype(), std::move(shape)));
+    }
+};
+
+template <typename T>
+struct npy_format_descriptor<T, enable_if_t<std::is_enum<T>::value>> {
+private:
+    using base_descr = npy_format_descriptor<typename std::underlying_type<T>::type>;
+
+public:
+    static constexpr auto name = base_descr::name;
+    static pybind11::dtype dtype() { return base_descr::dtype(); }
+};
+
+struct field_descriptor {
+    const char *name;
+    ssize_t offset;
+    ssize_t size;
+    std::string format;
+    dtype descr;
+};
+
+PYBIND11_NOINLINE void register_structured_dtype(any_container<field_descriptor> fields,
+                                                 const std::type_info &tinfo,
+                                                 ssize_t itemsize,
+                                                 bool (*direct_converter)(PyObject *, void *&)) {
+
+    auto &numpy_internals = get_numpy_internals();
+    if (numpy_internals.get_type_info(tinfo, false)) {
+        pybind11_fail("NumPy: dtype is already registered");
+    }
+
+    // Use ordered fields because order matters as of NumPy 1.14:
+    // https://docs.scipy.org/doc/numpy/release.html#multiple-field-indexing-assignment-of-structured-arrays
+    std::vector<field_descriptor> ordered_fields(std::move(fields));
+    std::sort(
+        ordered_fields.begin(),
+        ordered_fields.end(),
+        [](const field_descriptor &a, const field_descriptor &b) { return a.offset < b.offset; });
+
+    list names, formats, offsets;
+    for (auto &field : ordered_fields) {
+        if (!field.descr) {
+            pybind11_fail(std::string("NumPy: unsupported field dtype: `") + field.name + "` @ "
+                          + tinfo.name());
+        }
+        names.append(pybind11::str(field.name));
+        formats.append(field.descr);
+        offsets.append(pybind11::int_(field.offset));
+    }
+    auto *dtype_ptr
+        = pybind11::dtype(std::move(names), std::move(formats), std::move(offsets), itemsize)
+              .release()
+              .ptr();
+
+    // There is an existing bug in NumPy (as of v1.11): trailing bytes are
+    // not encoded explicitly into the format string. This will supposedly
+    // get fixed in v1.12; for further details, see these:
+    // - https://github.com/numpy/numpy/issues/7797
+    // - https://github.com/numpy/numpy/pull/7798
+    // Because of this, we won't use numpy's logic to generate buffer format
+    // strings and will just do it ourselves.
+    ssize_t offset = 0;
+    std::ostringstream oss;
+    // mark the structure as unaligned with '^', because numpy and C++ don't
+    // always agree about alignment (particularly for complex), and we're
+    // explicitly listing all our padding. This depends on none of the fields
+    // overriding the endianness. Putting the ^ in front of individual fields
+    // isn't guaranteed to work due to https://github.com/numpy/numpy/issues/9049
+    oss << "^T{";
+    for (auto &field : ordered_fields) {
+        if (field.offset > offset) {
+            oss << (field.offset - offset) << 'x';
+        }
+        oss << field.format << ':' << field.name << ':';
+        offset = field.offset + field.size;
+    }
+    if (itemsize > offset) {
+        oss << (itemsize - offset) << 'x';
+    }
+    oss << '}';
+    auto format_str = oss.str();
+
+    // Smoke test: verify that NumPy properly parses our buffer format string
+    auto &api = npy_api::get();
+    auto arr = array(buffer_info(nullptr, itemsize, format_str, 1));
+    if (!api.PyArray_EquivTypes_(dtype_ptr, arr.dtype().ptr())) {
+        pybind11_fail("NumPy: invalid buffer descriptor!");
+    }
+
+    auto tindex = std::type_index(tinfo);
+    numpy_internals.registered_dtypes[tindex] = {dtype_ptr, std::move(format_str)};
+    with_internals([tindex, &direct_converter](internals &internals) {
+        internals.direct_conversions[tindex].push_back(direct_converter);
+    });
+}
+
+template <typename T, typename SFINAE>
+struct npy_format_descriptor {
+    static_assert(is_pod_struct<T>::value,
+                  "Attempt to use a non-POD or unimplemented POD type as a numpy dtype");
+
+    static constexpr auto name = make_caster<T>::name;
+
+    static pybind11::dtype dtype() { return reinterpret_borrow<pybind11::dtype>(dtype_ptr()); }
+
+    static std::string format() {
+        static auto format_str = get_numpy_internals().get_type_info<T>(true)->format_str;
+        return format_str;
+    }
+
+    static void register_dtype(any_container<field_descriptor> fields) {
+        register_structured_dtype(std::move(fields),
+                                  typeid(typename std::remove_cv<T>::type),
+                                  sizeof(T),
+                                  &direct_converter);
+    }
+
+private:
+    static PyObject *dtype_ptr() {
+        static PyObject *ptr = get_numpy_internals().get_type_info<T>(true)->dtype_ptr;
+        return ptr;
+    }
+
+    static bool direct_converter(PyObject *obj, void *&value) {
+        auto &api = npy_api::get();
+        if (!PyObject_TypeCheck(obj, api.PyVoidArrType_Type_)) {
+            return false;
+        }
+        if (auto descr = reinterpret_steal<object>(api.PyArray_DescrFromScalar_(obj))) {
+            if (api.PyArray_EquivTypes_(dtype_ptr(), descr.ptr())) {
+                value = ((PyVoidScalarObject_Proxy *) obj)->obval;
+                return true;
+            }
+        }
+        return false;
+    }
+};
+
+#ifdef __CLION_IDE__ // replace heavy macro with dummy code for the IDE (doesn't affect code)
+#    define PYBIND11_NUMPY_DTYPE(Type, ...) ((void) 0)
+#    define PYBIND11_NUMPY_DTYPE_EX(Type, ...) ((void) 0)
+#else
+
+#    define PYBIND11_FIELD_DESCRIPTOR_EX(T, Field, Name)                                          \
+        ::pybind11::detail::field_descriptor {                                                    \
+            Name, offsetof(T, Field), sizeof(decltype(std::declval<T>().Field)),                  \
+                ::pybind11::format_descriptor<decltype(std::declval<T>().Field)>::format(),       \
+                ::pybind11::detail::npy_format_descriptor<                                        \
+                    decltype(std::declval<T>().Field)>::dtype()                                   \
+        }
+
+// Extract name, offset and format descriptor for a struct field
+#    define PYBIND11_FIELD_DESCRIPTOR(T, Field) PYBIND11_FIELD_DESCRIPTOR_EX(T, Field, #Field)
+
+// The main idea of this macro is borrowed from https://github.com/swansontec/map-macro
+// (C) William Swanson, Paul Fultz
+#    define PYBIND11_EVAL0(...) __VA_ARGS__
+#    define PYBIND11_EVAL1(...) PYBIND11_EVAL0(PYBIND11_EVAL0(PYBIND11_EVAL0(__VA_ARGS__)))
+#    define PYBIND11_EVAL2(...) PYBIND11_EVAL1(PYBIND11_EVAL1(PYBIND11_EVAL1(__VA_ARGS__)))
+#    define PYBIND11_EVAL3(...) PYBIND11_EVAL2(PYBIND11_EVAL2(PYBIND11_EVAL2(__VA_ARGS__)))
+#    define PYBIND11_EVAL4(...) PYBIND11_EVAL3(PYBIND11_EVAL3(PYBIND11_EVAL3(__VA_ARGS__)))
+#    define PYBIND11_EVAL(...) PYBIND11_EVAL4(PYBIND11_EVAL4(PYBIND11_EVAL4(__VA_ARGS__)))
+#    define PYBIND11_MAP_END(...)
+#    define PYBIND11_MAP_OUT
+#    define PYBIND11_MAP_COMMA ,
+#    define PYBIND11_MAP_GET_END() 0, PYBIND11_MAP_END
+#    define PYBIND11_MAP_NEXT0(test, next, ...) next PYBIND11_MAP_OUT
+#    define PYBIND11_MAP_NEXT1(test, next) PYBIND11_MAP_NEXT0(test, next, 0)
+#    define PYBIND11_MAP_NEXT(test, next) PYBIND11_MAP_NEXT1(PYBIND11_MAP_GET_END test, next)
+#    if defined(_MSC_VER)                                                                         \
+        && !defined(__clang__) // MSVC is not as eager to expand macros, hence this workaround
+#        define PYBIND11_MAP_LIST_NEXT1(test, next)                                               \
+            PYBIND11_EVAL0(PYBIND11_MAP_NEXT0(test, PYBIND11_MAP_COMMA next, 0))
+#    else
+#        define PYBIND11_MAP_LIST_NEXT1(test, next)                                               \
+            PYBIND11_MAP_NEXT0(test, PYBIND11_MAP_COMMA next, 0)
+#    endif
+#    define PYBIND11_MAP_LIST_NEXT(test, next)                                                    \
+        PYBIND11_MAP_LIST_NEXT1(PYBIND11_MAP_GET_END test, next)
+#    define PYBIND11_MAP_LIST0(f, t, x, peek, ...)                                                \
+        f(t, x) PYBIND11_MAP_LIST_NEXT(peek, PYBIND11_MAP_LIST1)(f, t, peek, __VA_ARGS__)
+#    define PYBIND11_MAP_LIST1(f, t, x, peek, ...)                                                \
+        f(t, x) PYBIND11_MAP_LIST_NEXT(peek, PYBIND11_MAP_LIST0)(f, t, peek, __VA_ARGS__)
+// PYBIND11_MAP_LIST(f, t, a1, a2, ...) expands to f(t, a1), f(t, a2), ...
+#    define PYBIND11_MAP_LIST(f, t, ...)                                                          \
+        PYBIND11_EVAL(PYBIND11_MAP_LIST1(f, t, __VA_ARGS__, (), 0))
+
+#    define PYBIND11_NUMPY_DTYPE(Type, ...)                                                       \
+        ::pybind11::detail::npy_format_descriptor<Type>::register_dtype(                          \
+            ::std::vector<::pybind11::detail::field_descriptor>{                                  \
+                PYBIND11_MAP_LIST(PYBIND11_FIELD_DESCRIPTOR, Type, __VA_ARGS__)})
+
+#    if defined(_MSC_VER) && !defined(__clang__)
+#        define PYBIND11_MAP2_LIST_NEXT1(test, next)                                              \
+            PYBIND11_EVAL0(PYBIND11_MAP_NEXT0(test, PYBIND11_MAP_COMMA next, 0))
+#    else
+#        define PYBIND11_MAP2_LIST_NEXT1(test, next)                                              \
+            PYBIND11_MAP_NEXT0(test, PYBIND11_MAP_COMMA next, 0)
+#    endif
+#    define PYBIND11_MAP2_LIST_NEXT(test, next)                                                   \
+        PYBIND11_MAP2_LIST_NEXT1(PYBIND11_MAP_GET_END test, next)
+#    define PYBIND11_MAP2_LIST0(f, t, x1, x2, peek, ...)                                          \
+        f(t, x1, x2) PYBIND11_MAP2_LIST_NEXT(peek, PYBIND11_MAP2_LIST1)(f, t, peek, __VA_ARGS__)
+#    define PYBIND11_MAP2_LIST1(f, t, x1, x2, peek, ...)                                          \
+        f(t, x1, x2) PYBIND11_MAP2_LIST_NEXT(peek, PYBIND11_MAP2_LIST0)(f, t, peek, __VA_ARGS__)
+// PYBIND11_MAP2_LIST(f, t, a1, a2, ...) expands to f(t, a1, a2), f(t, a3, a4), ...
+#    define PYBIND11_MAP2_LIST(f, t, ...)                                                         \
+        PYBIND11_EVAL(PYBIND11_MAP2_LIST1(f, t, __VA_ARGS__, (), 0))
+
+#    define PYBIND11_NUMPY_DTYPE_EX(Type, ...)                                                    \
+        ::pybind11::detail::npy_format_descriptor<Type>::register_dtype(                          \
+            ::std::vector<::pybind11::detail::field_descriptor>{                                  \
+                PYBIND11_MAP2_LIST(PYBIND11_FIELD_DESCRIPTOR_EX, Type, __VA_ARGS__)})
+
+#endif // __CLION_IDE__
+
+class common_iterator {
+public:
+    using container_type = std::vector<ssize_t>;
+    using value_type = container_type::value_type;
+    using size_type = container_type::size_type;
+
+    common_iterator() : m_strides() {}
+
+    common_iterator(void *ptr, const container_type &strides, const container_type &shape)
+        : p_ptr(reinterpret_cast<char *>(ptr)), m_strides(strides.size()) {
+        m_strides.back() = static_cast<value_type>(strides.back());
+        for (size_type i = m_strides.size() - 1; i != 0; --i) {
+            size_type j = i - 1;
+            auto s = static_cast<value_type>(shape[i]);
+            m_strides[j] = strides[j] + m_strides[i] - strides[i] * s;
+        }
+    }
+
+    void increment(size_type dim) { p_ptr += m_strides[dim]; }
+
+    void *data() const { return p_ptr; }
+
+private:
+    char *p_ptr{nullptr};
+    container_type m_strides;
+};
+
+template <size_t N>
+class multi_array_iterator {
+public:
+    using container_type = std::vector<ssize_t>;
+
+    multi_array_iterator(const std::array<buffer_info, N> &buffers, const container_type &shape)
+        : m_shape(shape.size()), m_index(shape.size(), 0), m_common_iterator() {
+
+        // Manual copy to avoid conversion warning if using std::copy
+        for (size_t i = 0; i < shape.size(); ++i) {
+            m_shape[i] = shape[i];
+        }
+
+        container_type strides(shape.size());
+        for (size_t i = 0; i < N; ++i) {
+            init_common_iterator(buffers[i], shape, m_common_iterator[i], strides);
+        }
+    }
+
+    multi_array_iterator &operator++() {
+        for (size_t j = m_index.size(); j != 0; --j) {
+            size_t i = j - 1;
+            if (++m_index[i] != m_shape[i]) {
+                increment_common_iterator(i);
+                break;
+            }
+            m_index[i] = 0;
+        }
+        return *this;
+    }
+
+    template <size_t K, class T = void>
+    T *data() const {
+        return reinterpret_cast<T *>(m_common_iterator[K].data());
+    }
+
+private:
+    using common_iter = common_iterator;
+
+    void init_common_iterator(const buffer_info &buffer,
+                              const container_type &shape,
+                              common_iter &iterator,
+                              container_type &strides) {
+        auto buffer_shape_iter = buffer.shape.rbegin();
+        auto buffer_strides_iter = buffer.strides.rbegin();
+        auto shape_iter = shape.rbegin();
+        auto strides_iter = strides.rbegin();
+
+        while (buffer_shape_iter != buffer.shape.rend()) {
+            if (*shape_iter == *buffer_shape_iter) {
+                *strides_iter = *buffer_strides_iter;
+            } else {
+                *strides_iter = 0;
+            }
+
+            ++buffer_shape_iter;
+            ++buffer_strides_iter;
+            ++shape_iter;
+            ++strides_iter;
+        }
+
+        std::fill(strides_iter, strides.rend(), 0);
+        iterator = common_iter(buffer.ptr, strides, shape);
+    }
+
+    void increment_common_iterator(size_t dim) {
+        for (auto &iter : m_common_iterator) {
+            iter.increment(dim);
+        }
+    }
+
+    container_type m_shape;
+    container_type m_index;
+    std::array<common_iter, N> m_common_iterator;
+};
+
+enum class broadcast_trivial { non_trivial, c_trivial, f_trivial };
+
+// Populates the shape and number of dimensions for the set of buffers.  Returns a
+// broadcast_trivial enum value indicating whether the broadcast is "trivial"--that is, has each
+// buffer being either a singleton or a full-size, C-contiguous (`c_trivial`) or Fortran-contiguous
+// (`f_trivial`) storage buffer; returns `non_trivial` otherwise.
+template <size_t N>
+broadcast_trivial
+broadcast(const std::array<buffer_info, N> &buffers, ssize_t &ndim, std::vector<ssize_t> &shape) {
+    ndim = std::accumulate(
+        buffers.begin(), buffers.end(), ssize_t(0), [](ssize_t res, const buffer_info &buf) {
+            return std::max(res, buf.ndim);
+        });
+
+    shape.clear();
+    shape.resize((size_t) ndim, 1);
+
+    // Figure out the output size, and make sure all input arrays conform (i.e. are either size 1
+    // or the full size).
+    for (size_t i = 0; i < N; ++i) {
+        auto res_iter = shape.rbegin();
+        auto end = buffers[i].shape.rend();
+        for (auto shape_iter = buffers[i].shape.rbegin(); shape_iter != end;
+             ++shape_iter, ++res_iter) {
+            const auto &dim_size_in = *shape_iter;
+            auto &dim_size_out = *res_iter;
+
+            // Each input dimension can either be 1 or `n`, but `n` values must match across
+            // buffers
+            if (dim_size_out == 1) {
+                dim_size_out = dim_size_in;
+            } else if (dim_size_in != 1 && dim_size_in != dim_size_out) {
+                pybind11_fail("pybind11::vectorize: incompatible size/dimension of inputs!");
+            }
+        }
+    }
+
+    bool trivial_broadcast_c = true;
+    bool trivial_broadcast_f = true;
+    for (size_t i = 0; i < N && (trivial_broadcast_c || trivial_broadcast_f); ++i) {
+        if (buffers[i].size == 1) {
+            continue;
+        }
+
+        // Require the same number of dimensions:
+        if (buffers[i].ndim != ndim) {
+            return broadcast_trivial::non_trivial;
+        }
+
+        // Require all dimensions be full-size:
+        if (!std::equal(buffers[i].shape.cbegin(), buffers[i].shape.cend(), shape.cbegin())) {
+            return broadcast_trivial::non_trivial;
+        }
+
+        // Check for C contiguity (but only if previous inputs were also C contiguous)
+        if (trivial_broadcast_c) {
+            ssize_t expect_stride = buffers[i].itemsize;
+            auto end = buffers[i].shape.crend();
+            for (auto shape_iter = buffers[i].shape.crbegin(),
+                      stride_iter = buffers[i].strides.crbegin();
+                 trivial_broadcast_c && shape_iter != end;
+                 ++shape_iter, ++stride_iter) {
+                if (expect_stride == *stride_iter) {
+                    expect_stride *= *shape_iter;
+                } else {
+                    trivial_broadcast_c = false;
+                }
+            }
+        }
+
+        // Check for Fortran contiguity (if previous inputs were also F contiguous)
+        if (trivial_broadcast_f) {
+            ssize_t expect_stride = buffers[i].itemsize;
+            auto end = buffers[i].shape.cend();
+            for (auto shape_iter = buffers[i].shape.cbegin(),
+                      stride_iter = buffers[i].strides.cbegin();
+                 trivial_broadcast_f && shape_iter != end;
+                 ++shape_iter, ++stride_iter) {
+                if (expect_stride == *stride_iter) {
+                    expect_stride *= *shape_iter;
+                } else {
+                    trivial_broadcast_f = false;
+                }
+            }
+        }
+    }
+
+    return trivial_broadcast_c   ? broadcast_trivial::c_trivial
+           : trivial_broadcast_f ? broadcast_trivial::f_trivial
+                                 : broadcast_trivial::non_trivial;
+}
+
+template <typename T>
+struct vectorize_arg {
+    static_assert(!std::is_rvalue_reference<T>::value,
+                  "Functions with rvalue reference arguments cannot be vectorized");
+    // The wrapped function gets called with this type:
+    using call_type = remove_reference_t<T>;
+    // Is this a vectorized argument?
+    static constexpr bool vectorize
+        = satisfies_any_of<call_type, std::is_arithmetic, is_complex, is_pod>::value
+          && satisfies_none_of<call_type,
+                               std::is_pointer,
+                               std::is_array,
+                               is_std_array,
+                               std::is_enum>::value
+          && (!std::is_reference<T>::value
+              || (std::is_lvalue_reference<T>::value && std::is_const<call_type>::value));
+    // Accept this type: an array for vectorized types, otherwise the type as-is:
+    using type = conditional_t<vectorize, array_t<remove_cv_t<call_type>, array::forcecast>, T>;
+};
+
+// py::vectorize when a return type is present
+template <typename Func, typename Return, typename... Args>
+struct vectorize_returned_array {
+    using Type = array_t<Return>;
+
+    static Type create(broadcast_trivial trivial, const std::vector<ssize_t> &shape) {
+        if (trivial == broadcast_trivial::f_trivial) {
+            return array_t<Return, array::f_style>(shape);
+        }
+        return array_t<Return>(shape);
+    }
+
+    static Return *mutable_data(Type &array) { return array.mutable_data(); }
+
+    static Return call(Func &f, Args &...args) { return f(args...); }
+
+    static void call(Return *out, size_t i, Func &f, Args &...args) { out[i] = f(args...); }
+};
+
+// py::vectorize when a return type is not present
+template <typename Func, typename... Args>
+struct vectorize_returned_array<Func, void, Args...> {
+    using Type = none;
+
+    static Type create(broadcast_trivial, const std::vector<ssize_t> &) { return none(); }
+
+    static void *mutable_data(Type &) { return nullptr; }
+
+    static detail::void_type call(Func &f, Args &...args) {
+        f(args...);
+        return {};
+    }
+
+    static void call(void *, size_t, Func &f, Args &...args) { f(args...); }
+};
+
+template <typename Func, typename Return, typename... Args>
+struct vectorize_helper {
+
+// NVCC for some reason breaks if NVectorized is private
+#ifdef __CUDACC__
+public:
+#else
+private:
+#endif
+
+    static constexpr size_t N = sizeof...(Args);
+    static constexpr size_t NVectorized = constexpr_sum(vectorize_arg<Args>::vectorize...);
+    static_assert(
+        NVectorized >= 1,
+        "pybind11::vectorize(...) requires a function with at least one vectorizable argument");
+
+public:
+    template <typename T,
+              // SFINAE to prevent shadowing the copy constructor.
+              typename = detail::enable_if_t<
+                  !std::is_same<vectorize_helper, typename std::decay<T>::type>::value>>
+    explicit vectorize_helper(T &&f) : f(std::forward<T>(f)) {}
+
+    object operator()(typename vectorize_arg<Args>::type... args) {
+        return run(args...,
+                   make_index_sequence<N>(),
+                   select_indices<vectorize_arg<Args>::vectorize...>(),
+                   make_index_sequence<NVectorized>());
+    }
+
+private:
+    remove_reference_t<Func> f;
+
+    // Internal compiler error in MSVC 19.16.27025.1 (Visual Studio 2017 15.9.4), when compiling
+    // with "/permissive-" flag when arg_call_types is manually inlined.
+    using arg_call_types = std::tuple<typename vectorize_arg<Args>::call_type...>;
+    template <size_t Index>
+    using param_n_t = typename std::tuple_element<Index, arg_call_types>::type;
+
+    using returned_array = vectorize_returned_array<Func, Return, Args...>;
+
+    // Runs a vectorized function given arguments tuple and three index sequences:
+    //     - Index is the full set of 0 ... (N-1) argument indices;
+    //     - VIndex is the subset of argument indices with vectorized parameters, letting us access
+    //       vectorized arguments (anything not in this sequence is passed through)
+    //     - BIndex is a incremental sequence (beginning at 0) of the same size as VIndex, so that
+    //       we can store vectorized buffer_infos in an array (argument VIndex has its buffer at
+    //       index BIndex in the array).
+    template <size_t... Index, size_t... VIndex, size_t... BIndex>
+    object run(typename vectorize_arg<Args>::type &...args,
+               index_sequence<Index...> i_seq,
+               index_sequence<VIndex...> vi_seq,
+               index_sequence<BIndex...> bi_seq) {
+
+        // Pointers to values the function was called with; the vectorized ones set here will start
+        // out as array_t<T> pointers, but they will be changed them to T pointers before we make
+        // call the wrapped function.  Non-vectorized pointers are left as-is.
+        std::array<void *, N> params{{reinterpret_cast<void *>(&args)...}};
+
+        // The array of `buffer_info`s of vectorized arguments:
+        std::array<buffer_info, NVectorized> buffers{
+            {reinterpret_cast<array *>(params[VIndex])->request()...}};
+
+        /* Determine dimensions parameters of output array */
+        ssize_t nd = 0;
+        std::vector<ssize_t> shape(0);
+        auto trivial = broadcast(buffers, nd, shape);
+        auto ndim = (size_t) nd;
+
+        size_t size
+            = std::accumulate(shape.begin(), shape.end(), (size_t) 1, std::multiplies<size_t>());
+
+        // If all arguments are 0-dimension arrays (i.e. single values) return a plain value (i.e.
+        // not wrapped in an array).
+        if (size == 1 && ndim == 0) {
+            PYBIND11_EXPAND_SIDE_EFFECTS(params[VIndex] = buffers[BIndex].ptr);
+            return cast(
+                returned_array::call(f, *reinterpret_cast<param_n_t<Index> *>(params[Index])...));
+        }
+
+        auto result = returned_array::create(trivial, shape);
+
+        PYBIND11_WARNING_PUSH
+#ifdef PYBIND11_DETECTED_CLANG_WITH_MISLEADING_CALL_STD_MOVE_EXPLICITLY_WARNING
+        PYBIND11_WARNING_DISABLE_CLANG("-Wreturn-std-move")
+#endif
+
+        if (size == 0) {
+            return result;
+        }
+
+        /* Call the function */
+        auto *mutable_data = returned_array::mutable_data(result);
+        if (trivial == broadcast_trivial::non_trivial) {
+            apply_broadcast(buffers, params, mutable_data, size, shape, i_seq, vi_seq, bi_seq);
+        } else {
+            apply_trivial(buffers, params, mutable_data, size, i_seq, vi_seq, bi_seq);
+        }
+
+        return result;
+        PYBIND11_WARNING_POP
+    }
+
+    template <size_t... Index, size_t... VIndex, size_t... BIndex>
+    void apply_trivial(std::array<buffer_info, NVectorized> &buffers,
+                       std::array<void *, N> &params,
+                       Return *out,
+                       size_t size,
+                       index_sequence<Index...>,
+                       index_sequence<VIndex...>,
+                       index_sequence<BIndex...>) {
+
+        // Initialize an array of mutable byte references and sizes with references set to the
+        // appropriate pointer in `params`; as we iterate, we'll increment each pointer by its size
+        // (except for singletons, which get an increment of 0).
+        std::array<std::pair<unsigned char *&, const size_t>, NVectorized> vecparams{
+            {std::pair<unsigned char *&, const size_t>(
+                reinterpret_cast<unsigned char *&>(params[VIndex] = buffers[BIndex].ptr),
+                buffers[BIndex].size == 1 ? 0 : sizeof(param_n_t<VIndex>))...}};
+
+        for (size_t i = 0; i < size; ++i) {
+            returned_array::call(
+                out, i, f, *reinterpret_cast<param_n_t<Index> *>(params[Index])...);
+            for (auto &x : vecparams) {
+                x.first += x.second;
+            }
+        }
+    }
+
+    template <size_t... Index, size_t... VIndex, size_t... BIndex>
+    void apply_broadcast(std::array<buffer_info, NVectorized> &buffers,
+                         std::array<void *, N> &params,
+                         Return *out,
+                         size_t size,
+                         const std::vector<ssize_t> &output_shape,
+                         index_sequence<Index...>,
+                         index_sequence<VIndex...>,
+                         index_sequence<BIndex...>) {
+
+        multi_array_iterator<NVectorized> input_iter(buffers, output_shape);
+
+        for (size_t i = 0; i < size; ++i, ++input_iter) {
+            PYBIND11_EXPAND_SIDE_EFFECTS((params[VIndex] = input_iter.template data<BIndex>()));
+            returned_array::call(
+                out, i, f, *reinterpret_cast<param_n_t<Index> *>(std::get<Index>(params))...);
+        }
+    }
+};
+
+template <typename Func, typename Return, typename... Args>
+vectorize_helper<Func, Return, Args...> vectorize_extractor(const Func &f, Return (*)(Args...)) {
+    return detail::vectorize_helper<Func, Return, Args...>(f);
+}
+
+template <typename T, int Flags>
+struct handle_type_name<array_t<T, Flags>> {
+    static constexpr auto name
+        = io_name("typing.Annotated[numpy.typing.ArrayLike, ", "numpy.typing.NDArray[")
+          + npy_format_descriptor<T>::name + const_name("]");
+};
+
+PYBIND11_NAMESPACE_END(detail)
+
+// Vanilla pointer vectorizer:
+template <typename Return, typename... Args>
+detail::vectorize_helper<Return (*)(Args...), Return, Args...> vectorize(Return (*f)(Args...)) {
+    return detail::vectorize_helper<Return (*)(Args...), Return, Args...>(f);
+}
+
+// lambda vectorizer:
+template <typename Func, detail::enable_if_t<detail::is_lambda<Func>::value, int> = 0>
+auto vectorize(Func &&f)
+    -> decltype(detail::vectorize_extractor(std::forward<Func>(f),
+                                            (detail::function_signature_t<Func> *) nullptr)) {
+    return detail::vectorize_extractor(std::forward<Func>(f),
+                                       (detail::function_signature_t<Func> *) nullptr);
+}
+
+// Vectorize a class method (non-const):
+template <typename Return,
+          typename Class,
+          typename... Args,
+          typename Helper = detail::vectorize_helper<
+              decltype(std::mem_fn(std::declval<Return (Class::*)(Args...)>())),
+              Return,
+              Class *,
+              Args...>>
+Helper vectorize(Return (Class::*f)(Args...)) {
+    return Helper(std::mem_fn(f));
+}
+
+// Vectorize a class method (const):
+template <typename Return,
+          typename Class,
+          typename... Args,
+          typename Helper = detail::vectorize_helper<
+              decltype(std::mem_fn(std::declval<Return (Class::*)(Args...) const>())),
+              Return,
+              const Class *,
+              Args...>>
+Helper vectorize(Return (Class::*f)(Args...) const) {
+    return Helper(std::mem_fn(f));
+}
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/operators.h b/local_pybind11/pybind11/include/pybind11/operators.h
new file mode 100644
index 000000000..16a88ae17
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/operators.h
@@ -0,0 +1,202 @@
+/*
+    pybind11/operator.h: Metatemplates for operator overloading
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "pybind11.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+/// Enumeration with all supported operator types
+enum op_id : int {
+    op_add,
+    op_sub,
+    op_mul,
+    op_div,
+    op_mod,
+    op_divmod,
+    op_pow,
+    op_lshift,
+    op_rshift,
+    op_and,
+    op_xor,
+    op_or,
+    op_neg,
+    op_pos,
+    op_abs,
+    op_invert,
+    op_int,
+    op_long,
+    op_float,
+    op_str,
+    op_cmp,
+    op_gt,
+    op_ge,
+    op_lt,
+    op_le,
+    op_eq,
+    op_ne,
+    op_iadd,
+    op_isub,
+    op_imul,
+    op_idiv,
+    op_imod,
+    op_ilshift,
+    op_irshift,
+    op_iand,
+    op_ixor,
+    op_ior,
+    op_complex,
+    op_bool,
+    op_nonzero,
+    op_repr,
+    op_truediv,
+    op_itruediv,
+    op_hash
+};
+
+enum op_type : int {
+    op_l, /* base type on left */
+    op_r, /* base type on right */
+    op_u  /* unary operator */
+};
+
+struct self_t {};
+static const self_t self = self_t();
+
+/// Type for an unused type slot
+struct undefined_t {};
+
+/// Don't warn about an unused variable
+inline self_t __self() { return self; }
+
+/// base template of operator implementations
+template <op_id, op_type, typename B, typename L, typename R>
+struct op_impl {};
+
+/// Operator implementation generator
+template <op_id id, op_type ot, typename L, typename R>
+struct op_ {
+    static constexpr bool op_enable_if_hook = true;
+    template <typename Class, typename... Extra>
+    void execute(Class &cl, const Extra &...extra) const {
+        using Base = typename Class::type;
+        using L_type = conditional_t<std::is_same<L, self_t>::value, Base, L>;
+        using R_type = conditional_t<std::is_same<R, self_t>::value, Base, R>;
+        using op = op_impl<id, ot, Base, L_type, R_type>;
+        cl.def(op::name(), &op::execute, is_operator(), extra...);
+    }
+    template <typename Class, typename... Extra>
+    void execute_cast(Class &cl, const Extra &...extra) const {
+        using Base = typename Class::type;
+        using L_type = conditional_t<std::is_same<L, self_t>::value, Base, L>;
+        using R_type = conditional_t<std::is_same<R, self_t>::value, Base, R>;
+        using op = op_impl<id, ot, Base, L_type, R_type>;
+        cl.def(op::name(), &op::execute_cast, is_operator(), extra...);
+    }
+};
+
+#define PYBIND11_BINARY_OPERATOR(id, rid, op, expr)                                               \
+    template <typename B, typename L, typename R>                                                 \
+    struct op_impl<op_##id, op_l, B, L, R> {                                                      \
+        static char const *name() { return "__" #id "__"; }                                       \
+        static auto execute(const L &l, const R &r) -> decltype(expr) { return (expr); }          \
+        static B execute_cast(const L &l, const R &r) { return B(expr); }                         \
+    };                                                                                            \
+    template <typename B, typename L, typename R>                                                 \
+    struct op_impl<op_##id, op_r, B, L, R> {                                                      \
+        static char const *name() { return "__" #rid "__"; }                                      \
+        static auto execute(const R &r, const L &l) -> decltype(expr) { return (expr); }          \
+        static B execute_cast(const R &r, const L &l) { return B(expr); }                         \
+    };                                                                                            \
+    inline op_<op_##id, op_l, self_t, self_t> op(const self_t &, const self_t &) {                \
+        return op_<op_##id, op_l, self_t, self_t>();                                              \
+    }                                                                                             \
+    template <typename T>                                                                         \
+    op_<op_##id, op_l, self_t, T> op(const self_t &, const T &) {                                 \
+        return op_<op_##id, op_l, self_t, T>();                                                   \
+    }                                                                                             \
+    template <typename T>                                                                         \
+    op_<op_##id, op_r, T, self_t> op(const T &, const self_t &) {                                 \
+        return op_<op_##id, op_r, T, self_t>();                                                   \
+    }
+
+#define PYBIND11_INPLACE_OPERATOR(id, op, expr)                                                   \
+    template <typename B, typename L, typename R>                                                 \
+    struct op_impl<op_##id, op_l, B, L, R> {                                                      \
+        static char const *name() { return "__" #id "__"; }                                       \
+        static auto execute(L &l, const R &r) -> decltype(expr) { return expr; }                  \
+        static B execute_cast(L &l, const R &r) { return B(expr); }                               \
+    };                                                                                            \
+    template <typename T>                                                                         \
+    op_<op_##id, op_l, self_t, T> op(const self_t &, const T &) {                                 \
+        return op_<op_##id, op_l, self_t, T>();                                                   \
+    }
+
+#define PYBIND11_UNARY_OPERATOR(id, op, expr)                                                     \
+    template <typename B, typename L>                                                             \
+    struct op_impl<op_##id, op_u, B, L, undefined_t> {                                            \
+        static char const *name() { return "__" #id "__"; }                                       \
+        static auto execute(const L &l) -> decltype(expr) { return expr; }                        \
+        static B execute_cast(const L &l) { return B(expr); }                                     \
+    };                                                                                            \
+    inline op_<op_##id, op_u, self_t, undefined_t> op(const self_t &) {                           \
+        return op_<op_##id, op_u, self_t, undefined_t>();                                         \
+    }
+
+PYBIND11_BINARY_OPERATOR(sub, rsub, operator-, l - r)
+PYBIND11_BINARY_OPERATOR(add, radd, operator+, l + r)
+PYBIND11_BINARY_OPERATOR(mul, rmul, operator*, l *r)
+PYBIND11_BINARY_OPERATOR(truediv, rtruediv, operator/, l / r)
+PYBIND11_BINARY_OPERATOR(mod, rmod, operator%, l % r)
+PYBIND11_BINARY_OPERATOR(lshift, rlshift, operator<<, l << r)
+PYBIND11_BINARY_OPERATOR(rshift, rrshift, operator>>, l >> r)
+PYBIND11_BINARY_OPERATOR(and, rand, operator&, l &r)
+PYBIND11_BINARY_OPERATOR(xor, rxor, operator^, l ^ r)
+PYBIND11_BINARY_OPERATOR(eq, eq, operator==, l == r)
+PYBIND11_BINARY_OPERATOR(ne, ne, operator!=, l != r)
+PYBIND11_BINARY_OPERATOR(or, ror, operator|, l | r)
+PYBIND11_BINARY_OPERATOR(gt, lt, operator>, l > r)
+PYBIND11_BINARY_OPERATOR(ge, le, operator>=, l >= r)
+PYBIND11_BINARY_OPERATOR(lt, gt, operator<, l < r)
+PYBIND11_BINARY_OPERATOR(le, ge, operator<=, l <= r)
+// PYBIND11_BINARY_OPERATOR(pow,       rpow,         pow,          std::pow(l,  r))
+PYBIND11_INPLACE_OPERATOR(iadd, operator+=, l += r)
+PYBIND11_INPLACE_OPERATOR(isub, operator-=, l -= r)
+PYBIND11_INPLACE_OPERATOR(imul, operator*=, l *= r)
+PYBIND11_INPLACE_OPERATOR(itruediv, operator/=, l /= r)
+PYBIND11_INPLACE_OPERATOR(imod, operator%=, l %= r)
+PYBIND11_INPLACE_OPERATOR(ilshift, operator<<=, l <<= r)
+PYBIND11_INPLACE_OPERATOR(irshift, operator>>=, l >>= r)
+PYBIND11_INPLACE_OPERATOR(iand, operator&=, l &= r)
+PYBIND11_INPLACE_OPERATOR(ixor, operator^=, l ^= r)
+PYBIND11_INPLACE_OPERATOR(ior, operator|=, l |= r)
+PYBIND11_UNARY_OPERATOR(neg, operator-, -l)
+PYBIND11_UNARY_OPERATOR(pos, operator+, +l)
+// WARNING: This usage of `abs` should only be done for existing STL overloads.
+// Adding overloads directly in to the `std::` namespace is advised against:
+// https://en.cppreference.com/w/cpp/language/extending_std
+PYBIND11_UNARY_OPERATOR(abs, abs, std::abs(l))
+PYBIND11_UNARY_OPERATOR(hash, hash, std::hash<L>()(l))
+PYBIND11_UNARY_OPERATOR(invert, operator~, (~l))
+PYBIND11_UNARY_OPERATOR(bool, operator!, !!l)
+PYBIND11_UNARY_OPERATOR(int, int_, (int) l)
+PYBIND11_UNARY_OPERATOR(float, float_, (double) l)
+
+#undef PYBIND11_BINARY_OPERATOR
+#undef PYBIND11_INPLACE_OPERATOR
+#undef PYBIND11_UNARY_OPERATOR
+PYBIND11_NAMESPACE_END(detail)
+
+using detail::self;
+// Add named operators so that they are accessible via `py::`.
+using detail::hash;
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/options.h b/local_pybind11/pybind11/include/pybind11/options.h
new file mode 100644
index 000000000..1b2122522
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/options.h
@@ -0,0 +1,92 @@
+/*
+    pybind11/options.h: global settings that are configurable at runtime.
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "detail/common.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+class options {
+public:
+    // Default RAII constructor, which leaves settings as they currently are.
+    options() : previous_state(global_state()) {}
+
+    // Class is non-copyable.
+    options(const options &) = delete;
+    options &operator=(const options &) = delete;
+
+    // Destructor, which restores settings that were in effect before.
+    ~options() { global_state() = previous_state; }
+
+    // Setter methods (affect the global state):
+
+    options &disable_user_defined_docstrings() & {
+        global_state().show_user_defined_docstrings = false;
+        return *this;
+    }
+
+    options &enable_user_defined_docstrings() & {
+        global_state().show_user_defined_docstrings = true;
+        return *this;
+    }
+
+    options &disable_function_signatures() & {
+        global_state().show_function_signatures = false;
+        return *this;
+    }
+
+    options &enable_function_signatures() & {
+        global_state().show_function_signatures = true;
+        return *this;
+    }
+
+    options &disable_enum_members_docstring() & {
+        global_state().show_enum_members_docstring = false;
+        return *this;
+    }
+
+    options &enable_enum_members_docstring() & {
+        global_state().show_enum_members_docstring = true;
+        return *this;
+    }
+
+    // Getter methods (return the global state):
+
+    static bool show_user_defined_docstrings() {
+        return global_state().show_user_defined_docstrings;
+    }
+
+    static bool show_function_signatures() { return global_state().show_function_signatures; }
+
+    static bool show_enum_members_docstring() {
+        return global_state().show_enum_members_docstring;
+    }
+
+    // This type is not meant to be allocated on the heap.
+    void *operator new(size_t) = delete;
+
+private:
+    struct state {
+        bool show_user_defined_docstrings = true; //< Include user-supplied texts in docstrings.
+        bool show_function_signatures = true;     //< Include auto-generated function signatures
+                                                  //  in docstrings.
+        bool show_enum_members_docstring = true;  //< Include auto-generated member list in enum
+                                                  //  docstrings.
+    };
+
+    static state &global_state() {
+        static state instance;
+        return instance;
+    }
+
+    state previous_state;
+};
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/pybind11.h b/local_pybind11/pybind11/include/pybind11/pybind11.h
new file mode 100644
index 000000000..117fecabf
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/pybind11.h
@@ -0,0 +1,3645 @@
+/*
+    pybind11/pybind11.h: Main header file of the C++11 python
+    binding generator library
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+#include "detail/class.h"
+#include "detail/dynamic_raw_ptr_cast_if_possible.h"
+#include "detail/exception_translation.h"
+#include "detail/function_record_pyobject.h"
+#include "detail/init.h"
+#include "detail/native_enum_data.h"
+#include "detail/using_smart_holder.h"
+#include "attr.h"
+#include "gil.h"
+#include "gil_safe_call_once.h"
+#include "options.h"
+#include "trampoline_self_life_support.h"
+#include "typing.h"
+
+#include <cassert>
+#include <cstdlib>
+#include <cstring>
+#include <memory>
+#include <new>
+#include <stack>
+#include <string>
+#include <utility>
+#include <vector>
+
+// See PR #5448. This warning suppression is needed for the PYBIND11_OVERRIDE macro family.
+// NOTE that this is NOT embedded in a push/pop pair because that is very difficult to achieve.
+#if defined(__clang_major__) && __clang_major__ < 14
+PYBIND11_WARNING_DISABLE_CLANG("-Wgnu-zero-variadic-macro-arguments")
+#endif
+
+#if defined(__GNUG__) && !defined(__clang__)
+#    include <cxxabi.h>
+#endif
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+/* https://stackoverflow.com/questions/46798456/handling-gccs-noexcept-type-warning
+   This warning is about ABI compatibility, not code health.
+   It is only actually needed in a couple places, but apparently GCC 7 "generates this warning if
+   and only if the first template instantiation ... involves noexcept" [stackoverflow], therefore
+   it could get triggered from seemingly random places, depending on user code.
+   No other GCC version generates this warning.
+ */
+#if defined(__GNUC__) && __GNUC__ == 7
+PYBIND11_WARNING_DISABLE_GCC("-Wnoexcept-type")
+#endif
+
+PYBIND11_WARNING_DISABLE_MSVC(4127)
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+inline std::string replace_newlines_and_squash(const char *text) {
+    const char *whitespaces = " \t\n\r\f\v";
+    std::string result(text);
+    bool previous_is_whitespace = false;
+
+    if (result.size() >= 2) {
+        // Do not modify string representations
+        char first_char = result[0];
+        char last_char = result[result.size() - 1];
+        if (first_char == last_char && first_char == '\'') {
+            return result;
+        }
+    }
+    result.clear();
+
+    // Replace characters in whitespaces array with spaces and squash consecutive spaces
+    while (*text != '\0') {
+        if (std::strchr(whitespaces, *text)) {
+            if (!previous_is_whitespace) {
+                result += ' ';
+                previous_is_whitespace = true;
+            }
+        } else {
+            result += *text;
+            previous_is_whitespace = false;
+        }
+        ++text;
+    }
+
+    // Strip leading and trailing whitespaces
+    const size_t str_begin = result.find_first_not_of(whitespaces);
+    if (str_begin == std::string::npos) {
+        return "";
+    }
+
+    const size_t str_end = result.find_last_not_of(whitespaces);
+    const size_t str_range = str_end - str_begin + 1;
+
+    return result.substr(str_begin, str_range);
+}
+
+/* Generate a proper function signature */
+inline std::string generate_function_signature(const char *type_caster_name_field,
+                                               detail::function_record *func_rec,
+                                               const std::type_info *const *types,
+                                               size_t &type_index,
+                                               size_t &arg_index) {
+    std::string signature;
+    bool is_starred = false;
+    // `is_return_value.top()` is true if we are currently inside the return type of the
+    // signature. Using `@^`/`@$` we can force types to be arg/return types while `@!` pops
+    // back to the previous state.
+    std::stack<bool> is_return_value({false});
+    // The following characters have special meaning in the signature parsing. Literals
+    // containing these are escaped with `!`.
+    std::string special_chars("!@%{}-");
+    for (const auto *pc = type_caster_name_field; *pc != '\0'; ++pc) {
+        const auto c = *pc;
+        if (c == '{') {
+            // Write arg name for everything except *args and **kwargs.
+            is_starred = *(pc + 1) == '*';
+            if (is_starred) {
+                continue;
+            }
+            // Separator for keyword-only arguments, placed before the kw
+            // arguments start (unless we are already putting an *args)
+            if (!func_rec->has_args && arg_index == func_rec->nargs_pos) {
+                signature += "*, ";
+            }
+            if (arg_index < func_rec->args.size() && func_rec->args[arg_index].name) {
+                signature += func_rec->args[arg_index].name;
+            } else if (arg_index == 0 && func_rec->is_method) {
+                signature += "self";
+            } else {
+                signature += "arg" + std::to_string(arg_index - (func_rec->is_method ? 1 : 0));
+            }
+            signature += ": ";
+        } else if (c == '}') {
+            // Write default value if available.
+            if (!is_starred && arg_index < func_rec->args.size()
+                && func_rec->args[arg_index].descr) {
+                signature += " = ";
+                signature += detail::replace_newlines_and_squash(func_rec->args[arg_index].descr);
+            }
+            // Separator for positional-only arguments (placed after the
+            // argument, rather than before like *
+            if (func_rec->nargs_pos_only > 0 && (arg_index + 1) == func_rec->nargs_pos_only) {
+                signature += ", /";
+            }
+            if (!is_starred) {
+                arg_index++;
+            }
+        } else if (c == '%') {
+            const std::type_info *t = types[type_index++];
+            if (!t) {
+                pybind11_fail("Internal error while parsing type signature (1)");
+            }
+            if (auto *tinfo = detail::get_type_info(*t)) {
+                handle th((PyObject *) tinfo->type);
+                signature += th.attr("__module__").cast<std::string>() + "."
+                             + th.attr("__qualname__").cast<std::string>();
+            } else if (auto th = detail::global_internals_native_enum_type_map_get_item(*t)) {
+                signature += th.attr("__module__").cast<std::string>() + "."
+                             + th.attr("__qualname__").cast<std::string>();
+            } else if (func_rec->is_new_style_constructor && arg_index == 0) {
+                // A new-style `__init__` takes `self` as `value_and_holder`.
+                // Rewrite it to the proper class type.
+                signature += func_rec->scope.attr("__module__").cast<std::string>() + "."
+                             + func_rec->scope.attr("__qualname__").cast<std::string>();
+            } else {
+                signature += detail::quote_cpp_type_name(detail::clean_type_id(t->name()));
+            }
+        } else if (c == '!' && special_chars.find(*(pc + 1)) != std::string::npos) {
+            // typing::Literal escapes special characters with !
+            signature += *++pc;
+        } else if (c == '@') {
+            // `@^ ... @!` and `@$ ... @!` are used to force arg/return value type (see
+            // typing::Callable/detail::arg_descr/detail::return_descr)
+            if (*(pc + 1) == '^') {
+                is_return_value.emplace(false);
+                ++pc;
+                continue;
+            }
+            if (*(pc + 1) == '$') {
+                is_return_value.emplace(true);
+                ++pc;
+                continue;
+            }
+            if (*(pc + 1) == '!') {
+                is_return_value.pop();
+                ++pc;
+                continue;
+            }
+            // Handle types that differ depending on whether they appear
+            // in an argument or a return value position (see io_name<text1, text2>).
+            // For named arguments (py::arg()) with noconvert set, return value type is used.
+            ++pc;
+            if (!is_return_value.top()
+                && (!(arg_index < func_rec->args.size() && !func_rec->args[arg_index].convert))) {
+                while (*pc != '\0' && *pc != '@') {
+                    signature += *pc++;
+                }
+                if (*pc == '@') {
+                    ++pc;
+                }
+                while (*pc != '\0' && *pc != '@') {
+                    ++pc;
+                }
+            } else {
+                while (*pc != '\0' && *pc != '@') {
+                    ++pc;
+                }
+                if (*pc == '@') {
+                    ++pc;
+                }
+                while (*pc != '\0' && *pc != '@') {
+                    signature += *pc++;
+                }
+            }
+        } else {
+            if (c == '-' && *(pc + 1) == '>') {
+                is_return_value.emplace(true);
+            }
+            signature += c;
+        }
+    }
+    return signature;
+}
+
+template <typename T>
+inline std::string generate_type_signature() {
+    static constexpr auto caster_name_field = make_caster<T>::name;
+    PYBIND11_DESCR_CONSTEXPR auto descr_types = decltype(caster_name_field)::types();
+    // Create a default function_record to ensure the function signature has the proper
+    // configuration e.g. no_convert.
+    auto func_rec = function_record();
+    size_t type_index = 0;
+    size_t arg_index = 0;
+    return generate_function_signature(
+        caster_name_field.text, &func_rec, descr_types.data(), type_index, arg_index);
+}
+
+#if defined(_MSC_VER)
+#    define PYBIND11_COMPAT_STRDUP _strdup
+#else
+#    define PYBIND11_COMPAT_STRDUP strdup
+#endif
+
+PYBIND11_NAMESPACE_END(detail)
+
+/// Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object
+class cpp_function : public function {
+public:
+    cpp_function() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    cpp_function(std::nullptr_t) {}
+    cpp_function(std::nullptr_t, const is_setter &) {}
+
+    /// Construct a cpp_function from a vanilla function pointer
+    template <typename Return, typename... Args, typename... Extra>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    cpp_function(Return (*f)(Args...), const Extra &...extra) {
+        initialize(f, f, extra...);
+    }
+
+    /// Construct a cpp_function from a lambda function (possibly with internal state)
+    template <typename Func,
+              typename... Extra,
+              typename = detail::enable_if_t<detail::is_lambda<Func>::value>>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    cpp_function(Func &&f, const Extra &...extra) {
+        initialize(
+            std::forward<Func>(f), (detail::function_signature_t<Func> *) nullptr, extra...);
+    }
+
+    /// Construct a cpp_function from a class method (non-const, no ref-qualifier)
+    template <typename Return, typename Class, typename... Arg, typename... Extra>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    cpp_function(Return (Class::*f)(Arg...), const Extra &...extra) {
+        initialize(
+            [f](Class *c, Arg... args) -> Return { return (c->*f)(std::forward<Arg>(args)...); },
+            (Return (*)(Class *, Arg...)) nullptr,
+            extra...);
+    }
+
+    /// Construct a cpp_function from a class method (non-const, lvalue ref-qualifier)
+    /// A copy of the overload for non-const functions without explicit ref-qualifier
+    /// but with an added `&`.
+    template <typename Return, typename Class, typename... Arg, typename... Extra>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    cpp_function(Return (Class::*f)(Arg...) &, const Extra &...extra) {
+        initialize(
+            [f](Class *c, Arg... args) -> Return { return (c->*f)(std::forward<Arg>(args)...); },
+            (Return (*)(Class *, Arg...)) nullptr,
+            extra...);
+    }
+
+    /// Construct a cpp_function from a class method (const, no ref-qualifier)
+    template <typename Return, typename Class, typename... Arg, typename... Extra>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    cpp_function(Return (Class::*f)(Arg...) const, const Extra &...extra) {
+        initialize([f](const Class *c,
+                       Arg... args) -> Return { return (c->*f)(std::forward<Arg>(args)...); },
+                   (Return (*)(const Class *, Arg...)) nullptr,
+                   extra...);
+    }
+
+    /// Construct a cpp_function from a class method (const, lvalue ref-qualifier)
+    /// A copy of the overload for const functions without explicit ref-qualifier
+    /// but with an added `&`.
+    template <typename Return, typename Class, typename... Arg, typename... Extra>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    cpp_function(Return (Class::*f)(Arg...) const &, const Extra &...extra) {
+        initialize([f](const Class *c,
+                       Arg... args) -> Return { return (c->*f)(std::forward<Arg>(args)...); },
+                   (Return (*)(const Class *, Arg...)) nullptr,
+                   extra...);
+    }
+
+    /// Return the function name
+    object name() const { return attr("__name__"); }
+
+protected:
+    struct InitializingFunctionRecordDeleter {
+        // `destruct(function_record, false)`: `initialize_generic` copies strings and
+        // takes care of cleaning up in case of exceptions. So pass `false` to `free_strings`.
+        void operator()(detail::function_record *rec) { destruct(rec, false); }
+    };
+    using unique_function_record
+        = std::unique_ptr<detail::function_record, InitializingFunctionRecordDeleter>;
+
+    /// Space optimization: don't inline this frequently instantiated fragment
+    PYBIND11_NOINLINE unique_function_record make_function_record() {
+        return unique_function_record(new detail::function_record());
+    }
+
+    /// Special internal constructor for functors, lambda functions, etc.
+    template <typename Func, typename Return, typename... Args, typename... Extra>
+    void initialize(Func &&f, Return (*)(Args...), const Extra &...extra) {
+        using namespace detail;
+        struct capture {
+            remove_reference_t<Func> f;
+
+            static capture *from_data(void **data) {
+                return PYBIND11_STD_LAUNDER(reinterpret_cast<capture *>(data));
+            }
+        };
+
+        /* Store the function including any extra state it might have (e.g. a lambda capture
+         * object) */
+        // The unique_ptr makes sure nothing is leaked in case of an exception.
+        auto unique_rec = make_function_record();
+        auto *rec = unique_rec.get();
+
+        /* Store the capture object directly in the function record if there is enough space */
+        if (sizeof(capture) <= sizeof(rec->data)) {
+            /* Without these pragmas, GCC warns that there might not be
+               enough space to use the placement new operator. However, the
+               'if' statement above ensures that this is the case. */
+            PYBIND11_WARNING_PUSH
+
+#if defined(__GNUG__) && __GNUC__ >= 6
+            PYBIND11_WARNING_DISABLE_GCC("-Wplacement-new")
+#endif
+
+            new (capture::from_data(rec->data)) capture{std::forward<Func>(f)};
+
+#if !PYBIND11_HAS_STD_LAUNDER
+            PYBIND11_WARNING_DISABLE_GCC("-Wstrict-aliasing")
+#endif
+
+            // UB without std::launder, but without breaking ABI and/or
+            // a significant refactoring it's "impossible" to solve.
+            if (!std::is_trivially_destructible<capture>::value) {
+                rec->free_data = [](function_record *r) {
+                    auto data = capture::from_data(r->data);
+                    (void) data; // suppress "unused variable" warnings
+                    data->~capture();
+                };
+            }
+            PYBIND11_WARNING_POP
+        } else {
+            rec->data[0] = new capture{std::forward<Func>(f)};
+            rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
+        }
+
+        /* Type casters for the function arguments and return value */
+        using cast_in = argument_loader<Args...>;
+        using cast_out
+            = make_caster<conditional_t<std::is_void<Return>::value, void_type, Return>>;
+
+        static_assert(
+            expected_num_args<Extra...>(
+                sizeof...(Args), cast_in::args_pos >= 0, cast_in::has_kwargs),
+            "The number of argument annotations does not match the number of function arguments");
+
+        /* Dispatch code which converts function arguments and performs the actual function call */
+        rec->impl = [](function_call &call) -> handle {
+            cast_in args_converter;
+
+            /* Try to cast the function arguments into the C++ domain */
+            if (!args_converter.load_args(call)) {
+                return PYBIND11_TRY_NEXT_OVERLOAD;
+            }
+
+            /* Invoke call policy pre-call hook */
+            process_attributes<Extra...>::precall(call);
+
+            /* Get a pointer to the capture object */
+            const auto *data = (sizeof(capture) <= sizeof(call.func.data) ? &call.func.data
+                                                                          : call.func.data[0]);
+            auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
+
+            /* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
+            return_value_policy policy
+                = return_value_policy_override<Return>::policy(call.func.policy);
+
+            /* Function scope guard -- defaults to the compile-to-nothing `void_type` */
+            using Guard = extract_guard_t<Extra...>;
+
+            /* Perform the function call */
+            handle result;
+            if (call.func.is_setter) {
+                (void) std::move(args_converter).template call<Return, Guard>(cap->f);
+                result = none().release();
+            } else {
+                result = cast_out::cast(
+                    std::move(args_converter).template call<Return, Guard>(cap->f),
+                    policy,
+                    call.parent);
+            }
+
+            /* Invoke call policy post-call hook */
+            process_attributes<Extra...>::postcall(call, result);
+
+            return result;
+        };
+
+        rec->nargs_pos = cast_in::args_pos >= 0
+                             ? static_cast<std::uint16_t>(cast_in::args_pos)
+                             : sizeof...(Args) - cast_in::has_kwargs; // Will get reduced more if
+                                                                      // we have a kw_only
+        rec->has_args = cast_in::args_pos >= 0;
+        rec->has_kwargs = cast_in::has_kwargs;
+
+        /* Process any user-provided function attributes */
+        process_attributes<Extra...>::init(extra..., rec);
+
+        {
+            constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
+                           has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
+                           has_arg_annotations = any_of<is_keyword<Extra>...>::value;
+            constexpr bool has_is_method = any_of<std::is_same<is_method, Extra>...>::value;
+            // The implicit `self` argument is not present and not counted in method definitions.
+            constexpr bool has_args = cast_in::args_pos >= 0;
+            constexpr bool is_method_with_self_arg_only = has_is_method && !has_args;
+            static_assert(has_arg_annotations || !has_kw_only_args,
+                          "py::kw_only requires the use of argument annotations");
+            static_assert(((/* Need `py::arg("arg_name")` annotation in function/method. */
+                            has_arg_annotations)
+                           || (/* Allow methods with no arguments `def method(self, /): ...`.
+                                * A method has at least one argument `self`. There can be no
+                                * `py::arg` annotation. E.g. `class.def("method", py::pos_only())`.
+                                */
+                               is_method_with_self_arg_only))
+                              || !has_pos_only_args,
+                          "py::pos_only requires the use of argument annotations (for docstrings "
+                          "and aligning the annotations to the argument)");
+
+            static_assert(constexpr_sum(is_kw_only<Extra>::value...) <= 1,
+                          "py::kw_only may be specified only once");
+            static_assert(constexpr_sum(is_pos_only<Extra>::value...) <= 1,
+                          "py::pos_only may be specified only once");
+            constexpr auto kw_only_pos = constexpr_first<is_kw_only, Extra...>();
+            constexpr auto pos_only_pos = constexpr_first<is_pos_only, Extra...>();
+            static_assert(!(has_kw_only_args && has_pos_only_args) || pos_only_pos < kw_only_pos,
+                          "py::pos_only must come before py::kw_only");
+        }
+
+        /* Generate a readable signature describing the function's arguments and return
+           value types */
+        static constexpr auto signature
+            = const_name("(") + cast_in::arg_names + const_name(") -> ") + cast_out::name;
+        PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
+
+        /* Register the function with Python from generic (non-templated) code */
+        // Pass on the ownership over the `unique_rec` to `initialize_generic`. `rec` stays valid.
+        initialize_generic(std::move(unique_rec), signature.text, types.data(), sizeof...(Args));
+
+        /* Stash some additional information used by an important optimization in 'functional.h' */
+        using FunctionType = Return (*)(Args...);
+        constexpr bool is_function_ptr
+            = std::is_convertible<Func, FunctionType>::value && sizeof(capture) == sizeof(void *);
+        PYBIND11_ENSURE_PRECONDITION_FOR_FUNCTIONAL_H_PERFORMANCE_OPTIMIZATIONS(
+            !is_function_ptr || std::is_standard_layout<capture>::value);
+        if (is_function_ptr) {
+            rec->is_stateless = true;
+            rec->data[1]
+                = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
+        }
+    }
+
+    // Utility class that keeps track of all duplicated strings, and cleans them up in its
+    // destructor, unless they are released. Basically a RAII-solution to deal with exceptions
+    // along the way.
+    class strdup_guard {
+    public:
+        strdup_guard() = default;
+        strdup_guard(const strdup_guard &) = delete;
+        strdup_guard &operator=(const strdup_guard &) = delete;
+
+        ~strdup_guard() {
+            for (auto *s : strings) {
+                std::free(s);
+            }
+        }
+        char *operator()(const char *s) {
+            auto *t = PYBIND11_COMPAT_STRDUP(s);
+            strings.push_back(t);
+            return t;
+        }
+        void release() { strings.clear(); }
+
+    private:
+        std::vector<char *> strings;
+    };
+
+    /// Register a function call with Python (generic non-templated code goes here)
+    void initialize_generic(unique_function_record &&unique_rec,
+                            const char *text,
+                            const std::type_info *const *types,
+                            size_t args) {
+        // Do NOT receive `unique_rec` by value. If this function fails to move out the unique_ptr,
+        // we do not want this to destruct the pointer. `initialize` (the caller) still relies on
+        // the pointee being alive after this call. Only move out if a `capsule` is going to keep
+        // it alive.
+        auto *rec = unique_rec.get();
+
+        // Keep track of strdup'ed strings, and clean them up as long as the function's capsule
+        // has not taken ownership yet (when `unique_rec.release()` is called).
+        // Note: This cannot easily be fixed by a `unique_ptr` with custom deleter, because the
+        // strings are only referenced before strdup'ing. So only *after* the following block could
+        // `destruct` safely be called, but even then, `repr` could still throw in the middle of
+        // copying all strings.
+        strdup_guard guarded_strdup;
+
+        /* Create copies of all referenced C-style strings */
+        rec->name = guarded_strdup(rec->name ? rec->name : "");
+        if (rec->doc) {
+            rec->doc = guarded_strdup(rec->doc);
+        }
+        for (auto &a : rec->args) {
+            if (a.name) {
+                a.name = guarded_strdup(a.name);
+            }
+            if (a.descr) {
+                a.descr = guarded_strdup(a.descr);
+            } else if (a.value) {
+                a.descr = guarded_strdup(repr(a.value).cast<std::string>().c_str());
+            }
+        }
+
+        rec->is_constructor = (std::strcmp(rec->name, "__init__") == 0)
+                              || (std::strcmp(rec->name, "__setstate__") == 0);
+
+#if defined(PYBIND11_DETAILED_ERROR_MESSAGES) && !defined(PYBIND11_DISABLE_NEW_STYLE_INIT_WARNING)
+        if (rec->is_constructor && !rec->is_new_style_constructor) {
+            const auto class_name
+                = detail::get_fully_qualified_tp_name((PyTypeObject *) rec->scope.ptr());
+            const auto func_name = std::string(rec->name);
+            PyErr_WarnEx(PyExc_FutureWarning,
+                         ("pybind11-bound class '" + class_name
+                          + "' is using an old-style "
+                            "placement-new '"
+                          + func_name
+                          + "' which has been deprecated. See "
+                            "the upgrade guide in pybind11's docs. This message is only visible "
+                            "when compiled in debug mode.")
+                             .c_str(),
+                         0);
+        }
+#endif
+
+        size_t type_index = 0, arg_index = 0;
+        std::string signature
+            = detail::generate_function_signature(text, rec, types, type_index, arg_index);
+
+        if (arg_index != args - rec->has_args - rec->has_kwargs || types[type_index] != nullptr) {
+            pybind11_fail("Internal error while parsing type signature (2)");
+        }
+
+        rec->signature = guarded_strdup(signature.c_str());
+        rec->args.shrink_to_fit();
+        rec->nargs = (std::uint16_t) args;
+
+        if (rec->sibling && PYBIND11_INSTANCE_METHOD_CHECK(rec->sibling.ptr())) {
+            rec->sibling = PYBIND11_INSTANCE_METHOD_GET_FUNCTION(rec->sibling.ptr());
+        }
+
+        detail::function_record *chain = nullptr, *chain_start = rec;
+        if (rec->sibling) {
+            if (PyCFunction_Check(rec->sibling.ptr())) {
+                auto *self = PyCFunction_GET_SELF(rec->sibling.ptr());
+                if (self == nullptr) {
+                    pybind11_fail(
+                        "initialize_generic: Unexpected nullptr from PyCFunction_GET_SELF");
+                }
+                chain = detail::function_record_ptr_from_PyObject(self);
+                if (chain && !chain->scope.is(rec->scope)) {
+                    /* Never append a method to an overload chain of a parent class;
+                       instead, hide the parent's overloads in this case */
+                    chain = nullptr;
+                }
+            }
+            // Don't trigger for things like the default __init__, which are wrapper_descriptors
+            // that we are intentionally replacing
+            else if (!rec->sibling.is_none() && rec->name[0] != '_') {
+                pybind11_fail("Cannot overload existing non-function object \""
+                              + std::string(rec->name) + "\" with a function of the same name");
+            }
+        }
+
+        if (!chain) {
+            /* No existing overload was found, create a new function object */
+            rec->def = new PyMethodDef();
+            std::memset(rec->def, 0, sizeof(PyMethodDef));
+            rec->def->ml_name = rec->name;
+            rec->def->ml_meth
+                = reinterpret_cast<PyCFunction>(reinterpret_cast<void (*)()>(dispatcher));
+            rec->def->ml_flags = METH_VARARGS | METH_KEYWORDS;
+
+            object py_func_rec = detail::function_record_PyObject_New();
+            ((detail::function_record_PyObject *) py_func_rec.ptr())->cpp_func_rec
+                = unique_rec.release();
+            guarded_strdup.release();
+
+            object scope_module = detail::get_scope_module(rec->scope);
+            m_ptr = PyCFunction_NewEx(rec->def, py_func_rec.ptr(), scope_module.ptr());
+            if (!m_ptr) {
+                pybind11_fail("cpp_function::cpp_function(): Could not allocate function object");
+            }
+        } else {
+            /* Append at the beginning or end of the overload chain */
+            m_ptr = rec->sibling.ptr();
+            inc_ref();
+            if (chain->is_method != rec->is_method) {
+                pybind11_fail(
+                    "overloading a method with both static and instance methods is not supported; "
+#if !defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+                    "#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for more "
+                    "details"
+#else
+                    "error while attempting to bind "
+                    + std::string(rec->is_method ? "instance" : "static") + " method "
+                    + std::string(pybind11::str(rec->scope.attr("__name__"))) + "."
+                    + std::string(rec->name) + signature
+#endif
+                );
+            }
+
+            if (rec->prepend) {
+                // Beginning of chain; we need to replace the capsule's current head-of-the-chain
+                // pointer with this one, then make this one point to the previous head of the
+                // chain.
+                chain_start = rec;
+                rec->next = chain;
+                auto *py_func_rec
+                    = (detail::function_record_PyObject *) PyCFunction_GET_SELF(m_ptr);
+                py_func_rec->cpp_func_rec = unique_rec.release();
+                guarded_strdup.release();
+            } else {
+                // Or end of chain (normal behavior)
+                chain_start = chain;
+                while (chain->next) {
+                    chain = chain->next;
+                }
+                chain->next = unique_rec.release();
+                guarded_strdup.release();
+            }
+        }
+
+        std::string signatures;
+        int index = 0;
+        /* Create a nice pydoc rec including all signatures and
+           docstrings of the functions in the overload chain */
+        if (chain && options::show_function_signatures()
+            && std::strcmp(rec->name, "_pybind11_conduit_v1_") != 0) {
+            // First a generic signature
+            signatures += rec->name;
+            signatures += "(*args, **kwargs)\n";
+            signatures += "Overloaded function.\n\n";
+        }
+        // Then specific overload signatures
+        bool first_user_def = true;
+        for (auto *it = chain_start; it != nullptr; it = it->next) {
+            if (options::show_function_signatures()
+                && std::strcmp(rec->name, "_pybind11_conduit_v1_") != 0) {
+                if (index > 0) {
+                    signatures += '\n';
+                }
+                if (chain) {
+                    signatures += std::to_string(++index) + ". ";
+                }
+                signatures += rec->name;
+                signatures += it->signature;
+                signatures += '\n';
+            }
+            if (it->doc && it->doc[0] != '\0' && options::show_user_defined_docstrings()) {
+                // If we're appending another docstring, and aren't printing function signatures,
+                // we need to append a newline first:
+                if (!options::show_function_signatures()) {
+                    if (first_user_def) {
+                        first_user_def = false;
+                    } else {
+                        signatures += '\n';
+                    }
+                }
+                if (options::show_function_signatures()) {
+                    signatures += '\n';
+                }
+                signatures += it->doc;
+                if (options::show_function_signatures()) {
+                    signatures += '\n';
+                }
+            }
+        }
+
+        auto *func = (PyCFunctionObject *) m_ptr;
+        // Install docstring if it's non-empty (when at least one option is enabled)
+        auto *doc = signatures.empty() ? nullptr : PYBIND11_COMPAT_STRDUP(signatures.c_str());
+        std::free(const_cast<char *>(PYBIND11_PYCFUNCTION_GET_DOC(func)));
+        PYBIND11_PYCFUNCTION_SET_DOC(func, doc);
+
+        if (rec->is_method) {
+            m_ptr = PYBIND11_INSTANCE_METHOD_NEW(m_ptr, rec->scope.ptr());
+            if (!m_ptr) {
+                pybind11_fail(
+                    "cpp_function::cpp_function(): Could not allocate instance method object");
+            }
+            Py_DECREF(func);
+        }
+    }
+
+    friend void detail::function_record_PyTypeObject_methods::tp_dealloc_impl(PyObject *);
+
+    /// When a cpp_function is GCed, release any memory allocated by pybind11
+    static void destruct(detail::function_record *rec, bool free_strings = true) {
+// If on Python 3.9, check the interpreter "MICRO" (patch) version.
+// If this is running on 3.9.0, we have to work around a bug.
+#if !defined(PYPY_VERSION) && PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION == 9
+        static bool is_zero = Py_GetVersion()[4] == '0';
+#endif
+
+        while (rec) {
+            detail::function_record *next = rec->next;
+            if (rec->free_data) {
+                rec->free_data(rec);
+            }
+            // During initialization, these strings might not have been copied yet,
+            // so they cannot be freed. Once the function has been created, they can.
+            // Check `make_function_record` for more details.
+            if (free_strings) {
+                std::free((char *) rec->name);
+                std::free((char *) rec->doc);
+                std::free((char *) rec->signature);
+                for (auto &arg : rec->args) {
+                    std::free(const_cast<char *>(arg.name));
+                    std::free(const_cast<char *>(arg.descr));
+                }
+            }
+            for (auto &arg : rec->args) {
+                arg.value.dec_ref();
+            }
+            if (rec->def) {
+                std::free(const_cast<char *>(rec->def->ml_doc));
+// Python 3.9.0 decref's these in the wrong order; rec->def
+// If loaded on 3.9.0, let these leak (use Python 3.9.1 at runtime to fix)
+// See https://github.com/python/cpython/pull/22670
+#if !defined(PYPY_VERSION) && PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION == 9
+                if (!is_zero) {
+                    delete rec->def;
+                }
+#else
+                delete rec->def;
+#endif
+            }
+            delete rec;
+            rec = next;
+        }
+    }
+
+    /// Main dispatch logic for calls to functions bound using pybind11
+    static PyObject *dispatcher(PyObject *self, PyObject *args_in, PyObject *kwargs_in) {
+        using namespace detail;
+        const function_record *overloads = function_record_ptr_from_PyObject(self);
+        assert(overloads != nullptr);
+
+        /* Iterator over the list of potentially admissible overloads */
+        const function_record *current_overload = overloads;
+
+        /* Need to know how many arguments + keyword arguments there are to pick the right
+           overload */
+        const auto n_args_in = (size_t) PyTuple_GET_SIZE(args_in);
+
+        handle parent = n_args_in > 0 ? PyTuple_GET_ITEM(args_in, 0) : nullptr,
+               result = PYBIND11_TRY_NEXT_OVERLOAD;
+
+        auto self_value_and_holder = value_and_holder();
+        if (overloads->is_constructor) {
+            if (!parent
+                || !PyObject_TypeCheck(parent.ptr(), (PyTypeObject *) overloads->scope.ptr())) {
+                set_error(PyExc_TypeError,
+                          "__init__(self, ...) called with invalid or missing `self` argument");
+                return nullptr;
+            }
+
+            auto *const tinfo = get_type_info((PyTypeObject *) overloads->scope.ptr());
+            auto *const pi = reinterpret_cast<instance *>(parent.ptr());
+            self_value_and_holder = pi->get_value_and_holder(tinfo, true);
+
+            // If this value is already registered it must mean __init__ is invoked multiple times;
+            // we really can't support that in C++, so just ignore the second __init__.
+            if (self_value_and_holder.instance_registered()) {
+                return none().release().ptr();
+            }
+        }
+
+        try {
+            // We do this in two passes: in the first pass, we load arguments with `convert=false`;
+            // in the second, we allow conversion (except for arguments with an explicit
+            // py::arg().noconvert()).  This lets us prefer calls without conversion, with
+            // conversion as a fallback.
+            std::vector<function_call> second_pass;
+
+            // However, if there are no overloads, we can just skip the no-convert pass entirely
+            const bool overloaded
+                = current_overload != nullptr && current_overload->next != nullptr;
+
+            for (; current_overload != nullptr; current_overload = current_overload->next) {
+
+                /* For each overload:
+                   1. Copy all positional arguments we were given, also checking to make sure that
+                      named positional arguments weren't *also* specified via kwarg.
+                   2. If we weren't given enough, try to make up the omitted ones by checking
+                      whether they were provided by a kwarg matching the `py::arg("name")` name. If
+                      so, use it (and remove it from kwargs); if not, see if the function binding
+                      provided a default that we can use.
+                   3. Ensure that either all keyword arguments were "consumed", or that the
+                   function takes a kwargs argument to accept unconsumed kwargs.
+                   4. Any positional arguments still left get put into a tuple (for args), and any
+                      leftover kwargs get put into a dict.
+                   5. Pack everything into a vector; if we have py::args or py::kwargs, they are an
+                      extra tuple or dict at the end of the positional arguments.
+                   6. Call the function call dispatcher (function_record::impl)
+
+                   If one of these fail, move on to the next overload and keep trying until we get
+                   a result other than PYBIND11_TRY_NEXT_OVERLOAD.
+                 */
+
+                const function_record &func = *current_overload;
+                size_t num_args = func.nargs; // Number of positional arguments that we need
+                if (func.has_args) {
+                    --num_args; // (but don't count py::args
+                }
+                if (func.has_kwargs) {
+                    --num_args; //  or py::kwargs)
+                }
+                size_t pos_args = func.nargs_pos;
+
+                if (!func.has_args && n_args_in > pos_args) {
+                    continue; // Too many positional arguments for this overload
+                }
+
+                if (n_args_in < pos_args && func.args.size() < pos_args) {
+                    continue; // Not enough positional arguments given, and not enough defaults to
+                              // fill in the blanks
+                }
+
+                function_call call(func, parent);
+
+                // Protect std::min with parentheses
+                size_t args_to_copy = (std::min) (pos_args, n_args_in);
+                size_t args_copied = 0;
+
+                // 0. Inject new-style `self` argument
+                if (func.is_new_style_constructor) {
+                    // The `value` may have been preallocated by an old-style `__init__`
+                    // if it was a preceding candidate for overload resolution.
+                    if (self_value_and_holder) {
+                        self_value_and_holder.type->dealloc(self_value_and_holder);
+                    }
+
+                    call.init_self = PyTuple_GET_ITEM(args_in, 0);
+                    call.args.emplace_back(reinterpret_cast<PyObject *>(&self_value_and_holder));
+                    call.args_convert.push_back(false);
+                    ++args_copied;
+                }
+
+                // 1. Copy any position arguments given.
+                bool bad_arg = false;
+                for (; args_copied < args_to_copy; ++args_copied) {
+                    const argument_record *arg_rec
+                        = args_copied < func.args.size() ? &func.args[args_copied] : nullptr;
+                    if (kwargs_in && arg_rec && arg_rec->name
+                        && dict_getitemstring(kwargs_in, arg_rec->name)) {
+                        bad_arg = true;
+                        break;
+                    }
+
+                    handle arg(PyTuple_GET_ITEM(args_in, args_copied));
+                    if (arg_rec && !arg_rec->none && arg.is_none()) {
+                        bad_arg = true;
+                        break;
+                    }
+                    call.args.push_back(arg);
+                    call.args_convert.push_back(arg_rec ? arg_rec->convert : true);
+                }
+                if (bad_arg) {
+                    continue; // Maybe it was meant for another overload (issue #688)
+                }
+
+                // Keep track of how many position args we copied out in case we need to come back
+                // to copy the rest into a py::args argument.
+                size_t positional_args_copied = args_copied;
+
+                // We'll need to copy this if we steal some kwargs for defaults
+                dict kwargs = reinterpret_borrow<dict>(kwargs_in);
+
+                // 1.5. Fill in any missing pos_only args from defaults if they exist
+                if (args_copied < func.nargs_pos_only) {
+                    for (; args_copied < func.nargs_pos_only; ++args_copied) {
+                        const auto &arg_rec = func.args[args_copied];
+                        handle value;
+
+                        if (arg_rec.value) {
+                            value = arg_rec.value;
+                        }
+                        if (value) {
+                            call.args.push_back(value);
+                            call.args_convert.push_back(arg_rec.convert);
+                        } else {
+                            break;
+                        }
+                    }
+
+                    if (args_copied < func.nargs_pos_only) {
+                        continue; // Not enough defaults to fill the positional arguments
+                    }
+                }
+
+                // 2. Check kwargs and, failing that, defaults that may help complete the list
+                if (args_copied < num_args) {
+                    bool copied_kwargs = false;
+
+                    for (; args_copied < num_args; ++args_copied) {
+                        const auto &arg_rec = func.args[args_copied];
+
+                        handle value;
+                        if (kwargs_in && arg_rec.name) {
+                            value = dict_getitemstring(kwargs.ptr(), arg_rec.name);
+                        }
+
+                        if (value) {
+                            // Consume a kwargs value
+                            if (!copied_kwargs) {
+                                kwargs = reinterpret_steal<dict>(PyDict_Copy(kwargs.ptr()));
+                                copied_kwargs = true;
+                            }
+                            if (PyDict_DelItemString(kwargs.ptr(), arg_rec.name) == -1) {
+                                throw error_already_set();
+                            }
+                        } else if (arg_rec.value) {
+                            value = arg_rec.value;
+                        }
+
+                        if (!arg_rec.none && value.is_none()) {
+                            break;
+                        }
+
+                        if (value) {
+                            // If we're at the py::args index then first insert a stub for it to be
+                            // replaced later
+                            if (func.has_args && call.args.size() == func.nargs_pos) {
+                                call.args.push_back(none());
+                            }
+
+                            call.args.push_back(value);
+                            call.args_convert.push_back(arg_rec.convert);
+                        } else {
+                            break;
+                        }
+                    }
+
+                    if (args_copied < num_args) {
+                        continue; // Not enough arguments, defaults, or kwargs to fill the
+                                  // positional arguments
+                    }
+                }
+
+                // 3. Check everything was consumed (unless we have a kwargs arg)
+                if (kwargs && !kwargs.empty() && !func.has_kwargs) {
+                    continue; // Unconsumed kwargs, but no py::kwargs argument to accept them
+                }
+
+                // 4a. If we have a py::args argument, create a new tuple with leftovers
+                if (func.has_args) {
+                    tuple extra_args;
+                    if (args_to_copy == 0) {
+                        // We didn't copy out any position arguments from the args_in tuple, so we
+                        // can reuse it directly without copying:
+                        extra_args = reinterpret_borrow<tuple>(args_in);
+                    } else if (positional_args_copied >= n_args_in) {
+                        extra_args = tuple(0);
+                    } else {
+                        size_t args_size = n_args_in - positional_args_copied;
+                        extra_args = tuple(args_size);
+                        for (size_t i = 0; i < args_size; ++i) {
+                            extra_args[i] = PyTuple_GET_ITEM(args_in, positional_args_copied + i);
+                        }
+                    }
+                    if (call.args.size() <= func.nargs_pos) {
+                        call.args.push_back(extra_args);
+                    } else {
+                        call.args[func.nargs_pos] = extra_args;
+                    }
+                    call.args_convert.push_back(false);
+                    call.args_ref = std::move(extra_args);
+                }
+
+                // 4b. If we have a py::kwargs, pass on any remaining kwargs
+                if (func.has_kwargs) {
+                    if (!kwargs.ptr()) {
+                        kwargs = dict(); // If we didn't get one, send an empty one
+                    }
+                    call.args.push_back(kwargs);
+                    call.args_convert.push_back(false);
+                    call.kwargs_ref = std::move(kwargs);
+                }
+
+// 5. Put everything in a vector.  Not technically step 5, we've been building it
+// in `call.args` all along.
+#if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+                if (call.args.size() != func.nargs || call.args_convert.size() != func.nargs) {
+                    pybind11_fail("Internal error: function call dispatcher inserted wrong number "
+                                  "of arguments!");
+                }
+#endif
+
+                std::vector<bool> second_pass_convert;
+                if (overloaded) {
+                    // We're in the first no-convert pass, so swap out the conversion flags for a
+                    // set of all-false flags.  If the call fails, we'll swap the flags back in for
+                    // the conversion-allowed call below.
+                    second_pass_convert.resize(func.nargs, false);
+                    call.args_convert.swap(second_pass_convert);
+                }
+
+                // 6. Call the function.
+                try {
+                    loader_life_support guard{};
+                    result = func.impl(call);
+                } catch (reference_cast_error &) {
+                    result = PYBIND11_TRY_NEXT_OVERLOAD;
+                }
+
+                if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD) {
+                    break;
+                }
+
+                if (overloaded) {
+                    // The (overloaded) call failed; if the call has at least one argument that
+                    // permits conversion (i.e. it hasn't been explicitly specified `.noconvert()`)
+                    // then add this call to the list of second pass overloads to try.
+                    for (size_t i = func.is_method ? 1 : 0; i < pos_args; i++) {
+                        if (second_pass_convert[i]) {
+                            // Found one: swap the converting flags back in and store the call for
+                            // the second pass.
+                            call.args_convert.swap(second_pass_convert);
+                            second_pass.push_back(std::move(call));
+                            break;
+                        }
+                    }
+                }
+            }
+
+            if (overloaded && !second_pass.empty() && result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) {
+                // The no-conversion pass finished without success, try again with conversion
+                // allowed
+                for (auto &call : second_pass) {
+                    try {
+                        loader_life_support guard{};
+                        result = call.func.impl(call);
+                    } catch (reference_cast_error &) {
+                        result = PYBIND11_TRY_NEXT_OVERLOAD;
+                    }
+
+                    if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD) {
+                        // The error reporting logic below expects 'current_overload' to be valid,
+                        // as it would be if we'd encountered this failure in the first-pass loop.
+                        if (!result) {
+                            current_overload = &call.func;
+                        }
+                        break;
+                    }
+                }
+            }
+        } catch (error_already_set &e) {
+            e.restore();
+            return nullptr;
+#ifdef __GLIBCXX__
+        } catch (abi::__forced_unwind &) {
+            throw;
+#endif
+        } catch (...) {
+            try_translate_exceptions();
+            return nullptr;
+        }
+
+        auto append_note_if_missing_header_is_suspected = [](std::string &msg) {
+            if (msg.find("std::") != std::string::npos) {
+                msg += "\n\n"
+                       "Did you forget to `#include <pybind11/stl.h>`? Or <pybind11/complex.h>,\n"
+                       "<pybind11/functional.h>, <pybind11/chrono.h>, etc. Some automatic\n"
+                       "conversions are optional and require extra headers to be included\n"
+                       "when compiling your pybind11 module.";
+            }
+        };
+
+        if (result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) {
+            if (overloads->is_operator) {
+                return handle(Py_NotImplemented).inc_ref().ptr();
+            }
+
+            std::string msg = std::string(overloads->name) + "(): incompatible "
+                              + std::string(overloads->is_constructor ? "constructor" : "function")
+                              + " arguments. The following argument types are supported:\n";
+
+            int ctr = 0;
+            for (const function_record *it2 = overloads; it2 != nullptr; it2 = it2->next) {
+                msg += "    " + std::to_string(++ctr) + ". ";
+
+                bool wrote_sig = false;
+                if (overloads->is_constructor) {
+                    // For a constructor, rewrite `(self: Object, arg0, ...) -> NoneType` as
+                    // `Object(arg0, ...)`
+                    std::string sig = it2->signature;
+                    size_t start = sig.find('(') + 7; // skip "(self: "
+                    if (start < sig.size()) {
+                        // End at the , for the next argument
+                        size_t end = sig.find(", "), next = end + 2;
+                        size_t ret = sig.rfind(" -> ");
+                        // Or the ), if there is no comma:
+                        if (end >= sig.size()) {
+                            next = end = sig.find(')');
+                        }
+                        if (start < end && next < sig.size()) {
+                            msg.append(sig, start, end - start);
+                            msg += '(';
+                            msg.append(sig, next, ret - next);
+                            wrote_sig = true;
+                        }
+                    }
+                }
+                if (!wrote_sig) {
+                    msg += it2->signature;
+                }
+
+                msg += '\n';
+            }
+            msg += "\nInvoked with: ";
+            auto args_ = reinterpret_borrow<tuple>(args_in);
+            bool some_args = false;
+            for (size_t ti = overloads->is_constructor ? 1 : 0; ti < args_.size(); ++ti) {
+                if (!some_args) {
+                    some_args = true;
+                } else {
+                    msg += ", ";
+                }
+                try {
+                    msg += pybind11::repr(args_[ti]);
+                } catch (const error_already_set &) {
+                    msg += "<repr raised Error>";
+                }
+            }
+            if (kwargs_in) {
+                auto kwargs = reinterpret_borrow<dict>(kwargs_in);
+                if (!kwargs.empty()) {
+                    if (some_args) {
+                        msg += "; ";
+                    }
+                    msg += "kwargs: ";
+                    bool first = true;
+                    for (const auto &kwarg : kwargs) {
+                        if (first) {
+                            first = false;
+                        } else {
+                            msg += ", ";
+                        }
+                        msg += pybind11::str("{}=").format(kwarg.first);
+                        try {
+                            msg += pybind11::repr(kwarg.second);
+                        } catch (const error_already_set &) {
+                            msg += "<repr raised Error>";
+                        }
+                    }
+                }
+            }
+
+            append_note_if_missing_header_is_suspected(msg);
+            // Attach additional error info to the exception if supported
+            if (PyErr_Occurred()) {
+                // #HelpAppreciated: unit test coverage for this branch.
+                raise_from(PyExc_TypeError, msg.c_str());
+                return nullptr;
+            }
+            set_error(PyExc_TypeError, msg.c_str());
+            return nullptr;
+        }
+        if (!result) {
+            std::string msg = "Unable to convert function return value to a "
+                              "Python type! The signature was\n\t";
+            assert(current_overload != nullptr);
+            msg += current_overload->signature;
+            append_note_if_missing_header_is_suspected(msg);
+            // Attach additional error info to the exception if supported
+            if (PyErr_Occurred()) {
+                raise_from(PyExc_TypeError, msg.c_str());
+                return nullptr;
+            }
+            set_error(PyExc_TypeError, msg.c_str());
+            return nullptr;
+        }
+        if (overloads->is_constructor && !self_value_and_holder.holder_constructed()) {
+            auto *pi = reinterpret_cast<instance *>(parent.ptr());
+            self_value_and_holder.type->init_instance(pi, nullptr);
+        }
+        return result.ptr();
+    }
+};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+PYBIND11_NAMESPACE_BEGIN(function_record_PyTypeObject_methods)
+
+// This implementation needs the definition of `class cpp_function`.
+inline void tp_dealloc_impl(PyObject *self) {
+    auto *py_func_rec = (function_record_PyObject *) self;
+    cpp_function::destruct(py_func_rec->cpp_func_rec);
+    py_func_rec->cpp_func_rec = nullptr;
+}
+
+PYBIND11_NAMESPACE_END(function_record_PyTypeObject_methods)
+
+template <>
+struct handle_type_name<cpp_function> {
+    static constexpr auto name = const_name("collections.abc.Callable");
+};
+
+PYBIND11_NAMESPACE_END(detail)
+
+// Use to activate Py_MOD_GIL_NOT_USED.
+class mod_gil_not_used {
+public:
+    explicit mod_gil_not_used(bool flag = true) : flag_(flag) {}
+    bool flag() const { return flag_; }
+
+private:
+    bool flag_;
+};
+
+class multiple_interpreters {
+public:
+    enum class level {
+        not_supported,      /// Use to activate Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED
+        shared_gil,         /// Use to activate Py_MOD_MULTIPLE_INTERPRETERS_SUPPORTED
+        per_interpreter_gil /// Use to activate Py_MOD_PER_INTERPRETER_GIL_SUPPORTED
+    };
+
+    static multiple_interpreters not_supported() {
+        return multiple_interpreters(level::not_supported);
+    }
+    static multiple_interpreters shared_gil() { return multiple_interpreters(level::shared_gil); }
+    static multiple_interpreters per_interpreter_gil() {
+        return multiple_interpreters(level::per_interpreter_gil);
+    }
+
+    explicit constexpr multiple_interpreters(level l) : level_(l) {}
+    level value() const { return level_; }
+
+private:
+    level level_;
+};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+inline bool gil_not_used_option() { return false; }
+template <typename F, typename... O>
+bool gil_not_used_option(F &&, O &&...o);
+template <typename... O>
+inline bool gil_not_used_option(mod_gil_not_used f, O &&...o) {
+    return f.flag() || gil_not_used_option(o...);
+}
+template <typename F, typename... O>
+inline bool gil_not_used_option(F &&, O &&...o) {
+    return gil_not_used_option(o...);
+}
+
+#ifdef Py_mod_multiple_interpreters
+inline void *multi_interp_slot() { return Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED; }
+template <typename... O>
+inline void *multi_interp_slot(multiple_interpreters mi, O &&...o) {
+    switch (mi.value()) {
+        case multiple_interpreters::level::per_interpreter_gil:
+            return Py_MOD_PER_INTERPRETER_GIL_SUPPORTED;
+        case multiple_interpreters::level::shared_gil:
+            return Py_MOD_MULTIPLE_INTERPRETERS_SUPPORTED;
+        case multiple_interpreters::level::not_supported:
+            return Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED;
+    }
+    // silence warnings with this unreachable line:
+    return multi_interp_slot(o...);
+}
+template <typename F, typename... O>
+inline void *multi_interp_slot(F &&, O &&...o) {
+    return multi_interp_slot(o...);
+}
+#endif
+
+/*
+Return a borrowed reference to the named module if it has been successfully initialized within this
+interpreter before. nullptr if it has not been successfully initialized.
+*/
+inline PyObject *get_cached_module(pybind11::str const &nameobj) {
+    dict state = detail::get_python_state_dict();
+    if (!state.contains("__pybind11_module_cache")) {
+        return nullptr;
+    }
+    dict cache = state["__pybind11_module_cache"];
+    if (!cache.contains(nameobj)) {
+        return nullptr;
+    }
+    return cache[nameobj].ptr();
+}
+
+/*
+Add successfully initialized a module object to the internal cache.
+
+The module must have a __spec__ attribute with a name attribute.
+*/
+inline void cache_completed_module(pybind11::object const &mod) {
+    dict state = detail::get_python_state_dict();
+    if (!state.contains("__pybind11_module_cache")) {
+        state["__pybind11_module_cache"] = dict();
+    }
+    state["__pybind11_module_cache"][mod.attr("__spec__").attr("name")] = mod;
+}
+
+/*
+A Py_mod_create slot function which will return the previously created module from the cache if one
+exists, and otherwise will create a new module object.
+*/
+inline PyObject *cached_create_module(PyObject *spec, PyModuleDef *) {
+    (void) &cache_completed_module; // silence unused-function warnings, it is used in a macro
+
+    auto nameobj = getattr(reinterpret_borrow<object>(spec), "name", none());
+    if (nameobj.is_none()) {
+        set_error(PyExc_ImportError, "module spec is missing a name");
+        return nullptr;
+    }
+
+    auto *mod = get_cached_module(nameobj);
+    if (mod) {
+        Py_INCREF(mod);
+    } else {
+        mod = PyModule_NewObject(nameobj.ptr());
+    }
+    return mod;
+}
+
+/// Must be a POD type, and must hold enough entries for all of the possible slots PLUS ONE for
+/// the sentinel (0) end slot.
+using slots_array = std::array<PyModuleDef_Slot, 5>;
+
+/// Initialize an array of slots based on the supplied exec slot and options.
+template <typename... Options>
+inline slots_array init_slots(int (*exec_fn)(PyObject *), Options &&...options) noexcept {
+    /* NOTE: slots_array MUST be large enough to hold all possible options.  If you add an option
+    here, you MUST also increase the size of slots_array in the type alias above! */
+    slots_array mod_def_slots;
+    size_t next_slot = 0;
+
+    mod_def_slots[next_slot++] = {Py_mod_create, reinterpret_cast<void *>(&cached_create_module)};
+
+    if (exec_fn != nullptr) {
+        mod_def_slots[next_slot++] = {Py_mod_exec, reinterpret_cast<void *>(exec_fn)};
+    }
+
+#ifdef Py_mod_multiple_interpreters
+    mod_def_slots[next_slot++] = {Py_mod_multiple_interpreters, multi_interp_slot(options...)};
+#endif
+
+    if (gil_not_used_option(options...)) {
+#if defined(Py_mod_gil) && defined(Py_GIL_DISABLED)
+        mod_def_slots[next_slot++] = {Py_mod_gil, Py_MOD_GIL_NOT_USED};
+#endif
+    }
+
+    // slots must have a zero end sentinel
+    mod_def_slots[next_slot++] = {0, nullptr};
+
+    return mod_def_slots;
+}
+
+PYBIND11_NAMESPACE_END(detail)
+
+/// Wrapper for Python extension modules
+class module_ : public object {
+public:
+    PYBIND11_OBJECT_DEFAULT(module_, object, PyModule_Check)
+
+    /// Create a new top-level Python module with the given name and docstring
+    PYBIND11_DEPRECATED("Use PYBIND11_MODULE or module_::create_extension_module instead")
+    explicit module_(const char *name, const char *doc = nullptr) {
+        *this = create_extension_module(name, doc, new PyModuleDef());
+    }
+
+    /** \rst
+        Create Python binding for a new function within the module scope. ``Func``
+        can be a plain C++ function, a function pointer, or a lambda function. For
+        details on the ``Extra&& ... extra`` argument, see section :ref:`extras`.
+    \endrst */
+    template <typename Func, typename... Extra>
+    module_ &def(const char *name_, Func &&f, const Extra &...extra) {
+        cpp_function func(std::forward<Func>(f),
+                          name(name_),
+                          scope(*this),
+                          sibling(getattr(*this, name_, none())),
+                          extra...);
+        // NB: allow overwriting here because cpp_function sets up a chain with the intention of
+        // overwriting (and has already checked internally that it isn't overwriting
+        // non-functions).
+        add_object(name_, func, true /* overwrite */);
+        return *this;
+    }
+
+    /** \rst
+        Create and return a new Python submodule with the given name and docstring.
+        This also works recursively, i.e.
+
+        .. code-block:: cpp
+
+            py::module_ m("example", "pybind11 example plugin");
+            py::module_ m2 = m.def_submodule("sub", "A submodule of 'example'");
+            py::module_ m3 = m2.def_submodule("subsub", "A submodule of 'example.sub'");
+    \endrst */
+    module_ def_submodule(const char *name, const char *doc = nullptr) {
+        const char *this_name = PyModule_GetName(m_ptr);
+        if (this_name == nullptr) {
+            throw error_already_set();
+        }
+        std::string full_name = std::string(this_name) + '.' + name;
+        handle submodule = PyImport_AddModule(full_name.c_str());
+        if (!submodule) {
+            throw error_already_set();
+        }
+        auto result = reinterpret_borrow<module_>(submodule);
+        if (doc && options::show_user_defined_docstrings()) {
+            result.attr("__doc__") = pybind11::str(doc);
+        }
+
+#if defined(GRAALVM_PYTHON) && (!defined(GRAALPY_VERSION_NUM) || GRAALPY_VERSION_NUM < 0x190000)
+        // GraalPy doesn't support PyModule_GetFilenameObject,
+        // so getting by attribute (see PR #5584)
+        handle this_module = m_ptr;
+        if (object this_file = getattr(this_module, "__file__", none())) {
+            result.attr("__file__") = this_file;
+        }
+#else
+        handle this_file = PyModule_GetFilenameObject(m_ptr);
+        if (this_file) {
+            result.attr("__file__") = this_file;
+        } else if (PyErr_ExceptionMatches(PyExc_SystemError) != 0) {
+            PyErr_Clear();
+        } else {
+            throw error_already_set();
+        }
+#endif
+        attr(name) = result;
+        return result;
+    }
+
+    /// Import and return a module or throws `error_already_set`.
+    static module_ import(const char *name) {
+        PyObject *obj = PyImport_ImportModule(name);
+        if (!obj) {
+            throw error_already_set();
+        }
+        return reinterpret_steal<module_>(obj);
+    }
+
+    /// Reload the module or throws `error_already_set`.
+    void reload() {
+        PyObject *obj = PyImport_ReloadModule(ptr());
+        if (!obj) {
+            throw error_already_set();
+        }
+        *this = reinterpret_steal<module_>(obj);
+    }
+
+    /** \rst
+        Adds an object to the module using the given name.  Throws if an object with the given name
+        already exists.
+
+        ``overwrite`` should almost always be false: attempting to overwrite objects that pybind11
+        has established will, in most cases, break things.
+    \endrst */
+    PYBIND11_NOINLINE void add_object(const char *name, handle obj, bool overwrite = false) {
+        if (!overwrite && hasattr(*this, name)) {
+            pybind11_fail(
+                "Error during initialization: multiple incompatible definitions with name \""
+                + std::string(name) + "\"");
+        }
+
+        PyModule_AddObject(ptr(), name, obj.inc_ref().ptr() /* steals a reference */);
+    }
+
+    // DEPRECATED (since PR #5688): Use PyModuleDef directly instead.
+    using module_def = PyModuleDef;
+
+    /** \rst
+        Create a new top-level module that can be used as the main module of a C extension.
+
+        ``def`` should point to a statically allocated PyModuleDef.
+    \endrst */
+    static module_ create_extension_module(const char *name,
+                                           const char *doc,
+                                           PyModuleDef *def,
+                                           mod_gil_not_used gil_not_used
+                                           = mod_gil_not_used(false)) {
+        // Placement new (not an allocation).
+        new (def) PyModuleDef{/* m_base */ PyModuleDef_HEAD_INIT,
+                              /* m_name */ name,
+                              /* m_doc */ options::show_user_defined_docstrings() ? doc : nullptr,
+                              /* m_size */ -1,
+                              /* m_methods */ nullptr,
+                              /* m_slots */ nullptr,
+                              /* m_traverse */ nullptr,
+                              /* m_clear */ nullptr,
+                              /* m_free */ nullptr};
+        auto *m = PyModule_Create(def);
+        if (m == nullptr) {
+            if (PyErr_Occurred()) {
+                throw error_already_set();
+            }
+            pybind11_fail("Internal error in module_::create_extension_module()");
+        }
+        if (gil_not_used.flag()) {
+#ifdef Py_GIL_DISABLED
+            PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+#endif
+        }
+        // TODO: Should be reinterpret_steal for Python 3, but Python also steals it again when
+        //       returned from PyInit_...
+        //       For Python 2, reinterpret_borrow was correct.
+        return reinterpret_borrow<module_>(m);
+    }
+};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+template <>
+struct handle_type_name<module_> {
+    static constexpr auto name = const_name("types.ModuleType");
+};
+
+PYBIND11_NAMESPACE_END(detail)
+
+// When inside a namespace (or anywhere as long as it's not the first item on a line),
+// C++20 allows "module" to be used. This is provided for backward compatibility, and for
+// simplicity, if someone wants to use py::module for example, that is perfectly safe.
+using module = module_;
+
+/// \ingroup python_builtins
+/// Return a dictionary representing the global variables in the current execution frame,
+/// or ``__main__.__dict__`` if there is no frame (usually when the interpreter is embedded).
+inline dict globals() {
+#if PY_VERSION_HEX >= 0x030d0000
+    PyObject *p = PyEval_GetFrameGlobals();
+    return p ? reinterpret_steal<dict>(p)
+             : reinterpret_borrow<dict>(module_::import("__main__").attr("__dict__").ptr());
+#else
+    PyObject *p = PyEval_GetGlobals();
+    return reinterpret_borrow<dict>(p ? p : module_::import("__main__").attr("__dict__").ptr());
+#endif
+}
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+/// Generic support for creating new Python heap types
+class generic_type : public object {
+public:
+    PYBIND11_OBJECT_DEFAULT(generic_type, object, PyType_Check)
+protected:
+    void initialize(const type_record &rec) {
+        if (rec.scope && hasattr(rec.scope, "__dict__")
+            && rec.scope.attr("__dict__").contains(rec.name)) {
+            pybind11_fail("generic_type: cannot initialize type \"" + std::string(rec.name)
+                          + "\": an object with that name is already defined");
+        }
+
+        if ((rec.module_local ? get_local_type_info(*rec.type) : get_global_type_info(*rec.type))
+            != nullptr) {
+            pybind11_fail("generic_type: type \"" + std::string(rec.name)
+                          + "\" is already registered!");
+        }
+
+        m_ptr = make_new_python_type(rec);
+
+        /* Register supplemental type information in C++ dict */
+        auto *tinfo = new detail::type_info();
+        tinfo->type = (PyTypeObject *) m_ptr;
+        tinfo->cpptype = rec.type;
+        tinfo->type_size = rec.type_size;
+        tinfo->type_align = rec.type_align;
+        tinfo->operator_new = rec.operator_new;
+        tinfo->holder_size_in_ptrs = size_in_ptrs(rec.holder_size);
+        tinfo->init_instance = rec.init_instance;
+        tinfo->dealloc = rec.dealloc;
+        tinfo->get_trampoline_self_life_support = rec.get_trampoline_self_life_support;
+        tinfo->simple_type = true;
+        tinfo->simple_ancestors = true;
+        tinfo->module_local = rec.module_local;
+        tinfo->holder_enum_v = rec.holder_enum_v;
+
+        with_internals([&](internals &internals) {
+            auto tindex = std::type_index(*rec.type);
+            tinfo->direct_conversions = &internals.direct_conversions[tindex];
+            if (rec.module_local) {
+                get_local_internals().registered_types_cpp[tindex] = tinfo;
+            } else {
+                internals.registered_types_cpp[tindex] = tinfo;
+            }
+
+            PYBIND11_WARNING_PUSH
+#if defined(__GNUC__) && __GNUC__ == 12
+            // When using GCC 12 these warnings are disabled as they trigger
+            // false positive warnings.  Discussed here:
+            // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115824.
+            PYBIND11_WARNING_DISABLE_GCC("-Warray-bounds")
+            PYBIND11_WARNING_DISABLE_GCC("-Wstringop-overread")
+#endif
+            internals.registered_types_py[(PyTypeObject *) m_ptr] = {tinfo};
+            PYBIND11_WARNING_POP
+        });
+
+        if (rec.bases.size() > 1 || rec.multiple_inheritance) {
+            mark_parents_nonsimple(tinfo->type);
+            tinfo->simple_ancestors = false;
+        } else if (rec.bases.size() == 1) {
+            auto *parent_tinfo = get_type_info((PyTypeObject *) rec.bases[0].ptr());
+            assert(parent_tinfo != nullptr);
+            bool parent_simple_ancestors = parent_tinfo->simple_ancestors;
+            tinfo->simple_ancestors = parent_simple_ancestors;
+            // The parent can no longer be a simple type if it has MI and has a child
+            parent_tinfo->simple_type = parent_tinfo->simple_type && parent_simple_ancestors;
+        }
+
+        if (rec.module_local) {
+            // Stash the local typeinfo and loader so that external modules can access it.
+            tinfo->module_local_load = &type_caster_generic::local_load;
+            setattr(m_ptr, PYBIND11_MODULE_LOCAL_ID, capsule(tinfo));
+        }
+    }
+
+    /// Helper function which tags all parents of a type using mult. inheritance
+    void mark_parents_nonsimple(PyTypeObject *value) {
+        auto t = reinterpret_borrow<tuple>(value->tp_bases);
+        for (handle h : t) {
+            auto *tinfo2 = get_type_info((PyTypeObject *) h.ptr());
+            if (tinfo2) {
+                tinfo2->simple_type = false;
+            }
+            mark_parents_nonsimple((PyTypeObject *) h.ptr());
+        }
+    }
+
+    void install_buffer_funcs(buffer_info *(*get_buffer)(PyObject *, void *),
+                              void *get_buffer_data) {
+        auto *type = (PyHeapTypeObject *) m_ptr;
+        auto *tinfo = detail::get_type_info(&type->ht_type);
+
+        if (!type->ht_type.tp_as_buffer) {
+            pybind11_fail("To be able to register buffer protocol support for the type '"
+                          + get_fully_qualified_tp_name(tinfo->type)
+                          + "' the associated class<>(..) invocation must "
+                            "include the pybind11::buffer_protocol() annotation!");
+        }
+
+        tinfo->get_buffer = get_buffer;
+        tinfo->get_buffer_data = get_buffer_data;
+    }
+
+    // rec_func must be set for either fget or fset.
+    void def_property_static_impl(const char *name,
+                                  handle fget,
+                                  handle fset,
+                                  detail::function_record *rec_func) {
+        const auto is_static = (rec_func != nullptr) && !(rec_func->is_method && rec_func->scope);
+        const auto has_doc = (rec_func != nullptr) && (rec_func->doc != nullptr)
+                             && pybind11::options::show_user_defined_docstrings();
+        auto property = handle(
+            (PyObject *) (is_static ? get_internals().static_property_type : &PyProperty_Type));
+        attr(name) = property(fget.ptr() ? fget : none(),
+                              fset.ptr() ? fset : none(),
+                              /*deleter*/ none(),
+                              pybind11::str(has_doc ? rec_func->doc : ""));
+    }
+};
+
+/// Set the pointer to operator new if it exists. The cast is needed because it can be overloaded.
+template <typename T,
+          typename = void_t<decltype(static_cast<void *(*) (size_t)>(T::operator new))>>
+void set_operator_new(type_record *r) {
+    r->operator_new = &T::operator new;
+}
+
+template <typename>
+void set_operator_new(...) {}
+
+template <typename T, typename SFINAE = void>
+struct has_operator_delete : std::false_type {};
+template <typename T>
+struct has_operator_delete<T, void_t<decltype(static_cast<void (*)(void *)>(T::operator delete))>>
+    : std::true_type {};
+template <typename T, typename SFINAE = void>
+struct has_operator_delete_size : std::false_type {};
+template <typename T>
+struct has_operator_delete_size<
+    T,
+    void_t<decltype(static_cast<void (*)(void *, size_t)>(T::operator delete))>> : std::true_type {
+};
+/// Call class-specific delete if it exists or global otherwise. Can also be an overload set.
+template <typename T, enable_if_t<has_operator_delete<T>::value, int> = 0>
+void call_operator_delete(T *p, size_t, size_t) {
+    T::operator delete(p);
+}
+template <typename T,
+          enable_if_t<!has_operator_delete<T>::value && has_operator_delete_size<T>::value, int>
+          = 0>
+void call_operator_delete(T *p, size_t s, size_t) {
+    T::operator delete(p, s);
+}
+
+inline void call_operator_delete(void *p, size_t s, size_t a) {
+    (void) s;
+    (void) a;
+#if defined(__cpp_aligned_new) && (!defined(_MSC_VER) || _MSC_VER >= 1912)
+    if (a > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+#    ifdef __cpp_sized_deallocation
+        ::operator delete(p, s, std::align_val_t(a));
+#    else
+        ::operator delete(p, std::align_val_t(a));
+#    endif
+        return;
+    }
+#endif
+#ifdef __cpp_sized_deallocation
+    ::operator delete(p, s);
+#else
+    ::operator delete(p);
+#endif
+}
+
+inline void add_class_method(object &cls, const char *name_, const cpp_function &cf) {
+    cls.attr(cf.name()) = cf;
+    if (std::strcmp(name_, "__eq__") == 0 && !cls.attr("__dict__").contains("__hash__")) {
+        cls.attr("__hash__") = none();
+    }
+}
+
+PYBIND11_NAMESPACE_END(detail)
+
+/// Given a pointer to a member function, cast it to its `Derived` version.
+/// Forward everything else unchanged.
+template <typename /*Derived*/, typename F>
+auto method_adaptor(F &&f) -> decltype(std::forward<F>(f)) {
+    return std::forward<F>(f);
+}
+
+template <typename Derived, typename Return, typename Class, typename... Args>
+auto method_adaptor(Return (Class::*pmf)(Args...)) -> Return (Derived::*)(Args...) {
+    static_assert(
+        detail::is_accessible_base_of<Class, Derived>::value,
+        "Cannot bind an inaccessible base class method; use a lambda definition instead");
+    return pmf;
+}
+
+template <typename Derived, typename Return, typename Class, typename... Args>
+auto method_adaptor(Return (Class::*pmf)(Args...) const) -> Return (Derived::*)(Args...) const {
+    static_assert(
+        detail::is_accessible_base_of<Class, Derived>::value,
+        "Cannot bind an inaccessible base class method; use a lambda definition instead");
+    return pmf;
+}
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+// Helper for the property_cpp_function static member functions below.
+// The only purpose of these functions is to support .def_readonly & .def_readwrite.
+// In this context, the PM template parameter is certain to be a Pointer to a Member.
+// The main purpose of must_be_member_function_pointer is to make this obvious, and to guard
+// against accidents. As a side-effect, it also explains why the syntactical overhead for
+// perfect forwarding is not needed.
+template <typename PM>
+using must_be_member_function_pointer = enable_if_t<std::is_member_pointer<PM>::value, int>;
+
+// Note that property_cpp_function is intentionally in the main pybind11 namespace,
+// because user-defined specializations could be useful.
+
+// Classic (non-smart_holder) implementations for .def_readonly and .def_readwrite
+// getter and setter functions.
+// WARNING: This classic implementation can lead to dangling pointers for raw pointer members.
+// See test_ptr() in tests/test_class_sh_property.py
+// However, this implementation works as-is (and safely) for smart_holder std::shared_ptr members.
+template <typename T, typename D>
+struct property_cpp_function_classic {
+    template <typename PM, must_be_member_function_pointer<PM> = 0>
+    static cpp_function readonly(PM pm, const handle &hdl) {
+        return cpp_function([pm](const T &c) -> const D & { return c.*pm; }, is_method(hdl));
+    }
+
+    template <typename PM, must_be_member_function_pointer<PM> = 0>
+    static cpp_function read(PM pm, const handle &hdl) {
+        return readonly(pm, hdl);
+    }
+
+    template <typename PM, must_be_member_function_pointer<PM> = 0>
+    static cpp_function write(PM pm, const handle &hdl) {
+        return cpp_function([pm](T &c, const D &value) { c.*pm = value; }, is_method(hdl));
+    }
+};
+
+PYBIND11_NAMESPACE_END(detail)
+
+template <typename T, typename D, typename SFINAE = void>
+struct property_cpp_function : detail::property_cpp_function_classic<T, D> {};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+template <typename T, typename D, typename SFINAE = void>
+struct both_t_and_d_use_type_caster_base : std::false_type {};
+
+// `T` is assumed to be equivalent to `intrinsic_t<T>`.
+// `D` is may or may not be equivalent to `intrinsic_t<D>`.
+template <typename T, typename D>
+struct both_t_and_d_use_type_caster_base<
+    T,
+    D,
+    enable_if_t<all_of<std::is_base_of<type_caster_base<T>, type_caster<T>>,
+                       std::is_base_of<type_caster_base<intrinsic_t<D>>, make_caster<D>>>::value>>
+    : std::true_type {};
+
+// Specialization for raw pointer members, using smart_holder if that is the class_ holder,
+// or falling back to the classic implementation if not.
+// WARNING: Like the classic implementation, this implementation can lead to dangling pointers.
+// See test_ptr() in tests/test_class_sh_property.py
+// However, the read functions return a shared_ptr to the member, emulating the PyCLIF approach:
+// https://github.com/google/clif/blob/c371a6d4b28d25d53a16e6d2a6d97305fb1be25a/clif/python/instance.h#L233
+// This prevents disowning of the Python object owning the raw pointer member.
+template <typename T, typename D>
+struct property_cpp_function_sh_raw_ptr_member {
+    using drp = typename std::remove_pointer<D>::type;
+
+    template <typename PM, must_be_member_function_pointer<PM> = 0>
+    static cpp_function readonly(PM pm, const handle &hdl) {
+        type_info *tinfo = get_type_info(typeid(T), /*throw_if_missing=*/true);
+        if (tinfo->holder_enum_v == holder_enum_t::smart_holder) {
+            return cpp_function(
+                [pm](handle c_hdl) -> std::shared_ptr<drp> {
+                    std::shared_ptr<T> c_sp
+                        = type_caster<std::shared_ptr<T>>::shared_ptr_with_responsible_parent(
+                            c_hdl);
+                    D ptr = (*c_sp).*pm;
+                    return std::shared_ptr<drp>(c_sp, ptr);
+                },
+                is_method(hdl));
+        }
+        return property_cpp_function_classic<T, D>::readonly(pm, hdl);
+    }
+
+    template <typename PM, must_be_member_function_pointer<PM> = 0>
+    static cpp_function read(PM pm, const handle &hdl) {
+        return readonly(pm, hdl);
+    }
+
+    template <typename PM, must_be_member_function_pointer<PM> = 0>
+    static cpp_function write(PM pm, const handle &hdl) {
+        type_info *tinfo = get_type_info(typeid(T), /*throw_if_missing=*/true);
+        if (tinfo->holder_enum_v == holder_enum_t::smart_holder) {
+            return cpp_function([pm](T &c, D value) { c.*pm = std::forward<D>(std::move(value)); },
+                                is_method(hdl));
+        }
+        return property_cpp_function_classic<T, D>::write(pm, hdl);
+    }
+};
+
+// Specialization for members held by-value, using smart_holder if that is the class_ holder,
+// or falling back to the classic implementation if not.
+// The read functions return a shared_ptr to the member, emulating the PyCLIF approach:
+// https://github.com/google/clif/blob/c371a6d4b28d25d53a16e6d2a6d97305fb1be25a/clif/python/instance.h#L233
+// This prevents disowning of the Python object owning the member.
+template <typename T, typename D>
+struct property_cpp_function_sh_member_held_by_value {
+    template <typename PM, must_be_member_function_pointer<PM> = 0>
+    static cpp_function readonly(PM pm, const handle &hdl) {
+        type_info *tinfo = get_type_info(typeid(T), /*throw_if_missing=*/true);
+        if (tinfo->holder_enum_v == holder_enum_t::smart_holder) {
+            return cpp_function(
+                [pm](handle c_hdl) -> std::shared_ptr<typename std::add_const<D>::type> {
+                    std::shared_ptr<T> c_sp
+                        = type_caster<std::shared_ptr<T>>::shared_ptr_with_responsible_parent(
+                            c_hdl);
+                    return std::shared_ptr<typename std::add_const<D>::type>(c_sp,
+                                                                             &(c_sp.get()->*pm));
+                },
+                is_method(hdl));
+        }
+        return property_cpp_function_classic<T, D>::readonly(pm, hdl);
+    }
+
+    template <typename PM, must_be_member_function_pointer<PM> = 0>
+    static cpp_function read(PM pm, const handle &hdl) {
+        type_info *tinfo = get_type_info(typeid(T), /*throw_if_missing=*/true);
+        if (tinfo->holder_enum_v == holder_enum_t::smart_holder) {
+            return cpp_function(
+                [pm](handle c_hdl) -> std::shared_ptr<D> {
+                    std::shared_ptr<T> c_sp
+                        = type_caster<std::shared_ptr<T>>::shared_ptr_with_responsible_parent(
+                            c_hdl);
+                    return std::shared_ptr<D>(c_sp, &(c_sp.get()->*pm));
+                },
+                is_method(hdl));
+        }
+        return property_cpp_function_classic<T, D>::read(pm, hdl);
+    }
+
+    template <typename PM, must_be_member_function_pointer<PM> = 0>
+    static cpp_function write(PM pm, const handle &hdl) {
+        type_info *tinfo = get_type_info(typeid(T), /*throw_if_missing=*/true);
+        if (tinfo->holder_enum_v == holder_enum_t::smart_holder) {
+            return cpp_function([pm](T &c, const D &value) { c.*pm = value; }, is_method(hdl));
+        }
+        return property_cpp_function_classic<T, D>::write(pm, hdl);
+    }
+};
+
+// Specialization for std::unique_ptr members, using smart_holder if that is the class_ holder,
+// or falling back to the classic implementation if not.
+// read disowns the member unique_ptr.
+// write disowns the passed Python object.
+// readonly is disabled (static_assert) because there is no safe & intuitive way to make the member
+// accessible as a Python object without disowning the member unique_ptr. A .def_readonly disowning
+// the unique_ptr member is deemed highly prone to misunderstandings.
+template <typename T, typename D>
+struct property_cpp_function_sh_unique_ptr_member {
+    template <typename PM, must_be_member_function_pointer<PM> = 0>
+    static cpp_function readonly(PM, const handle &) {
+        static_assert(!is_instantiation<std::unique_ptr, D>::value,
+                      "def_readonly cannot be used for std::unique_ptr members.");
+        return cpp_function{}; // Unreachable.
+    }
+
+    template <typename PM, must_be_member_function_pointer<PM> = 0>
+    static cpp_function read(PM pm, const handle &hdl) {
+        type_info *tinfo = get_type_info(typeid(T), /*throw_if_missing=*/true);
+        if (tinfo->holder_enum_v == holder_enum_t::smart_holder) {
+            return cpp_function(
+                [pm](handle c_hdl) -> D {
+                    std::shared_ptr<T> c_sp
+                        = type_caster<std::shared_ptr<T>>::shared_ptr_with_responsible_parent(
+                            c_hdl);
+                    return D{std::move(c_sp.get()->*pm)};
+                },
+                is_method(hdl));
+        }
+        return property_cpp_function_classic<T, D>::read(pm, hdl);
+    }
+
+    template <typename PM, must_be_member_function_pointer<PM> = 0>
+    static cpp_function write(PM pm, const handle &hdl) {
+        return cpp_function([pm](T &c, D &&value) { c.*pm = std::move(value); }, is_method(hdl));
+    }
+};
+
+PYBIND11_NAMESPACE_END(detail)
+
+template <typename T, typename D>
+struct property_cpp_function<
+    T,
+    D,
+    detail::enable_if_t<detail::all_of<std::is_pointer<D>,
+                                       detail::both_t_and_d_use_type_caster_base<T, D>>::value>>
+    : detail::property_cpp_function_sh_raw_ptr_member<T, D> {};
+
+template <typename T, typename D>
+struct property_cpp_function<T,
+                             D,
+                             detail::enable_if_t<detail::all_of<
+                                 detail::none_of<std::is_pointer<D>,
+                                                 std::is_array<D>,
+                                                 detail::is_instantiation<std::unique_ptr, D>,
+                                                 detail::is_instantiation<std::shared_ptr, D>>,
+                                 detail::both_t_and_d_use_type_caster_base<T, D>>::value>>
+    : detail::property_cpp_function_sh_member_held_by_value<T, D> {};
+
+template <typename T, typename D>
+struct property_cpp_function<
+    T,
+    D,
+    detail::enable_if_t<detail::all_of<
+        detail::is_instantiation<std::unique_ptr, D>,
+        detail::both_t_and_d_use_type_caster_base<T, typename D::element_type>>::value>>
+    : detail::property_cpp_function_sh_unique_ptr_member<T, D> {};
+
+#ifdef PYBIND11_RUN_TESTING_WITH_SMART_HOLDER_AS_DEFAULT_BUT_NEVER_USE_IN_PRODUCTION_PLEASE
+// NOTE: THIS IS MEANT FOR STRESS-TESTING OR TRIAGING ONLY!
+//       Running the pybind11 unit tests with smart_holder as the default holder is to ensure
+//       that `py::smart_holder` / `py::classh` is backward-compatible with all pre-existing
+//       functionality.
+//       Be careful not to link translation units compiled with different default holders, because
+//       this will cause ODR violations (https://en.wikipedia.org/wiki/One_Definition_Rule).
+template <typename>
+using default_holder_type = smart_holder;
+#else
+template <typename T>
+using default_holder_type = std::unique_ptr<T>;
+#endif
+
+template <typename type_, typename... options>
+class class_ : public detail::generic_type {
+    template <typename T>
+    using is_holder = detail::is_holder_type<type_, T>;
+    template <typename T>
+    using is_subtype = detail::is_strict_base_of<type_, T>;
+    template <typename T>
+    using is_base = detail::is_strict_base_of<T, type_>;
+    // struct instead of using here to help MSVC:
+    template <typename T>
+    struct is_valid_class_option : detail::any_of<is_holder<T>, is_subtype<T>, is_base<T>> {};
+
+public:
+    using type = type_;
+    using type_alias = detail::exactly_one_t<is_subtype, void, options...>;
+    constexpr static bool has_alias = !std::is_void<type_alias>::value;
+    using holder_type = detail::exactly_one_t<is_holder, default_holder_type<type>, options...>;
+
+    static_assert(detail::all_of<is_valid_class_option<options>...>::value,
+                  "Unknown/invalid class_ template parameters provided");
+
+    static_assert(!has_alias || std::is_polymorphic<type>::value,
+                  "Cannot use an alias class (aka trampoline) with a non-polymorphic type");
+
+#ifndef PYBIND11_RUN_TESTING_WITH_SMART_HOLDER_AS_DEFAULT_BUT_NEVER_USE_IN_PRODUCTION_PLEASE
+    static_assert(!has_alias || !detail::is_smart_holder<holder_type>::value
+                      || std::is_base_of<trampoline_self_life_support, type_alias>::value,
+                  "Alias class (aka trampoline) must inherit from"
+                  " pybind11::trampoline_self_life_support if used in combination with"
+                  " pybind11::smart_holder");
+#endif
+    static_assert(!has_alias || detail::is_smart_holder<holder_type>::value
+                      || !std::is_base_of<trampoline_self_life_support, type_alias>::value,
+                  "pybind11::trampoline_self_life_support is a smart_holder feature, therefore"
+                  " an alias class (aka trampoline) should inherit from"
+                  " pybind11::trampoline_self_life_support only if used in combination with"
+                  " pybind11::smart_holder");
+
+    PYBIND11_OBJECT(class_, generic_type, PyType_Check)
+
+    template <typename... Extra>
+    class_(handle scope, const char *name, const Extra &...extra) {
+        using namespace detail;
+
+        // MI can only be specified via class_ template options, not constructor parameters
+        static_assert(
+            none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
+                (constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base
+                 constexpr_sum(is_base<options>::value...) == 0 &&   // no template option bases
+                 // no multiple_inheritance attr
+                 none_of<std::is_same<multiple_inheritance, Extra>...>::value),
+            "Error: multiple inheritance bases must be specified via class_ template options");
+
+        type_record record;
+        record.scope = scope;
+        record.name = name;
+        record.type = &typeid(type);
+        record.type_size = sizeof(conditional_t<has_alias, type_alias, type>);
+        record.type_align = alignof(conditional_t<has_alias, type_alias, type> &);
+        record.holder_size = sizeof(holder_type);
+        record.init_instance = init_instance;
+
+        if (detail::is_instantiation<std::unique_ptr, holder_type>::value) {
+            record.holder_enum_v = detail::holder_enum_t::std_unique_ptr;
+        } else if (detail::is_instantiation<std::shared_ptr, holder_type>::value) {
+            record.holder_enum_v = detail::holder_enum_t::std_shared_ptr;
+        } else if (std::is_same<holder_type, smart_holder>::value) {
+            record.holder_enum_v = detail::holder_enum_t::smart_holder;
+        } else {
+            record.holder_enum_v = detail::holder_enum_t::custom_holder;
+        }
+
+        set_operator_new<type>(&record);
+
+        /* Register base classes specified via template arguments to class_, if any */
+        PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record));
+
+        /* Process optional arguments, if any */
+        process_attributes<Extra...>::init(extra..., &record);
+
+        if (record.release_gil_before_calling_cpp_dtor) {
+            record.dealloc = dealloc_release_gil_before_calling_cpp_dtor;
+        } else {
+            record.dealloc = dealloc_without_manipulating_gil;
+        }
+
+        if (std::is_base_of<trampoline_self_life_support, type_alias>::value) {
+            // Store a cross-DSO-safe getter.
+            // This lambda is defined in the same DSO that instantiates
+            // class_<type, alias_type>, but it can be called safely from any other DSO.
+            record.get_trampoline_self_life_support = [](void *type_ptr) {
+                return dynamic_raw_ptr_cast_if_possible<trampoline_self_life_support>(
+                    static_cast<type *>(type_ptr));
+            };
+        }
+
+        generic_type::initialize(record);
+
+        if (has_alias) {
+            with_internals([&](internals &internals) {
+                auto &instances = record.module_local ? get_local_internals().registered_types_cpp
+                                                      : internals.registered_types_cpp;
+                instances[std::type_index(typeid(type_alias))]
+                    = instances[std::type_index(typeid(type))];
+            });
+        }
+        def("_pybind11_conduit_v1_", cpp_conduit_method);
+    }
+
+    template <typename Base, detail::enable_if_t<is_base<Base>::value, int> = 0>
+    static void add_base(detail::type_record &rec) {
+        rec.add_base(typeid(Base), [](void *src) -> void * {
+            return static_cast<Base *>(reinterpret_cast<type *>(src));
+        });
+    }
+
+    template <typename Base, detail::enable_if_t<!is_base<Base>::value, int> = 0>
+    static void add_base(detail::type_record &) {}
+
+    template <typename Func, typename... Extra>
+    class_ &def(const char *name_, Func &&f, const Extra &...extra) {
+        cpp_function cf(method_adaptor<type>(std::forward<Func>(f)),
+                        name(name_),
+                        is_method(*this),
+                        sibling(getattr(*this, name_, none())),
+                        extra...);
+        add_class_method(*this, name_, cf);
+        return *this;
+    }
+
+    template <typename Func, typename... Extra>
+    class_ &def_static(const char *name_, Func &&f, const Extra &...extra) {
+        static_assert(!std::is_member_function_pointer<Func>::value,
+                      "def_static(...) called with a non-static member function pointer");
+        cpp_function cf(std::forward<Func>(f),
+                        name(name_),
+                        scope(*this),
+                        sibling(getattr(*this, name_, none())),
+                        extra...);
+        auto cf_name = cf.name();
+        attr(std::move(cf_name)) = staticmethod(std::move(cf));
+        return *this;
+    }
+
+    template <typename T, typename... Extra, detail::enable_if_t<T::op_enable_if_hook, int> = 0>
+    class_ &def(const T &op, const Extra &...extra) {
+        op.execute(*this, extra...);
+        return *this;
+    }
+
+    template <typename T, typename... Extra, detail::enable_if_t<T::op_enable_if_hook, int> = 0>
+    class_ &def_cast(const T &op, const Extra &...extra) {
+        op.execute_cast(*this, extra...);
+        return *this;
+    }
+
+    template <typename... Args, typename... Extra>
+    class_ &def(const detail::initimpl::constructor<Args...> &init, const Extra &...extra) {
+        PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(init);
+        init.execute(*this, extra...);
+        return *this;
+    }
+
+    template <typename... Args, typename... Extra>
+    class_ &def(const detail::initimpl::alias_constructor<Args...> &init, const Extra &...extra) {
+        PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(init);
+        init.execute(*this, extra...);
+        return *this;
+    }
+
+    template <typename... Args, typename... Extra>
+    class_ &def(detail::initimpl::factory<Args...> &&init, const Extra &...extra) {
+        std::move(init).execute(*this, extra...);
+        return *this;
+    }
+
+    template <typename... Args, typename... Extra>
+    class_ &def(detail::initimpl::pickle_factory<Args...> &&pf, const Extra &...extra) {
+        std::move(pf).execute(*this, extra...);
+        return *this;
+    }
+
+    template <typename Func>
+    class_ &def_buffer(Func &&func) {
+        struct capture {
+            Func func;
+        };
+        auto *ptr = new capture{std::forward<Func>(func)};
+        install_buffer_funcs(
+            [](PyObject *obj, void *ptr) -> buffer_info * {
+                detail::make_caster<type> caster;
+                if (!caster.load(obj, false)) {
+                    return nullptr;
+                }
+                return new buffer_info(((capture *) ptr)->func(std::move(caster)));
+            },
+            ptr);
+        weakref(m_ptr, cpp_function([ptr](handle wr) {
+                    delete ptr;
+                    wr.dec_ref();
+                }))
+            .release();
+        return *this;
+    }
+
+    template <typename Return, typename Class, typename... Args>
+    class_ &def_buffer(Return (Class::*func)(Args...)) {
+        return def_buffer([func](type &obj) { return (obj.*func)(); });
+    }
+
+    template <typename Return, typename Class, typename... Args>
+    class_ &def_buffer(Return (Class::*func)(Args...) const) {
+        return def_buffer([func](const type &obj) { return (obj.*func)(); });
+    }
+
+    template <typename C, typename D, typename... Extra>
+    class_ &def_readwrite(const char *name, D C::*pm, const Extra &...extra) {
+        static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value,
+                      "def_readwrite() requires a class member (or base class member)");
+        def_property(name,
+                     property_cpp_function<type, D>::read(pm, *this),
+                     property_cpp_function<type, D>::write(pm, *this),
+                     return_value_policy::reference_internal,
+                     extra...);
+        return *this;
+    }
+
+    template <typename C, typename D, typename... Extra>
+    class_ &def_readonly(const char *name, const D C::*pm, const Extra &...extra) {
+        static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value,
+                      "def_readonly() requires a class member (or base class member)");
+        def_property_readonly(name,
+                              property_cpp_function<type, D>::readonly(pm, *this),
+                              return_value_policy::reference_internal,
+                              extra...);
+        return *this;
+    }
+
+    template <typename D, typename... Extra>
+    class_ &def_readwrite_static(const char *name, D *pm, const Extra &...extra) {
+        cpp_function fget([pm](const object &) -> const D & { return *pm; }, scope(*this)),
+            fset([pm](const object &, const D &value) { *pm = value; }, scope(*this));
+        def_property_static(name, fget, fset, return_value_policy::reference, extra...);
+        return *this;
+    }
+
+    template <typename D, typename... Extra>
+    class_ &def_readonly_static(const char *name, const D *pm, const Extra &...extra) {
+        cpp_function fget([pm](const object &) -> const D & { return *pm; }, scope(*this));
+        def_property_readonly_static(name, fget, return_value_policy::reference, extra...);
+        return *this;
+    }
+
+    /// Uses return_value_policy::reference_internal by default
+    template <typename Getter, typename... Extra>
+    class_ &def_property_readonly(const char *name, const Getter &fget, const Extra &...extra) {
+        return def_property_readonly(name,
+                                     cpp_function(method_adaptor<type>(fget)),
+                                     return_value_policy::reference_internal,
+                                     extra...);
+    }
+
+    /// Uses cpp_function's return_value_policy by default
+    template <typename... Extra>
+    class_ &
+    def_property_readonly(const char *name, const cpp_function &fget, const Extra &...extra) {
+        return def_property(name, fget, nullptr, extra...);
+    }
+
+    /// Uses return_value_policy::reference by default
+    template <typename Getter, typename... Extra>
+    class_ &
+    def_property_readonly_static(const char *name, const Getter &fget, const Extra &...extra) {
+        return def_property_readonly_static(
+            name, cpp_function(fget), return_value_policy::reference, extra...);
+    }
+
+    /// Uses cpp_function's return_value_policy by default
+    template <typename... Extra>
+    class_ &def_property_readonly_static(const char *name,
+                                         const cpp_function &fget,
+                                         const Extra &...extra) {
+        return def_property_static(name, fget, nullptr, extra...);
+    }
+
+    /// Uses return_value_policy::reference_internal by default
+    template <typename Getter, typename Setter, typename... Extra>
+    class_ &
+    def_property(const char *name, const Getter &fget, const Setter &fset, const Extra &...extra) {
+        return def_property(
+            name, fget, cpp_function(method_adaptor<type>(fset), is_setter()), extra...);
+    }
+    template <typename Getter, typename... Extra>
+    class_ &def_property(const char *name,
+                         const Getter &fget,
+                         const cpp_function &fset,
+                         const Extra &...extra) {
+        return def_property(name,
+                            cpp_function(method_adaptor<type>(fget)),
+                            fset,
+                            return_value_policy::reference_internal,
+                            extra...);
+    }
+
+    /// Uses cpp_function's return_value_policy by default
+    template <typename... Extra>
+    class_ &def_property(const char *name,
+                         const cpp_function &fget,
+                         const cpp_function &fset,
+                         const Extra &...extra) {
+        return def_property_static(name, fget, fset, is_method(*this), extra...);
+    }
+
+    /// Uses return_value_policy::reference by default
+    template <typename Getter, typename... Extra>
+    class_ &def_property_static(const char *name,
+                                const Getter &fget,
+                                const cpp_function &fset,
+                                const Extra &...extra) {
+        return def_property_static(
+            name, cpp_function(fget), fset, return_value_policy::reference, extra...);
+    }
+
+    /// Uses cpp_function's return_value_policy by default
+    template <typename... Extra>
+    class_ &def_property_static(const char *name,
+                                const cpp_function &fget,
+                                const cpp_function &fset,
+                                const Extra &...extra) {
+        static_assert(0 == detail::constexpr_sum(std::is_base_of<arg, Extra>::value...),
+                      "Argument annotations are not allowed for properties");
+        auto rec_fget = get_function_record(fget), rec_fset = get_function_record(fset);
+        auto *rec_active = rec_fget;
+        if (rec_fget) {
+            char *doc_prev = rec_fget->doc; /* 'extra' field may include a property-specific
+                                               documentation string */
+            detail::process_attributes<Extra...>::init(extra..., rec_fget);
+            if (rec_fget->doc && rec_fget->doc != doc_prev) {
+                std::free(doc_prev);
+                rec_fget->doc = PYBIND11_COMPAT_STRDUP(rec_fget->doc);
+            }
+        }
+        if (rec_fset) {
+            char *doc_prev = rec_fset->doc;
+            detail::process_attributes<Extra...>::init(extra..., rec_fset);
+            if (rec_fset->doc && rec_fset->doc != doc_prev) {
+                std::free(doc_prev);
+                rec_fset->doc = PYBIND11_COMPAT_STRDUP(rec_fset->doc);
+            }
+            if (!rec_active) {
+                rec_active = rec_fset;
+            }
+        }
+        def_property_static_impl(name, fget, fset, rec_active);
+        return *this;
+    }
+
+private:
+    /// Initialize holder object, variant 1: object derives from enable_shared_from_this
+    template <typename T>
+    static void init_holder(detail::instance *inst,
+                            detail::value_and_holder &v_h,
+                            const holder_type * /* unused */,
+                            const std::enable_shared_from_this<T> * /* dummy */) {
+
+        auto sh = std::dynamic_pointer_cast<typename holder_type::element_type>(
+            detail::try_get_shared_from_this(v_h.value_ptr<type>()));
+        if (sh) {
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(sh));
+            v_h.set_holder_constructed();
+        }
+
+        if (!v_h.holder_constructed() && inst->owned) {
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
+            v_h.set_holder_constructed();
+        }
+    }
+
+    static void init_holder_from_existing(const detail::value_and_holder &v_h,
+                                          const holder_type *holder_ptr,
+                                          std::true_type /*is_copy_constructible*/) {
+        new (std::addressof(v_h.holder<holder_type>()))
+            holder_type(*reinterpret_cast<const holder_type *>(holder_ptr));
+    }
+
+    static void init_holder_from_existing(const detail::value_and_holder &v_h,
+                                          const holder_type *holder_ptr,
+                                          std::false_type /*is_copy_constructible*/) {
+        new (std::addressof(v_h.holder<holder_type>()))
+            holder_type(std::move(*const_cast<holder_type *>(holder_ptr)));
+    }
+
+    /// Initialize holder object, variant 2: try to construct from existing holder object, if
+    /// possible
+    static void init_holder(detail::instance *inst,
+                            detail::value_and_holder &v_h,
+                            const holder_type *holder_ptr,
+                            const void * /* dummy -- not enable_shared_from_this<T>) */) {
+        if (holder_ptr) {
+            init_holder_from_existing(v_h, holder_ptr, std::is_copy_constructible<holder_type>());
+            v_h.set_holder_constructed();
+        } else if (detail::always_construct_holder<holder_type>::value || inst->owned) {
+            new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
+            v_h.set_holder_constructed();
+        }
+    }
+
+    /// Performs instance initialization including constructing a holder and registering the known
+    /// instance.  Should be called as soon as the `type` value_ptr is set for an instance.  Takes
+    /// an optional pointer to an existing holder to use; if not specified and the instance is
+    /// `.owned`, a new holder will be constructed to manage the value pointer.
+    template <typename H = holder_type,
+              detail::enable_if_t<!detail::is_smart_holder<H>::value, int> = 0>
+    static void init_instance(detail::instance *inst, const void *holder_ptr) {
+        auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
+        if (!v_h.instance_registered()) {
+            register_instance(inst, v_h.value_ptr(), v_h.type);
+            v_h.set_instance_registered();
+        }
+        init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
+    }
+
+    template <typename WrappedType>
+    static bool try_initialization_using_shared_from_this(holder_type *, WrappedType *, ...) {
+        return false;
+    }
+
+    // Adopting existing approach used by type_caster_base, although it leads to somewhat fuzzy
+    // ownership semantics: if we detected via shared_from_this that a shared_ptr exists already,
+    // it is reused, irrespective of the return_value_policy in effect.
+    // "SomeBaseOfWrappedType" is needed because std::enable_shared_from_this is not necessarily a
+    // direct base of WrappedType.
+    template <typename WrappedType, typename SomeBaseOfWrappedType>
+    static bool try_initialization_using_shared_from_this(
+        holder_type *uninitialized_location,
+        WrappedType *value_ptr_w_t,
+        const std::enable_shared_from_this<SomeBaseOfWrappedType> *) {
+        auto shd_ptr = std::dynamic_pointer_cast<WrappedType>(
+            detail::try_get_shared_from_this(value_ptr_w_t));
+        if (!shd_ptr) {
+            return false;
+        }
+        // Note: inst->owned ignored.
+        new (uninitialized_location) holder_type(holder_type::from_shared_ptr(shd_ptr));
+        return true;
+    }
+
+    template <typename H = holder_type,
+              detail::enable_if_t<detail::is_smart_holder<H>::value, int> = 0>
+    static void init_instance(detail::instance *inst, const void *holder_const_void_ptr) {
+        // Need for const_cast is a consequence of the type_info::init_instance type:
+        // void (*init_instance)(instance *, const void *);
+        auto *holder_void_ptr = const_cast<void *>(holder_const_void_ptr);
+
+        auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
+        if (!v_h.instance_registered()) {
+            register_instance(inst, v_h.value_ptr(), v_h.type);
+            v_h.set_instance_registered();
+        }
+        auto *uninitialized_location = std::addressof(v_h.holder<holder_type>());
+        auto *value_ptr_w_t = v_h.value_ptr<type>();
+        // Try downcast from `type` to `type_alias`:
+        inst->is_alias
+            = detail::dynamic_raw_ptr_cast_if_possible<type_alias>(value_ptr_w_t) != nullptr;
+        if (holder_void_ptr) {
+            // Note: inst->owned ignored.
+            auto *holder_ptr = static_cast<holder_type *>(holder_void_ptr);
+            new (uninitialized_location) holder_type(std::move(*holder_ptr));
+        } else if (!try_initialization_using_shared_from_this(
+                       uninitialized_location, value_ptr_w_t, value_ptr_w_t)) {
+            if (inst->owned) {
+                new (uninitialized_location) holder_type(holder_type::from_raw_ptr_take_ownership(
+                    value_ptr_w_t, /*void_cast_raw_ptr*/ inst->is_alias));
+            } else {
+                new (uninitialized_location)
+                    holder_type(holder_type::from_raw_ptr_unowned(value_ptr_w_t));
+            }
+        }
+        v_h.set_holder_constructed();
+    }
+
+    // Deallocates an instance; via holder, if constructed; otherwise via operator delete.
+    // NOTE: The Python error indicator needs to cleared BEFORE this function is called.
+    // This is because we could be deallocating while cleaning up after a Python exception.
+    // If the error indicator is not cleared but the C++ destructor code makes Python C API
+    // calls, those calls are likely to generate a new exception, and pybind11 will then
+    // throw `error_already_set` from the C++ destructor. This is forbidden and will
+    // trigger std::terminate().
+    static void dealloc_impl(detail::value_and_holder &v_h) {
+        if (v_h.holder_constructed()) {
+            v_h.holder<holder_type>().~holder_type();
+            v_h.set_holder_constructed(false);
+        } else {
+            detail::call_operator_delete(
+                v_h.value_ptr<type>(), v_h.type->type_size, v_h.type->type_align);
+        }
+        v_h.value_ptr() = nullptr;
+    }
+
+    static void dealloc_without_manipulating_gil(detail::value_and_holder &v_h) {
+        error_scope scope;
+        dealloc_impl(v_h);
+    }
+
+    static void dealloc_release_gil_before_calling_cpp_dtor(detail::value_and_holder &v_h) {
+        error_scope scope;
+        // Intentionally not using `gil_scoped_release` because the non-simple
+        // version unconditionally calls `get_internals()`.
+        // `Py_BEGIN_ALLOW_THREADS`, `Py_END_ALLOW_THREADS` cannot be used
+        // because those macros include `{` and `}`.
+        PyThreadState *py_ts = PyEval_SaveThread();
+        try {
+            dealloc_impl(v_h);
+        } catch (...) {
+            // This code path is expected to be unreachable unless there is a
+            // bug in pybind11 itself.
+            // An alternative would be to mark this function, or
+            // `dealloc_impl()`, with `nothrow`, but that would be a subtle
+            // behavior change and could make debugging more difficult.
+            PyEval_RestoreThread(py_ts);
+            throw;
+        }
+        PyEval_RestoreThread(py_ts);
+    }
+
+    static detail::function_record *get_function_record(handle h) {
+        h = detail::get_function(h);
+        if (!h) {
+            return nullptr;
+        }
+
+        handle func_self = PyCFunction_GET_SELF(h.ptr());
+        if (!func_self) {
+            throw error_already_set();
+        }
+        return detail::function_record_ptr_from_PyObject(func_self.ptr());
+    }
+};
+
+// Supports easier switching between py::class_<T> and py::class_<T, py::smart_holder>:
+// users can simply replace the `_` in `class_` with `h` or vice versa.
+template <typename type_, typename... options>
+using classh = class_<type_, smart_holder, options...>;
+
+/// Binds an existing constructor taking arguments Args...
+template <typename... Args>
+detail::initimpl::constructor<Args...> init() {
+    return {};
+}
+/// Like `init<Args...>()`, but the instance is always constructed through the alias class (even
+/// when not inheriting on the Python side).
+template <typename... Args>
+detail::initimpl::alias_constructor<Args...> init_alias() {
+    return {};
+}
+
+/// Binds a factory function as a constructor
+template <typename Func, typename Ret = detail::initimpl::factory<Func>>
+Ret init(Func &&f) {
+    return {std::forward<Func>(f)};
+}
+
+/// Dual-argument factory function: the first function is called when no alias is needed, the
+/// second when an alias is needed (i.e. due to python-side inheritance).  Arguments must be
+/// identical.
+template <typename CFunc, typename AFunc, typename Ret = detail::initimpl::factory<CFunc, AFunc>>
+Ret init(CFunc &&c, AFunc &&a) {
+    return {std::forward<CFunc>(c), std::forward<AFunc>(a)};
+}
+
+/// Binds pickling functions `__getstate__` and `__setstate__` and ensures that the type
+/// returned by `__getstate__` is the same as the argument accepted by `__setstate__`.
+template <typename GetState, typename SetState>
+detail::initimpl::pickle_factory<GetState, SetState> pickle(GetState &&g, SetState &&s) {
+    return {std::forward<GetState>(g), std::forward<SetState>(s)};
+}
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+inline str enum_name(handle arg) {
+    dict entries = type::handle_of(arg).attr("__entries");
+    for (auto kv : entries) {
+        if (handle(kv.second[int_(0)]).equal(arg)) {
+            return pybind11::str(kv.first);
+        }
+    }
+    return "???";
+}
+
+struct enum_base {
+    enum_base(const handle &base, const handle &parent) : m_base(base), m_parent(parent) {}
+
+    PYBIND11_NOINLINE void init(bool is_arithmetic, bool is_convertible) {
+        m_base.attr("__entries") = dict();
+        auto property = handle((PyObject *) &PyProperty_Type);
+        auto static_property = handle((PyObject *) get_internals().static_property_type);
+
+        m_base.attr("__repr__") = cpp_function(
+            [](const object &arg) -> str {
+                handle type = type::handle_of(arg);
+                object type_name = type.attr("__name__");
+                return pybind11::str("<{}.{}: {}>")
+                    .format(std::move(type_name), enum_name(arg), int_(arg));
+            },
+            name("__repr__"),
+            is_method(m_base),
+            pos_only());
+
+        m_base.attr("name")
+            = property(cpp_function(&enum_name, name("name"), is_method(m_base), pos_only()));
+
+        m_base.attr("__str__") = cpp_function(
+            [](handle arg) -> str {
+                object type_name = type::handle_of(arg).attr("__name__");
+                return pybind11::str("{}.{}").format(std::move(type_name), enum_name(arg));
+            },
+            name("__str__"),
+            is_method(m_base),
+            pos_only());
+
+        if (options::show_enum_members_docstring()) {
+            m_base.attr("__doc__") = static_property(
+                cpp_function(
+                    [](handle arg) -> std::string {
+                        std::string docstring;
+                        dict entries = arg.attr("__entries");
+                        if (((PyTypeObject *) arg.ptr())->tp_doc) {
+                            docstring += std::string(
+                                reinterpret_cast<PyTypeObject *>(arg.ptr())->tp_doc);
+                            docstring += "\n\n";
+                        }
+                        docstring += "Members:";
+                        for (auto kv : entries) {
+                            auto key = std::string(pybind11::str(kv.first));
+                            auto comment = kv.second[int_(1)];
+                            docstring += "\n\n  ";
+                            docstring += key;
+                            if (!comment.is_none()) {
+                                docstring += " : ";
+                                docstring += pybind11::str(comment).cast<std::string>();
+                            }
+                        }
+                        return docstring;
+                    },
+                    name("__doc__")),
+                none(),
+                none(),
+                "");
+        }
+
+        m_base.attr("__members__") = static_property(cpp_function(
+                                                         [](handle arg) -> dict {
+                                                             dict entries = arg.attr("__entries"),
+                                                                  m;
+                                                             for (auto kv : entries) {
+                                                                 m[kv.first] = kv.second[int_(0)];
+                                                             }
+                                                             return m;
+                                                         },
+                                                         name("__members__")),
+                                                     none(),
+                                                     none(),
+                                                     "");
+
+#define PYBIND11_ENUM_OP_STRICT(op, expr, strict_behavior)                                        \
+    m_base.attr(op) = cpp_function(                                                               \
+        [](const object &a, const object &b) {                                                    \
+            if (!type::handle_of(a).is(type::handle_of(b)))                                       \
+                strict_behavior; /* NOLINT(bugprone-macro-parentheses) */                         \
+            return expr;                                                                          \
+        },                                                                                        \
+        name(op),                                                                                 \
+        is_method(m_base),                                                                        \
+        arg("other"),                                                                             \
+        pos_only())
+
+#define PYBIND11_ENUM_OP_CONV(op, expr)                                                           \
+    m_base.attr(op) = cpp_function(                                                               \
+        [](const object &a_, const object &b_) {                                                  \
+            int_ a(a_), b(b_);                                                                    \
+            return expr;                                                                          \
+        },                                                                                        \
+        name(op),                                                                                 \
+        is_method(m_base),                                                                        \
+        arg("other"),                                                                             \
+        pos_only())
+
+#define PYBIND11_ENUM_OP_CONV_LHS(op, expr)                                                       \
+    m_base.attr(op) = cpp_function(                                                               \
+        [](const object &a_, const object &b) {                                                   \
+            int_ a(a_);                                                                           \
+            return expr;                                                                          \
+        },                                                                                        \
+        name(op),                                                                                 \
+        is_method(m_base),                                                                        \
+        arg("other"),                                                                             \
+        pos_only())
+
+        if (is_convertible) {
+            PYBIND11_ENUM_OP_CONV_LHS("__eq__", !b.is_none() && a.equal(b));
+            PYBIND11_ENUM_OP_CONV_LHS("__ne__", b.is_none() || !a.equal(b));
+
+            if (is_arithmetic) {
+                PYBIND11_ENUM_OP_CONV("__lt__", a < b);
+                PYBIND11_ENUM_OP_CONV("__gt__", a > b);
+                PYBIND11_ENUM_OP_CONV("__le__", a <= b);
+                PYBIND11_ENUM_OP_CONV("__ge__", a >= b);
+                PYBIND11_ENUM_OP_CONV("__and__", a & b);
+                PYBIND11_ENUM_OP_CONV("__rand__", a & b);
+                PYBIND11_ENUM_OP_CONV("__or__", a | b);
+                PYBIND11_ENUM_OP_CONV("__ror__", a | b);
+                PYBIND11_ENUM_OP_CONV("__xor__", a ^ b);
+                PYBIND11_ENUM_OP_CONV("__rxor__", a ^ b);
+                m_base.attr("__invert__")
+                    = cpp_function([](const object &arg) { return ~(int_(arg)); },
+                                   name("__invert__"),
+                                   is_method(m_base),
+                                   pos_only());
+            }
+        } else {
+            PYBIND11_ENUM_OP_STRICT("__eq__", int_(a).equal(int_(b)), return false);
+            PYBIND11_ENUM_OP_STRICT("__ne__", !int_(a).equal(int_(b)), return true);
+
+            if (is_arithmetic) {
+#define PYBIND11_THROW throw type_error("Expected an enumeration of matching type!");
+                PYBIND11_ENUM_OP_STRICT("__lt__", int_(a) < int_(b), PYBIND11_THROW);
+                PYBIND11_ENUM_OP_STRICT("__gt__", int_(a) > int_(b), PYBIND11_THROW);
+                PYBIND11_ENUM_OP_STRICT("__le__", int_(a) <= int_(b), PYBIND11_THROW);
+                PYBIND11_ENUM_OP_STRICT("__ge__", int_(a) >= int_(b), PYBIND11_THROW);
+#undef PYBIND11_THROW
+            }
+        }
+
+#undef PYBIND11_ENUM_OP_CONV_LHS
+#undef PYBIND11_ENUM_OP_CONV
+#undef PYBIND11_ENUM_OP_STRICT
+
+        m_base.attr("__getstate__") = cpp_function([](const object &arg) { return int_(arg); },
+                                                   name("__getstate__"),
+                                                   is_method(m_base),
+                                                   pos_only());
+
+        m_base.attr("__hash__") = cpp_function([](const object &arg) { return int_(arg); },
+                                               name("__hash__"),
+                                               is_method(m_base),
+                                               pos_only());
+    }
+
+    PYBIND11_NOINLINE void value(char const *name_, object value, const char *doc = nullptr) {
+        dict entries = m_base.attr("__entries");
+        str name(name_);
+        if (entries.contains(name)) {
+            std::string type_name = (std::string) str(m_base.attr("__name__"));
+            throw value_error(std::move(type_name) + ": element \"" + std::string(name_)
+                              + "\" already exists!");
+        }
+
+        entries[name] = pybind11::make_tuple(value, doc);
+        m_base.attr(std::move(name)) = std::move(value);
+    }
+
+    PYBIND11_NOINLINE void export_values() {
+        dict entries = m_base.attr("__entries");
+        for (auto kv : entries) {
+            m_parent.attr(kv.first) = kv.second[int_(0)];
+        }
+    }
+
+    handle m_base;
+    handle m_parent;
+};
+
+template <bool is_signed, size_t length>
+struct equivalent_integer {};
+template <>
+struct equivalent_integer<true, 1> {
+    using type = int8_t;
+};
+template <>
+struct equivalent_integer<false, 1> {
+    using type = uint8_t;
+};
+template <>
+struct equivalent_integer<true, 2> {
+    using type = int16_t;
+};
+template <>
+struct equivalent_integer<false, 2> {
+    using type = uint16_t;
+};
+template <>
+struct equivalent_integer<true, 4> {
+    using type = int32_t;
+};
+template <>
+struct equivalent_integer<false, 4> {
+    using type = uint32_t;
+};
+template <>
+struct equivalent_integer<true, 8> {
+    using type = int64_t;
+};
+template <>
+struct equivalent_integer<false, 8> {
+    using type = uint64_t;
+};
+
+template <typename IntLike>
+using equivalent_integer_t =
+    typename equivalent_integer<std::is_signed<IntLike>::value, sizeof(IntLike)>::type;
+
+PYBIND11_NAMESPACE_END(detail)
+
+/// Binds C++ enumerations and enumeration classes to Python
+template <typename Type>
+class enum_ : public class_<Type> {
+public:
+    using Base = class_<Type>;
+    using Base::attr;
+    using Base::def;
+    using Base::def_property_readonly;
+    using Base::def_property_readonly_static;
+    using Underlying = typename std::underlying_type<Type>::type;
+    // Scalar is the integer representation of underlying type
+    using Scalar = detail::conditional_t<detail::any_of<detail::is_std_char_type<Underlying>,
+                                                        std::is_same<Underlying, bool>>::value,
+                                         detail::equivalent_integer_t<Underlying>,
+                                         Underlying>;
+
+    template <typename... Extra>
+    enum_(const handle &scope, const char *name, const Extra &...extra)
+        : class_<Type>(scope, name, extra...), m_base(*this, scope) {
+        {
+            if (detail::global_internals_native_enum_type_map_contains(
+                    std::type_index(typeid(Type)))) {
+                pybind11_fail("pybind11::enum_ \"" + std::string(name)
+                              + "\" is already registered as a pybind11::native_enum!");
+            }
+        }
+
+        constexpr bool is_arithmetic = detail::any_of<std::is_same<arithmetic, Extra>...>::value;
+        constexpr bool is_convertible = std::is_convertible<Type, Underlying>::value;
+        m_base.init(is_arithmetic, is_convertible);
+
+        def(init([](Scalar i) { return static_cast<Type>(i); }), arg("value"));
+        def_property_readonly("value", [](Type value) { return (Scalar) value; }, pos_only());
+        def("__int__", [](Type value) { return (Scalar) value; }, pos_only());
+        def("__index__", [](Type value) { return (Scalar) value; }, pos_only());
+        attr("__setstate__") = cpp_function(
+            [](detail::value_and_holder &v_h, Scalar arg) {
+                detail::initimpl::setstate<Base>(
+                    v_h, static_cast<Type>(arg), Py_TYPE(v_h.inst) != v_h.type->type);
+            },
+            detail::is_new_style_constructor(),
+            pybind11::name("__setstate__"),
+            is_method(*this),
+            arg("state"),
+            pos_only());
+    }
+
+    /// Export enumeration entries into the parent scope
+    enum_ &export_values() {
+        m_base.export_values();
+        return *this;
+    }
+
+    /// Add an enumeration entry
+    enum_ &value(char const *name, Type value, const char *doc = nullptr) {
+        m_base.value(name, pybind11::cast(value, return_value_policy::copy), doc);
+        return *this;
+    }
+
+private:
+    detail::enum_base m_base;
+};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+PYBIND11_NOINLINE void keep_alive_impl(handle nurse, handle patient) {
+    if (!nurse || !patient) {
+        pybind11_fail("Could not activate keep_alive!");
+    }
+
+    if (patient.is_none() || nurse.is_none()) {
+        return; /* Nothing to keep alive or nothing to be kept alive by */
+    }
+
+    auto tinfo = all_type_info(Py_TYPE(nurse.ptr()));
+    if (!tinfo.empty()) {
+        /* It's a pybind-registered type, so we can store the patient in the
+         * internal list. */
+        add_patient(nurse.ptr(), patient.ptr());
+    } else {
+        /* Fall back to clever approach based on weak references taken from
+         * Boost.Python. This is not used for pybind-registered types because
+         * the objects can be destroyed out-of-order in a GC pass. */
+        cpp_function disable_lifesupport([patient](handle weakref) {
+            patient.dec_ref();
+            weakref.dec_ref();
+        });
+
+        weakref wr(nurse, disable_lifesupport);
+
+        patient.inc_ref(); /* reference patient and leak the weak reference */
+        (void) wr.release();
+    }
+}
+
+PYBIND11_NOINLINE void
+keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret) {
+    auto get_arg = [&](size_t n) {
+        if (n == 0) {
+            return ret;
+        }
+        if (n == 1 && call.init_self) {
+            return call.init_self;
+        }
+        if (n <= call.args.size()) {
+            return call.args[n - 1];
+        }
+        return handle();
+    };
+
+    keep_alive_impl(get_arg(Nurse), get_arg(Patient));
+}
+
+inline std::pair<decltype(internals::registered_types_py)::iterator, bool>
+all_type_info_get_cache(PyTypeObject *type) {
+    auto res = with_internals([type](internals &internals) {
+        auto ins = internals
+                       .registered_types_py
+#ifdef __cpp_lib_unordered_map_try_emplace
+                       .try_emplace(type);
+#else
+                       .emplace(type, std::vector<detail::type_info *>());
+#endif
+        if (ins.second) {
+            // For free-threading mode, this call must be under
+            // the with_internals() mutex lock, to avoid that other threads
+            // continue running with the empty ins.first->second.
+            all_type_info_populate(type, ins.first->second);
+        }
+        return ins;
+    });
+    if (res.second) {
+        // New cache entry created; set up a weak reference to automatically remove it if the type
+        // gets destroyed:
+        weakref((PyObject *) type, cpp_function([type](handle wr) {
+                    with_internals([type](internals &internals) {
+                        internals.registered_types_py.erase(type);
+
+                        // TODO consolidate the erasure code in pybind11_meta_dealloc() in class.h
+                        auto &cache = internals.inactive_override_cache;
+                        for (auto it = cache.begin(), last = cache.end(); it != last;) {
+                            if (it->first == reinterpret_cast<PyObject *>(type)) {
+                                it = cache.erase(it);
+                            } else {
+                                ++it;
+                            }
+                        }
+                    });
+
+                    wr.dec_ref();
+                }))
+            .release();
+    }
+
+    return res;
+}
+
+/* There are a large number of apparently unused template arguments because
+ * each combination requires a separate py::class_ registration.
+ */
+template <typename Access,
+          return_value_policy Policy,
+          typename Iterator,
+          typename Sentinel,
+          typename ValueType,
+          typename... Extra>
+struct iterator_state {
+    Iterator it;
+    Sentinel end;
+    bool first_or_done;
+};
+
+// Note: these helpers take the iterator by non-const reference because some
+// iterators in the wild can't be dereferenced when const. The & after Iterator
+// is required for MSVC < 16.9. SFINAE cannot be reused for result_type due to
+// bugs in ICC, NVCC, and PGI compilers. See PR #3293.
+template <typename Iterator, typename SFINAE = decltype(*std::declval<Iterator &>())>
+struct iterator_access {
+    using result_type = decltype(*std::declval<Iterator &>());
+    // NOLINTNEXTLINE(readability-const-return-type) // PR #3263
+    result_type operator()(Iterator &it) const { return *it; }
+};
+
+template <typename Iterator, typename SFINAE = decltype((*std::declval<Iterator &>()).first)>
+class iterator_key_access {
+private:
+    using pair_type = decltype(*std::declval<Iterator &>());
+
+public:
+    /* If either the pair itself or the element of the pair is a reference, we
+     * want to return a reference, otherwise a value. When the decltype
+     * expression is parenthesized it is based on the value category of the
+     * expression; otherwise it is the declared type of the pair member.
+     * The use of declval<pair_type> in the second branch rather than directly
+     * using *std::declval<Iterator &>() is a workaround for nvcc
+     * (it's not used in the first branch because going via decltype and back
+     * through declval does not perfectly preserve references).
+     */
+    using result_type
+        = conditional_t<std::is_reference<decltype(*std::declval<Iterator &>())>::value,
+                        decltype(((*std::declval<Iterator &>()).first)),
+                        decltype(std::declval<pair_type>().first)>;
+    result_type operator()(Iterator &it) const { return (*it).first; }
+};
+
+template <typename Iterator, typename SFINAE = decltype((*std::declval<Iterator &>()).second)>
+class iterator_value_access {
+private:
+    using pair_type = decltype(*std::declval<Iterator &>());
+
+public:
+    using result_type
+        = conditional_t<std::is_reference<decltype(*std::declval<Iterator &>())>::value,
+                        decltype(((*std::declval<Iterator &>()).second)),
+                        decltype(std::declval<pair_type>().second)>;
+    result_type operator()(Iterator &it) const { return (*it).second; }
+};
+
+template <typename Access,
+          return_value_policy Policy,
+          typename Iterator,
+          typename Sentinel,
+          typename ValueType,
+          typename... Extra>
+// NOLINTNEXTLINE(performance-unnecessary-value-param)
+iterator make_iterator_impl(Iterator first, Sentinel last, Extra &&...extra) {
+    using state = detail::iterator_state<Access, Policy, Iterator, Sentinel, ValueType, Extra...>;
+    // TODO: state captures only the types of Extra, not the values
+
+    if (!detail::get_type_info(typeid(state), false)) {
+        class_<state>(handle(), "iterator", pybind11::module_local())
+            .def(
+                "__iter__", [](state &s) -> state & { return s; }, pos_only())
+            .def(
+                "__next__",
+                [](state &s) -> ValueType {
+                    if (!s.first_or_done) {
+                        ++s.it;
+                    } else {
+                        s.first_or_done = false;
+                    }
+                    if (s.it == s.end) {
+                        s.first_or_done = true;
+                        throw stop_iteration();
+                    }
+                    return Access()(s.it);
+                    // NOLINTNEXTLINE(readability-const-return-type) // PR #3263
+                },
+                std::forward<Extra>(extra)...,
+                pos_only(),
+                Policy);
+    }
+
+    return cast(state{std::forward<Iterator>(first), std::forward<Sentinel>(last), true});
+}
+
+PYBIND11_NAMESPACE_END(detail)
+
+/// Makes a python iterator from a first and past-the-end C++ InputIterator.
+template <return_value_policy Policy = return_value_policy::reference_internal,
+          typename Iterator,
+          typename Sentinel,
+          typename ValueType = typename detail::iterator_access<Iterator>::result_type,
+          typename... Extra>
+// NOLINTNEXTLINE(performance-unnecessary-value-param)
+typing::Iterator<ValueType> make_iterator(Iterator first, Sentinel last, Extra &&...extra) {
+    return detail::make_iterator_impl<detail::iterator_access<Iterator>,
+                                      Policy,
+                                      Iterator,
+                                      Sentinel,
+                                      ValueType,
+                                      Extra...>(std::forward<Iterator>(first),
+                                                std::forward<Sentinel>(last),
+                                                std::forward<Extra>(extra)...);
+}
+
+/// Makes a python iterator over the keys (`.first`) of a iterator over pairs from a
+/// first and past-the-end InputIterator.
+template <return_value_policy Policy = return_value_policy::reference_internal,
+          typename Iterator,
+          typename Sentinel,
+          typename KeyType = typename detail::iterator_key_access<Iterator>::result_type,
+          typename... Extra>
+typing::Iterator<KeyType> make_key_iterator(Iterator first, Sentinel last, Extra &&...extra) {
+    return detail::make_iterator_impl<detail::iterator_key_access<Iterator>,
+                                      Policy,
+                                      Iterator,
+                                      Sentinel,
+                                      KeyType,
+                                      Extra...>(std::forward<Iterator>(first),
+                                                std::forward<Sentinel>(last),
+                                                std::forward<Extra>(extra)...);
+}
+
+/// Makes a python iterator over the values (`.second`) of a iterator over pairs from a
+/// first and past-the-end InputIterator.
+template <return_value_policy Policy = return_value_policy::reference_internal,
+          typename Iterator,
+          typename Sentinel,
+          typename ValueType = typename detail::iterator_value_access<Iterator>::result_type,
+          typename... Extra>
+typing::Iterator<ValueType> make_value_iterator(Iterator first, Sentinel last, Extra &&...extra) {
+    return detail::make_iterator_impl<detail::iterator_value_access<Iterator>,
+                                      Policy,
+                                      Iterator,
+                                      Sentinel,
+                                      ValueType,
+                                      Extra...>(std::forward<Iterator>(first),
+                                                std::forward<Sentinel>(last),
+                                                std::forward<Extra>(extra)...);
+}
+
+/// Makes an iterator over values of an stl container or other container supporting
+/// `std::begin()`/`std::end()`
+template <return_value_policy Policy = return_value_policy::reference_internal,
+          typename Type,
+          typename ValueType = typename detail::iterator_access<
+              decltype(std::begin(std::declval<Type &>()))>::result_type,
+          typename... Extra>
+typing::Iterator<ValueType> make_iterator(Type &value, Extra &&...extra) {
+    return make_iterator<Policy>(
+        std::begin(value), std::end(value), std::forward<Extra>(extra)...);
+}
+
+/// Makes an iterator over the keys (`.first`) of a stl map-like container supporting
+/// `std::begin()`/`std::end()`
+template <return_value_policy Policy = return_value_policy::reference_internal,
+          typename Type,
+          typename KeyType = typename detail::iterator_key_access<
+              decltype(std::begin(std::declval<Type &>()))>::result_type,
+          typename... Extra>
+typing::Iterator<KeyType> make_key_iterator(Type &value, Extra &&...extra) {
+    return make_key_iterator<Policy>(
+        std::begin(value), std::end(value), std::forward<Extra>(extra)...);
+}
+
+/// Makes an iterator over the values (`.second`) of a stl map-like container supporting
+/// `std::begin()`/`std::end()`
+template <return_value_policy Policy = return_value_policy::reference_internal,
+          typename Type,
+          typename ValueType = typename detail::iterator_value_access<
+              decltype(std::begin(std::declval<Type &>()))>::result_type,
+          typename... Extra>
+typing::Iterator<ValueType> make_value_iterator(Type &value, Extra &&...extra) {
+    return make_value_iterator<Policy>(
+        std::begin(value), std::end(value), std::forward<Extra>(extra)...);
+}
+
+template <typename InputType, typename OutputType>
+void implicitly_convertible() {
+    static int tss_sentinel_pointee = 1; // arbitrary value
+    struct set_flag {
+        thread_specific_storage<int> &flag;
+        explicit set_flag(thread_specific_storage<int> &flag_) : flag(flag_) {
+            flag = &tss_sentinel_pointee; // trick: the pointer itself is the sentinel
+        }
+        ~set_flag() { flag.reset(nullptr); }
+
+        // Prevent copying/moving to ensure RAII guard is used safely
+        set_flag(const set_flag &) = delete;
+        set_flag(set_flag &&) = delete;
+        set_flag &operator=(const set_flag &) = delete;
+        set_flag &operator=(set_flag &&) = delete;
+    };
+    auto implicit_caster = [](PyObject *obj, PyTypeObject *type) -> PyObject * {
+        static thread_specific_storage<int> currently_used;
+        if (currently_used) { // implicit conversions are non-reentrant
+            return nullptr;
+        }
+        set_flag flag_helper(currently_used);
+        if (!detail::make_caster<InputType>().load(obj, false)) {
+            return nullptr;
+        }
+        tuple args(1);
+        args[0] = obj;
+        PyObject *result = PyObject_Call((PyObject *) type, args.ptr(), nullptr);
+        if (result == nullptr) {
+            PyErr_Clear();
+        }
+        return result;
+    };
+
+    if (auto *tinfo = detail::get_type_info(typeid(OutputType))) {
+        tinfo->implicit_conversions.emplace_back(std::move(implicit_caster));
+    } else {
+        pybind11_fail("implicitly_convertible: Unable to find type " + type_id<OutputType>());
+    }
+}
+
+inline void register_exception_translator(ExceptionTranslator &&translator) {
+    detail::with_exception_translators(
+        [&](std::forward_list<ExceptionTranslator> &exception_translators,
+            std::forward_list<ExceptionTranslator> &local_exception_translators) {
+            (void) local_exception_translators;
+            exception_translators.push_front(std::forward<ExceptionTranslator>(translator));
+        });
+}
+
+/**
+ * Add a new module-local exception translator. Locally registered functions
+ * will be tried before any globally registered exception translators, which
+ * will only be invoked if the module-local handlers do not deal with
+ * the exception.
+ */
+inline void register_local_exception_translator(ExceptionTranslator &&translator) {
+    detail::with_exception_translators(
+        [&](std::forward_list<ExceptionTranslator> &exception_translators,
+            std::forward_list<ExceptionTranslator> &local_exception_translators) {
+            (void) exception_translators;
+            local_exception_translators.push_front(std::forward<ExceptionTranslator>(translator));
+        });
+}
+
+/**
+ * Wrapper to generate a new Python exception type.
+ *
+ * This should only be used with py::set_error() for now.
+ * It is not (yet) possible to use as a py::base.
+ * Template type argument is reserved for future use.
+ */
+template <typename type>
+class exception : public object {
+public:
+    exception() = default;
+    exception(handle scope, const char *name, handle base = PyExc_Exception) {
+        std::string full_name
+            = scope.attr("__name__").cast<std::string>() + std::string(".") + name;
+        m_ptr = PyErr_NewException(const_cast<char *>(full_name.c_str()), base.ptr(), nullptr);
+        if (hasattr(scope, "__dict__") && scope.attr("__dict__").contains(name)) {
+            pybind11_fail("Error during initialization: multiple incompatible "
+                          "definitions with name \""
+                          + std::string(name) + "\"");
+        }
+        scope.attr(name) = *this;
+    }
+
+    // Sets the current python exception to this exception object with the given message
+    PYBIND11_DEPRECATED("Please use py::set_error() instead "
+                        "(https://github.com/pybind/pybind11/pull/4772)")
+    void operator()(const char *message) const { set_error(*this, message); }
+};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+template <>
+struct handle_type_name<exception<void>> {
+    static constexpr auto name = const_name("Exception");
+};
+
+// Helper function for register_exception and register_local_exception
+template <typename CppException>
+exception<CppException> &
+register_exception_impl(handle scope, const char *name, handle base, bool isLocal) {
+    PYBIND11_CONSTINIT static gil_safe_call_once_and_store<exception<CppException>> exc_storage;
+    exc_storage.call_once_and_store_result(
+        [&]() { return exception<CppException>(scope, name, base); });
+
+    auto register_func
+        = isLocal ? &register_local_exception_translator : &register_exception_translator;
+
+    register_func([](std::exception_ptr p) {
+        if (!p) {
+            return;
+        }
+        try {
+            std::rethrow_exception(p);
+        } catch (const CppException &e) {
+            set_error(exc_storage.get_stored(), e.what());
+        }
+    });
+    return exc_storage.get_stored();
+}
+
+PYBIND11_NAMESPACE_END(detail)
+
+/**
+ * Registers a Python exception in `m` of the given `name` and installs a translator to
+ * translate the C++ exception to the created Python exception using the what() method.
+ * This is intended for simple exception translations; for more complex translation, register the
+ * exception object and translator directly.
+ */
+template <typename CppException>
+exception<CppException> &
+register_exception(handle scope, const char *name, handle base = PyExc_Exception) {
+    return detail::register_exception_impl<CppException>(scope, name, base, false /* isLocal */);
+}
+
+/**
+ * Registers a Python exception in `m` of the given `name` and installs a translator to
+ * translate the C++ exception to the created Python exception using the what() method.
+ * This translator will only be used for exceptions that are thrown in this module and will be
+ * tried before global exception translators, including those registered with register_exception.
+ * This is intended for simple exception translations; for more complex translation, register the
+ * exception object and translator directly.
+ */
+template <typename CppException>
+exception<CppException> &
+register_local_exception(handle scope, const char *name, handle base = PyExc_Exception) {
+    return detail::register_exception_impl<CppException>(scope, name, base, true /* isLocal */);
+}
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+PYBIND11_NOINLINE void print(const tuple &args, const dict &kwargs) {
+    auto strings = tuple(args.size());
+    for (size_t i = 0; i < args.size(); ++i) {
+        strings[i] = str(args[i]);
+    }
+    auto sep = kwargs.contains("sep") ? kwargs["sep"] : str(" ");
+    auto line = sep.attr("join")(std::move(strings));
+
+    object file;
+    if (kwargs.contains("file")) {
+        file = kwargs["file"].cast<object>();
+    } else {
+        try {
+            file = module_::import("sys").attr("stdout");
+        } catch (const error_already_set &) {
+            /* If print() is called from code that is executed as
+               part of garbage collection during interpreter shutdown,
+               importing 'sys' can fail. Give up rather than crashing the
+               interpreter in this case. */
+            return;
+        }
+    }
+
+    auto write = file.attr("write");
+    write(std::move(line));
+    write(kwargs.contains("end") ? kwargs["end"] : str("\n"));
+
+    if (kwargs.contains("flush") && kwargs["flush"].cast<bool>()) {
+        file.attr("flush")();
+    }
+}
+PYBIND11_NAMESPACE_END(detail)
+
+template <return_value_policy policy = return_value_policy::automatic_reference, typename... Args>
+void print(Args &&...args) {
+    auto c = detail::collect_arguments<policy>(std::forward<Args>(args)...);
+    detail::print(c.args(), c.kwargs());
+}
+
+inline void
+error_already_set::m_fetched_error_deleter(detail::error_fetch_and_normalize *raw_ptr) {
+    gil_scoped_acquire gil;
+    error_scope scope;
+    delete raw_ptr;
+}
+
+inline const char *error_already_set::what() const noexcept {
+    gil_scoped_acquire gil;
+    error_scope scope;
+    return m_fetched_error->error_string().c_str();
+}
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+inline function
+get_type_override(const void *this_ptr, const type_info *this_type, const char *name) {
+    handle self = get_object_handle(this_ptr, this_type);
+    if (!self) {
+        return function();
+    }
+    handle type = type::handle_of(self);
+    auto key = std::make_pair(type.ptr(), name);
+
+    /* Cache functions that aren't overridden in Python to avoid
+       many costly Python dictionary lookups below */
+    bool not_overridden = with_internals([&key](internals &internals) {
+        auto &cache = internals.inactive_override_cache;
+        return cache.find(key) != cache.end();
+    });
+    if (not_overridden) {
+        return function();
+    }
+
+    function override = getattr(self, name, function());
+    if (override.is_cpp_function()) {
+        with_internals([&](internals &internals) {
+            internals.inactive_override_cache.insert(std::move(key));
+        });
+        return function();
+    }
+
+    /* Don't call dispatch code if invoked from overridden function.
+       Unfortunately this doesn't work on PyPy and GraalPy. */
+#if !defined(PYPY_VERSION) && !defined(GRAALVM_PYTHON)
+#    if PY_VERSION_HEX >= 0x03090000
+    PyFrameObject *frame = PyThreadState_GetFrame(PyThreadState_Get());
+    if (frame != nullptr) {
+        PyCodeObject *f_code = PyFrame_GetCode(frame);
+        // f_code is guaranteed to not be NULL
+        if ((std::string) str(f_code->co_name) == name && f_code->co_argcount > 0) {
+#        if PY_VERSION_HEX >= 0x030d0000
+            PyObject *locals = PyEval_GetFrameLocals();
+#        else
+            PyObject *locals = PyEval_GetLocals();
+            Py_XINCREF(locals);
+#        endif
+            if (locals != nullptr) {
+#        if PY_VERSION_HEX >= 0x030b0000
+                PyObject *co_varnames = PyCode_GetVarnames(f_code);
+#        else
+                PyObject *co_varnames = PyObject_GetAttrString((PyObject *) f_code, "co_varnames");
+#        endif
+                PyObject *self_arg = PyTuple_GET_ITEM(co_varnames, 0);
+                Py_DECREF(co_varnames);
+                PyObject *self_caller = dict_getitem(locals, self_arg);
+                Py_DECREF(locals);
+                if (self_caller == self.ptr()) {
+                    Py_DECREF(f_code);
+                    Py_DECREF(frame);
+                    return function();
+                }
+            }
+        }
+        Py_DECREF(f_code);
+        Py_DECREF(frame);
+    }
+#    else
+    PyFrameObject *frame = PyThreadState_Get()->frame;
+    if (frame != nullptr && (std::string) str(frame->f_code->co_name) == name
+        && frame->f_code->co_argcount > 0) {
+        PyFrame_FastToLocals(frame);
+        PyObject *self_caller
+            = dict_getitem(frame->f_locals, PyTuple_GET_ITEM(frame->f_code->co_varnames, 0));
+        if (self_caller == self.ptr()) {
+            return function();
+        }
+    }
+#    endif
+
+#else
+    /* PyPy currently doesn't provide a detailed cpyext emulation of
+       frame objects, so we have to emulate this using Python. This
+       is going to be slow..*/
+    dict d;
+    d["self"] = self;
+    d["name"] = pybind11::str(name);
+    PyObject *result
+        = PyRun_String("import inspect\n"
+                       "frame = inspect.currentframe()\n"
+                       "if frame is not None:\n"
+                       "    frame = frame.f_back\n"
+                       "    if frame is not None and str(frame.f_code.co_name) == name and "
+                       "frame.f_code.co_argcount > 0:\n"
+                       "        self_caller = frame.f_locals[frame.f_code.co_varnames[0]]\n"
+                       "        if self_caller == self:\n"
+                       "            self = None\n",
+                       Py_file_input,
+                       d.ptr(),
+                       d.ptr());
+    if (result == nullptr)
+        throw error_already_set();
+    Py_DECREF(result);
+    if (d["self"].is_none())
+        return function();
+#endif
+
+    return override;
+}
+PYBIND11_NAMESPACE_END(detail)
+
+/** \rst
+  Try to retrieve a python method by the provided name from the instance pointed to by the
+  this_ptr.
+
+  :this_ptr: The pointer to the object the overridden method should be retrieved for. This should
+             be the first non-trampoline class encountered in the inheritance chain.
+  :name: The name of the overridden Python method to retrieve.
+  :return: The Python method by this name from the object or an empty function wrapper.
+ \endrst */
+template <class T>
+function get_override(const T *this_ptr, const char *name) {
+    auto *tinfo = detail::get_type_info(typeid(T));
+    return tinfo ? detail::get_type_override(this_ptr, tinfo, name) : function();
+}
+
+#define PYBIND11_OVERRIDE_IMPL(ret_type, cname, name, ...)                                        \
+    do {                                                                                          \
+        pybind11::gil_scoped_acquire gil;                                                         \
+        pybind11::function override                                                               \
+            = pybind11::get_override(static_cast<const cname *>(this), name);                     \
+        if (override) {                                                                           \
+            auto o = override(__VA_ARGS__);                                                       \
+            PYBIND11_WARNING_PUSH                                                                 \
+            PYBIND11_WARNING_DISABLE_MSVC(4127)                                                   \
+            if (pybind11::detail::cast_is_temporary_value_reference<ret_type>::value              \
+                && !pybind11::detail::is_same_ignoring_cvref<ret_type, PyObject *>::value) {      \
+                static pybind11::detail::override_caster_t<ret_type> caster;                      \
+                return pybind11::detail::cast_ref<ret_type>(std::move(o), caster);                \
+            }                                                                                     \
+            PYBIND11_WARNING_POP                                                                  \
+            return pybind11::detail::cast_safe<ret_type>(std::move(o));                           \
+        }                                                                                         \
+    } while (false)
+
+/** \rst
+    Macro to populate the virtual method in the trampoline class. This macro tries to look up a
+    method named 'fn' from the Python side, deals with the :ref:`gil` and necessary argument
+    conversions to call this method and return the appropriate type.
+    See :ref:`overriding_virtuals` for more information. This macro should be used when the method
+    name in C is not the same as the method name in Python. For example with `__str__`.
+
+    .. code-block:: cpp
+
+      std::string toString() override {
+        PYBIND11_OVERRIDE_NAME(
+            std::string, // Return type (ret_type)
+            Animal,      // Parent class (cname)
+            "__str__",   // Name of method in Python (name)
+            toString,    // Name of function in C++ (fn)
+        );
+      }
+\endrst */
+#define PYBIND11_OVERRIDE_NAME(ret_type, cname, name, fn, ...)                                    \
+    do {                                                                                          \
+        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), name, __VA_ARGS__); \
+        return cname::fn(__VA_ARGS__);                                                            \
+    } while (false)
+
+/** \rst
+    Macro for pure virtual functions, this function is identical to
+    :c:macro:`PYBIND11_OVERRIDE_NAME`, except that it throws if no override can be found.
+\endrst */
+#define PYBIND11_OVERRIDE_PURE_NAME(ret_type, cname, name, fn, ...)                               \
+    do {                                                                                          \
+        PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), name, __VA_ARGS__); \
+        pybind11::pybind11_fail(                                                                  \
+            "Tried to call pure virtual function \"" PYBIND11_STRINGIFY(cname) "::" name "\"");   \
+    } while (false)
+
+/** \rst
+    Macro to populate the virtual method in the trampoline class. This macro tries to look up the
+    method from the Python side, deals with the :ref:`gil` and necessary argument conversions to
+    call this method and return the appropriate type. This macro should be used if the method name
+    in C and in Python are identical.
+    See :ref:`overriding_virtuals` for more information.
+
+    .. code-block:: cpp
+
+      class PyAnimal : public Animal {
+      public:
+          // Inherit the constructors
+          using Animal::Animal;
+
+          // Trampoline (need one for each virtual function)
+          std::string go(int n_times) override {
+              PYBIND11_OVERRIDE_PURE(
+                  std::string, // Return type (ret_type)
+                  Animal,      // Parent class (cname)
+                  go,          // Name of function in C++ (must match Python name) (fn)
+                  n_times      // Argument(s) (...)
+              );
+          }
+      };
+\endrst */
+#define PYBIND11_OVERRIDE(ret_type, cname, fn, ...)                                               \
+    PYBIND11_OVERRIDE_NAME(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), #fn, fn, __VA_ARGS__)
+
+/** \rst
+    Macro for pure virtual functions, this function is identical to :c:macro:`PYBIND11_OVERRIDE`,
+    except that it throws if no override can be found.
+\endrst */
+#define PYBIND11_OVERRIDE_PURE(ret_type, cname, fn, ...)                                          \
+    PYBIND11_OVERRIDE_PURE_NAME(                                                                  \
+        PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), #fn, fn, __VA_ARGS__)
+
+// Deprecated versions
+
+PYBIND11_DEPRECATED("get_type_overload has been deprecated")
+inline function
+get_type_overload(const void *this_ptr, const detail::type_info *this_type, const char *name) {
+    return detail::get_type_override(this_ptr, this_type, name);
+}
+
+template <class T>
+inline function get_overload(const T *this_ptr, const char *name) {
+    return get_override(this_ptr, name);
+}
+
+#define PYBIND11_OVERLOAD_INT(ret_type, cname, name, ...)                                         \
+    PYBIND11_OVERRIDE_IMPL(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), name, __VA_ARGS__)
+#define PYBIND11_OVERLOAD_NAME(ret_type, cname, name, fn, ...)                                    \
+    PYBIND11_OVERRIDE_NAME(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), name, fn, __VA_ARGS__)
+#define PYBIND11_OVERLOAD_PURE_NAME(ret_type, cname, name, fn, ...)                               \
+    PYBIND11_OVERRIDE_PURE_NAME(                                                                  \
+        PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), name, fn, __VA_ARGS__);
+#define PYBIND11_OVERLOAD(ret_type, cname, fn, ...)                                               \
+    PYBIND11_OVERRIDE(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), fn, __VA_ARGS__)
+#define PYBIND11_OVERLOAD_PURE(ret_type, cname, fn, ...)                                          \
+    PYBIND11_OVERRIDE_PURE(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), fn, __VA_ARGS__);
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/pytypes.h b/local_pybind11/pybind11/include/pybind11/pytypes.h
new file mode 100644
index 000000000..9c60c94c0
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/pytypes.h
@@ -0,0 +1,2680 @@
+/*
+    pybind11/pytypes.h: Convenience wrapper classes for basic Python types
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "detail/common.h"
+#include "buffer_info.h"
+
+#include <assert.h>
+#include <cstddef>
+#include <exception>
+#include <frameobject.h>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+
+#if defined(PYBIND11_HAS_OPTIONAL)
+#    include <optional>
+#endif
+
+#ifdef PYBIND11_HAS_STRING_VIEW
+#    include <string_view>
+#endif
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+PYBIND11_WARNING_DISABLE_MSVC(4127)
+
+/* A few forward declarations */
+class handle;
+class object;
+class str;
+class iterator;
+class type;
+struct arg;
+struct arg_v;
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+class args_proxy;
+bool isinstance_generic(handle obj, const std::type_info &tp);
+
+template <typename T>
+bool isinstance_native_enum(handle obj, const std::type_info &tp);
+
+// Accessor forward declarations
+template <typename Policy>
+class accessor;
+namespace accessor_policies {
+struct obj_attr;
+struct str_attr;
+struct generic_item;
+struct sequence_item;
+struct list_item;
+struct tuple_item;
+} // namespace accessor_policies
+// PLEASE KEEP handle_type_name SPECIALIZATIONS IN SYNC.
+using obj_attr_accessor = accessor<accessor_policies::obj_attr>;
+using str_attr_accessor = accessor<accessor_policies::str_attr>;
+using item_accessor = accessor<accessor_policies::generic_item>;
+using sequence_accessor = accessor<accessor_policies::sequence_item>;
+using list_accessor = accessor<accessor_policies::list_item>;
+using tuple_accessor = accessor<accessor_policies::tuple_item>;
+
+/// Tag and check to identify a class which implements the Python object API
+class pyobject_tag {};
+template <typename T>
+using is_pyobject = std::is_base_of<pyobject_tag, remove_reference_t<T>>;
+
+/** \rst
+    A mixin class which adds common functions to `handle`, `object` and various accessors.
+    The only requirement for `Derived` is to implement ``PyObject *Derived::ptr() const``.
+\endrst */
+template <typename Derived>
+class object_api : public pyobject_tag {
+    object_api() = default;
+    const Derived &derived() const { return static_cast<const Derived &>(*this); }
+    friend Derived;
+
+public:
+    /** \rst
+        Return an iterator equivalent to calling ``iter()`` in Python. The object
+        must be a collection which supports the iteration protocol.
+    \endrst */
+    iterator begin() const;
+    /// Return a sentinel which ends iteration.
+    iterator end() const;
+
+    /** \rst
+        Return an internal functor to invoke the object's sequence protocol. Casting
+        the returned ``detail::item_accessor`` instance to a `handle` or `object`
+        subclass causes a corresponding call to ``__getitem__``. Assigning a `handle`
+        or `object` subclass causes a call to ``__setitem__``.
+    \endrst */
+    item_accessor operator[](handle key) const;
+    /// See above (the only difference is that the key's reference is stolen)
+    item_accessor operator[](object &&key) const;
+    /// See above (the only difference is that the key is provided as a string literal)
+    item_accessor operator[](const char *key) const;
+
+    /** \rst
+        Return an internal functor to access the object's attributes. Casting the
+        returned ``detail::obj_attr_accessor`` instance to a `handle` or `object`
+        subclass causes a corresponding call to ``getattr``. Assigning a `handle`
+        or `object` subclass causes a call to ``setattr``.
+    \endrst */
+    obj_attr_accessor attr(handle key) const;
+    /// See above (the only difference is that the key's reference is stolen)
+    obj_attr_accessor attr(object &&key) const;
+    /// See above (the only difference is that the key is provided as a string literal)
+    str_attr_accessor attr(const char *key) const;
+
+    /** \rst
+         Similar to the above attr functions with the difference that the templated Type
+         is used to set the `__annotations__` dict value to the corresponding key. Worth noting
+         that attr_with_type_hint is implemented in cast.h.
+    \endrst */
+    template <typename T>
+    obj_attr_accessor attr_with_type_hint(handle key) const;
+    /// See above (the only difference is that the key is provided as a string literal)
+    template <typename T>
+    str_attr_accessor attr_with_type_hint(const char *key) const;
+
+    /** \rst
+        Matches * unpacking in Python, e.g. to unpack arguments out of a ``tuple``
+        or ``list`` for a function call. Applying another * to the result yields
+        ** unpacking, e.g. to unpack a dict as function keyword arguments.
+        See :ref:`calling_python_functions`.
+    \endrst */
+    args_proxy operator*() const;
+
+    /// Check if the given item is contained within this object, i.e. ``item in obj``.
+    template <typename T>
+    bool contains(T &&item) const;
+
+    /** \rst
+        Assuming the Python object is a function or implements the ``__call__``
+        protocol, ``operator()`` invokes the underlying function, passing an
+        arbitrary set of parameters. The result is returned as a `object` and
+        may need to be converted back into a Python object using `handle::cast()`.
+
+        When some of the arguments cannot be converted to Python objects, the
+        function will throw a `cast_error` exception. When the Python function
+        call fails, a `error_already_set` exception is thrown.
+    \endrst */
+    template <return_value_policy policy = return_value_policy::automatic_reference,
+              typename... Args>
+    object operator()(Args &&...args) const;
+    template <return_value_policy policy = return_value_policy::automatic_reference,
+              typename... Args>
+    PYBIND11_DEPRECATED("call(...) was deprecated in favor of operator()(...)")
+    object call(Args &&...args) const;
+
+    /// Equivalent to ``obj is other`` in Python.
+    bool is(object_api const &other) const { return derived().ptr() == other.derived().ptr(); }
+    /// Equivalent to ``obj is None`` in Python.
+    bool is_none() const { return derived().ptr() == Py_None; }
+    /// Equivalent to obj == other in Python
+    bool equal(object_api const &other) const { return rich_compare(other, Py_EQ); }
+    bool not_equal(object_api const &other) const { return rich_compare(other, Py_NE); }
+    bool operator<(object_api const &other) const { return rich_compare(other, Py_LT); }
+    bool operator<=(object_api const &other) const { return rich_compare(other, Py_LE); }
+    bool operator>(object_api const &other) const { return rich_compare(other, Py_GT); }
+    bool operator>=(object_api const &other) const { return rich_compare(other, Py_GE); }
+
+    object operator-() const;
+    object operator~() const;
+    object operator+(object_api const &other) const;
+    object operator+=(object_api const &other);
+    object operator-(object_api const &other) const;
+    object operator-=(object_api const &other);
+    object operator*(object_api const &other) const;
+    object operator*=(object_api const &other);
+    object operator/(object_api const &other) const;
+    object operator/=(object_api const &other);
+    object operator|(object_api const &other) const;
+    object operator|=(object_api const &other);
+    object operator&(object_api const &other) const;
+    object operator&=(object_api const &other);
+    object operator^(object_api const &other) const;
+    object operator^=(object_api const &other);
+    object operator<<(object_api const &other) const;
+    object operator<<=(object_api const &other);
+    object operator>>(object_api const &other) const;
+    object operator>>=(object_api const &other);
+
+    PYBIND11_DEPRECATED("Use py::str(obj) instead")
+    pybind11::str str() const;
+
+    /// Get or set the object's docstring, i.e. ``obj.__doc__``.
+    str_attr_accessor doc() const;
+
+    /// Get or set the object's annotations, i.e. ``obj.__annotations__``.
+    object annotations() const;
+
+    /// Return the object's current reference count
+    ssize_t ref_count() const {
+#ifdef PYPY_VERSION
+        // PyPy uses the top few bits for REFCNT_FROM_PYPY & REFCNT_FROM_PYPY_LIGHT
+        // Following pybind11 2.12.1 and older behavior and removing this part
+        return static_cast<ssize_t>(static_cast<int>(Py_REFCNT(derived().ptr())));
+#else
+        return Py_REFCNT(derived().ptr());
+#endif
+    }
+
+    PYBIND11_DEPRECATED("Call py::type::handle_of(h) or py::type::of(h) instead of h.get_type()")
+    handle get_type() const;
+
+private:
+    bool rich_compare(object_api const &other, int value) const;
+};
+
+template <typename T>
+using is_pyobj_ptr_or_nullptr_t = detail::any_of<std::is_same<T, PyObject *>,
+                                                 std::is_same<T, PyObject *const>,
+                                                 std::is_same<T, std::nullptr_t>>;
+
+PYBIND11_NAMESPACE_END(detail)
+
+#if !defined(PYBIND11_HANDLE_REF_DEBUG) && !defined(NDEBUG)
+#    define PYBIND11_HANDLE_REF_DEBUG
+#endif
+
+/** \rst
+    Holds a reference to a Python object (no reference counting)
+
+    The `handle` class is a thin wrapper around an arbitrary Python object (i.e. a
+    ``PyObject *`` in Python's C API). It does not perform any automatic reference
+    counting and merely provides a basic C++ interface to various Python API functions.
+
+    .. seealso::
+        The `object` class inherits from `handle` and adds automatic reference
+        counting features.
+\endrst */
+class handle : public detail::object_api<handle> {
+public:
+    /// The default constructor creates a handle with a ``nullptr``-valued pointer
+    handle() = default;
+
+    /// Enable implicit conversion from ``PyObject *`` and ``nullptr``.
+    /// Not using ``handle(PyObject *ptr)`` to avoid implicit conversion from ``0``.
+    template <typename T,
+              detail::enable_if_t<detail::is_pyobj_ptr_or_nullptr_t<T>::value, int> = 0>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    handle(T ptr) : m_ptr(ptr) {}
+
+    /// Enable implicit conversion through ``T::operator PyObject *()``.
+    template <
+        typename T,
+        detail::enable_if_t<detail::all_of<detail::none_of<std::is_base_of<handle, T>,
+                                                           detail::is_pyobj_ptr_or_nullptr_t<T>>,
+                                           std::is_convertible<T, PyObject *>>::value,
+                            int>
+        = 0>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    handle(T &obj) : m_ptr(obj) {}
+
+    /// Return the underlying ``PyObject *`` pointer
+    PyObject *ptr() const { return m_ptr; }
+    PyObject *&ptr() { return m_ptr; }
+
+    /** \rst
+        Manually increase the reference count of the Python object. Usually, it is
+        preferable to use the `object` class which derives from `handle` and calls
+        this function automatically. Returns a reference to itself.
+    \endrst */
+    const handle &inc_ref() const & {
+#ifdef PYBIND11_HANDLE_REF_DEBUG
+        inc_ref_counter(1);
+#endif
+#ifdef PYBIND11_ASSERT_GIL_HELD_INCREF_DECREF
+        if (m_ptr != nullptr && PyGILState_Check() == 0) {
+            throw_gilstate_error("pybind11::handle::inc_ref()");
+        }
+#endif
+        Py_XINCREF(m_ptr);
+        return *this;
+    }
+
+    /** \rst
+        Manually decrease the reference count of the Python object. Usually, it is
+        preferable to use the `object` class which derives from `handle` and calls
+        this function automatically. Returns a reference to itself.
+    \endrst */
+    const handle &dec_ref() const & {
+#ifdef PYBIND11_ASSERT_GIL_HELD_INCREF_DECREF
+        if (m_ptr != nullptr && PyGILState_Check() == 0) {
+            throw_gilstate_error("pybind11::handle::dec_ref()");
+        }
+#endif
+        Py_XDECREF(m_ptr);
+        return *this;
+    }
+
+    /** \rst
+        Attempt to cast the Python object into the given C++ type. A `cast_error`
+        will be throw upon failure.
+    \endrst */
+    template <typename T>
+    T cast() const;
+    /// Return ``true`` when the `handle` wraps a valid Python object
+    explicit operator bool() const { return m_ptr != nullptr; }
+    /** \rst
+        Deprecated: Check that the underlying pointers are the same.
+        Equivalent to ``obj1 is obj2`` in Python.
+    \endrst */
+    PYBIND11_DEPRECATED("Use obj1.is(obj2) instead")
+    bool operator==(const handle &h) const { return m_ptr == h.m_ptr; }
+    PYBIND11_DEPRECATED("Use !obj1.is(obj2) instead")
+    bool operator!=(const handle &h) const { return m_ptr != h.m_ptr; }
+    PYBIND11_DEPRECATED("Use handle::operator bool() instead")
+    bool check() const { return m_ptr != nullptr; }
+
+protected:
+    PyObject *m_ptr = nullptr;
+
+private:
+#ifdef PYBIND11_ASSERT_GIL_HELD_INCREF_DECREF
+    void throw_gilstate_error(const std::string &function_name) const {
+        fprintf(
+            stderr,
+            "%s is being called while the GIL is either not held or invalid. Please see "
+            "https://pybind11.readthedocs.io/en/stable/advanced/"
+            "misc.html#common-sources-of-global-interpreter-lock-errors for debugging advice.\n"
+            "If you are convinced there is no bug in your code, you can #define "
+            "PYBIND11_NO_ASSERT_GIL_HELD_INCREF_DECREF "
+            "to disable this check. In that case you have to ensure this #define is consistently "
+            "used for all translation units linked into a given pybind11 extension, otherwise "
+            "there will be ODR violations.",
+            function_name.c_str());
+        if (Py_TYPE(m_ptr)->tp_name != nullptr) {
+            fprintf(stderr,
+                    " The failing %s call was triggered on a %s object.",
+                    function_name.c_str(),
+                    Py_TYPE(m_ptr)->tp_name);
+        }
+        fprintf(stderr, "\n");
+        fflush(stderr);
+        throw std::runtime_error(function_name + " PyGILState_Check() failure.");
+    }
+#endif
+
+#ifdef PYBIND11_HANDLE_REF_DEBUG
+    static std::size_t inc_ref_counter(std::size_t add) {
+        thread_local std::size_t counter = 0;
+        counter += add;
+        return counter;
+    }
+
+public:
+    static std::size_t inc_ref_counter() { return inc_ref_counter(0); }
+#endif
+};
+
+inline void set_error(const handle &type, const char *message) {
+    PyErr_SetString(type.ptr(), message);
+}
+
+inline void set_error(const handle &type, const handle &value) {
+    PyErr_SetObject(type.ptr(), value.ptr());
+}
+
+/** \rst
+    Holds a reference to a Python object (with reference counting)
+
+    Like `handle`, the `object` class is a thin wrapper around an arbitrary Python
+    object (i.e. a ``PyObject *`` in Python's C API). In contrast to `handle`, it
+    optionally increases the object's reference count upon construction, and it
+    *always* decreases the reference count when the `object` instance goes out of
+    scope and is destructed. When using `object` instances consistently, it is much
+    easier to get reference counting right at the first attempt.
+\endrst */
+class object : public handle {
+public:
+    object() = default;
+    PYBIND11_DEPRECATED("Use reinterpret_borrow<object>() or reinterpret_steal<object>()")
+    object(handle h, bool is_borrowed) : handle(h) {
+        if (is_borrowed) {
+            inc_ref();
+        }
+    }
+    /// Copy constructor; always increases the reference count
+    object(const object &o) : handle(o) { inc_ref(); }
+    /// Move constructor; steals the object from ``other`` and preserves its reference count
+    object(object &&other) noexcept : handle(other) { other.m_ptr = nullptr; }
+    /// Destructor; automatically calls `handle::dec_ref()`
+    ~object() { dec_ref(); }
+
+    /** \rst
+        Resets the internal pointer to ``nullptr`` without decreasing the
+        object's reference count. The function returns a raw handle to the original
+        Python object.
+    \endrst */
+    handle release() {
+        PyObject *tmp = m_ptr;
+        m_ptr = nullptr;
+        return handle(tmp);
+    }
+
+    object &operator=(const object &other) {
+        // Skip inc_ref and dec_ref if both objects are the same
+        if (!this->is(other)) {
+            other.inc_ref();
+            // Use temporary variable to ensure `*this` remains valid while
+            // `Py_XDECREF` executes, in case `*this` is accessible from Python.
+            handle temp(m_ptr);
+            m_ptr = other.m_ptr;
+            temp.dec_ref();
+        }
+        return *this;
+    }
+
+    object &operator=(object &&other) noexcept {
+        if (this != &other) {
+            handle temp(m_ptr);
+            m_ptr = other.m_ptr;
+            other.m_ptr = nullptr;
+            temp.dec_ref();
+        }
+        return *this;
+    }
+
+#define PYBIND11_INPLACE_OP(iop)                                                                  \
+    object iop(object_api const &other) { return operator=(handle::iop(other)); }
+
+    PYBIND11_INPLACE_OP(operator+=)
+    PYBIND11_INPLACE_OP(operator-=)
+    PYBIND11_INPLACE_OP(operator*=)
+    PYBIND11_INPLACE_OP(operator/=)
+    PYBIND11_INPLACE_OP(operator|=)
+    PYBIND11_INPLACE_OP(operator&=)
+    PYBIND11_INPLACE_OP(operator^=)
+    PYBIND11_INPLACE_OP(operator<<=)
+    PYBIND11_INPLACE_OP(operator>>=)
+#undef PYBIND11_INPLACE_OP
+
+    // Calling cast() on an object lvalue just copies (via handle::cast)
+    template <typename T>
+    T cast() const &;
+    // Calling on an object rvalue does a move, if needed and/or possible
+    template <typename T>
+    T cast() &&;
+
+protected:
+    // Tags for choosing constructors from raw PyObject *
+    struct borrowed_t {};
+    struct stolen_t {};
+
+    /// @cond BROKEN
+    template <typename T>
+    friend T reinterpret_borrow(handle);
+    template <typename T>
+    friend T reinterpret_steal(handle);
+    /// @endcond
+
+public:
+    // Only accessible from derived classes and the reinterpret_* functions
+    object(handle h, borrowed_t) : handle(h) { inc_ref(); }
+    object(handle h, stolen_t) : handle(h) {}
+};
+
+/** \rst
+    Declare that a `handle` or ``PyObject *`` is a certain type and borrow the reference.
+    The target type ``T`` must be `object` or one of its derived classes. The function
+    doesn't do any conversions or checks. It's up to the user to make sure that the
+    target type is correct.
+
+    .. code-block:: cpp
+
+        PyObject *p = PyList_GetItem(obj, index);
+        py::object o = reinterpret_borrow<py::object>(p);
+        // or
+        py::tuple t = reinterpret_borrow<py::tuple>(p); // <-- `p` must be already be a `tuple`
+\endrst */
+template <typename T>
+T reinterpret_borrow(handle h) {
+    return {h, object::borrowed_t{}};
+}
+
+/** \rst
+    Like `reinterpret_borrow`, but steals the reference.
+
+     .. code-block:: cpp
+
+        PyObject *p = PyObject_Str(obj);
+        py::str s = reinterpret_steal<py::str>(p); // <-- `p` must be already be a `str`
+\endrst */
+template <typename T>
+T reinterpret_steal(handle h) {
+    return {h, object::stolen_t{}};
+}
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+// Equivalent to obj.__class__.__name__ (or obj.__name__ if obj is a class).
+inline const char *obj_class_name(PyObject *obj) {
+    if (PyType_Check(obj)) {
+        return reinterpret_cast<PyTypeObject *>(obj)->tp_name;
+    }
+    return Py_TYPE(obj)->tp_name;
+}
+
+std::string error_string();
+
+// The code in this struct is very unusual, to minimize the chances of
+// masking bugs (elsewhere) by errors during the error handling (here).
+// This is meant to be a lifeline for troubleshooting long-running processes
+// that crash under conditions that are virtually impossible to reproduce.
+// Low-level implementation alternatives are preferred to higher-level ones
+// that might raise cascading exceptions. Last-ditch-kind-of attempts are made
+// to report as much of the original error as possible, even if there are
+// secondary issues obtaining some of the details.
+struct error_fetch_and_normalize {
+    // This comment only applies to Python <= 3.11:
+    //     Immediate normalization is long-established behavior (starting with
+    //     https://github.com/pybind/pybind11/commit/135ba8deafb8bf64a15b24d1513899eb600e2011
+    //     from Sep 2016) and safest. Normalization could be deferred, but this could mask
+    //     errors elsewhere, the performance gain is very minor in typical situations
+    //     (usually the dominant bottleneck is EH unwinding), and the implementation here
+    //     would be more complex.
+    // Starting with Python 3.12, PyErr_Fetch() normalizes exceptions immediately.
+    // Any errors during normalization are tracked under __notes__.
+    explicit error_fetch_and_normalize(const char *called) {
+        PyErr_Fetch(&m_type.ptr(), &m_value.ptr(), &m_trace.ptr());
+        if (!m_type) {
+            pybind11_fail("Internal error: " + std::string(called)
+                          + " called while "
+                            "Python error indicator not set.");
+        }
+        const char *exc_type_name_orig = detail::obj_class_name(m_type.ptr());
+        if (exc_type_name_orig == nullptr) {
+            pybind11_fail("Internal error: " + std::string(called)
+                          + " failed to obtain the name "
+                            "of the original active exception type.");
+        }
+        m_lazy_error_string = exc_type_name_orig;
+#if PY_VERSION_HEX >= 0x030C0000
+        // The presence of __notes__ is likely due to exception normalization
+        // errors, although that is not necessarily true, therefore insert a
+        // hint only:
+        if (PyObject_HasAttrString(m_value.ptr(), "__notes__")) {
+            m_lazy_error_string += "[WITH __notes__]";
+        }
+#else
+        // PyErr_NormalizeException() may change the exception type if there are cascading
+        // failures. This can potentially be extremely confusing.
+        PyErr_NormalizeException(&m_type.ptr(), &m_value.ptr(), &m_trace.ptr());
+        if (m_type.ptr() == nullptr) {
+            pybind11_fail("Internal error: " + std::string(called)
+                          + " failed to normalize the "
+                            "active exception.");
+        }
+        const char *exc_type_name_norm = detail::obj_class_name(m_type.ptr());
+        if (exc_type_name_norm == nullptr) {
+            pybind11_fail("Internal error: " + std::string(called)
+                          + " failed to obtain the name "
+                            "of the normalized active exception type.");
+        }
+        if (exc_type_name_norm != m_lazy_error_string) {
+            std::string msg = std::string(called)
+                              + ": MISMATCH of original and normalized "
+                                "active exception types: ";
+            msg += "ORIGINAL ";
+            msg += m_lazy_error_string;
+            msg += " REPLACED BY ";
+            msg += exc_type_name_norm;
+            msg += ": " + format_value_and_trace();
+            pybind11_fail(msg);
+        }
+#endif
+    }
+
+    error_fetch_and_normalize(const error_fetch_and_normalize &) = delete;
+    error_fetch_and_normalize(error_fetch_and_normalize &&) = delete;
+
+    std::string format_value_and_trace() const {
+        std::string result;
+        std::string message_error_string;
+        if (m_value) {
+            auto value_str = reinterpret_steal<object>(PyObject_Str(m_value.ptr()));
+            constexpr const char *message_unavailable_exc
+                = "<MESSAGE UNAVAILABLE DUE TO ANOTHER EXCEPTION>";
+            if (!value_str) {
+                message_error_string = detail::error_string();
+                result = message_unavailable_exc;
+            } else {
+                // Not using `value_str.cast<std::string>()`, to not potentially throw a secondary
+                // error_already_set that will then result in process termination (#4288).
+                auto value_bytes = reinterpret_steal<object>(
+                    PyUnicode_AsEncodedString(value_str.ptr(), "utf-8", "backslashreplace"));
+                if (!value_bytes) {
+                    message_error_string = detail::error_string();
+                    result = message_unavailable_exc;
+                } else {
+                    char *buffer = nullptr;
+                    Py_ssize_t length = 0;
+                    if (PyBytes_AsStringAndSize(value_bytes.ptr(), &buffer, &length) == -1) {
+                        message_error_string = detail::error_string();
+                        result = message_unavailable_exc;
+                    } else {
+                        result = std::string(buffer, static_cast<std::size_t>(length));
+                    }
+                }
+            }
+#if PY_VERSION_HEX >= 0x030B0000
+            auto notes
+                = reinterpret_steal<object>(PyObject_GetAttrString(m_value.ptr(), "__notes__"));
+            if (!notes) {
+                PyErr_Clear(); // No notes is good news.
+            } else {
+                auto len_notes = PyList_Size(notes.ptr());
+                if (len_notes < 0) {
+                    result += "\nFAILURE obtaining len(__notes__): " + detail::error_string();
+                } else {
+                    result += "\n__notes__ (len=" + std::to_string(len_notes) + "):";
+                    for (ssize_t i = 0; i < len_notes; i++) {
+                        PyObject *note = PyList_GET_ITEM(notes.ptr(), i);
+                        auto note_bytes = reinterpret_steal<object>(
+                            PyUnicode_AsEncodedString(note, "utf-8", "backslashreplace"));
+                        if (!note_bytes) {
+                            result += "\nFAILURE obtaining __notes__[" + std::to_string(i)
+                                      + "]: " + detail::error_string();
+                        } else {
+                            char *buffer = nullptr;
+                            Py_ssize_t length = 0;
+                            if (PyBytes_AsStringAndSize(note_bytes.ptr(), &buffer, &length)
+                                == -1) {
+                                result += "\nFAILURE formatting __notes__[" + std::to_string(i)
+                                          + "]: " + detail::error_string();
+                            } else {
+                                result += '\n';
+                                result += std::string(buffer, static_cast<std::size_t>(length));
+                            }
+                        }
+                    }
+                }
+            }
+#endif
+        } else {
+            result = "<MESSAGE UNAVAILABLE>";
+        }
+        if (result.empty()) {
+            result = "<EMPTY MESSAGE>";
+        }
+
+        bool have_trace = false;
+        if (m_trace) {
+#if !defined(PYPY_VERSION) && !defined(GRAALVM_PYTHON)
+            auto *tb = reinterpret_cast<PyTracebackObject *>(m_trace.ptr());
+
+            // Get the deepest trace possible.
+            while (tb->tb_next) {
+                tb = tb->tb_next;
+            }
+
+            PyFrameObject *frame = tb->tb_frame;
+            Py_XINCREF(frame);
+            result += "\n\nAt:\n";
+            while (frame) {
+#    if PY_VERSION_HEX >= 0x030900B1
+                PyCodeObject *f_code = PyFrame_GetCode(frame);
+#    else
+                PyCodeObject *f_code = frame->f_code;
+                Py_INCREF(f_code);
+#    endif
+                int lineno = PyFrame_GetLineNumber(frame);
+                result += "  ";
+                result += handle(f_code->co_filename).cast<std::string>();
+                result += '(';
+                result += std::to_string(lineno);
+                result += "): ";
+                result += handle(f_code->co_name).cast<std::string>();
+                result += '\n';
+                Py_DECREF(f_code);
+#    if PY_VERSION_HEX >= 0x030900B1
+                auto *b_frame = PyFrame_GetBack(frame);
+#    else
+                auto *b_frame = frame->f_back;
+                Py_XINCREF(b_frame);
+#    endif
+                Py_DECREF(frame);
+                frame = b_frame;
+            }
+
+            have_trace = true;
+#endif //! defined(PYPY_VERSION)
+        }
+
+        if (!message_error_string.empty()) {
+            if (!have_trace) {
+                result += '\n';
+            }
+            result += "\nMESSAGE UNAVAILABLE DUE TO EXCEPTION: " + message_error_string;
+        }
+
+        return result;
+    }
+
+    std::string const &error_string() const {
+        if (!m_lazy_error_string_completed) {
+            m_lazy_error_string += ": " + format_value_and_trace();
+            m_lazy_error_string_completed = true;
+        }
+        return m_lazy_error_string;
+    }
+
+    void restore() {
+        if (m_restore_called) {
+            pybind11_fail("Internal error: pybind11::detail::error_fetch_and_normalize::restore() "
+                          "called a second time. ORIGINAL ERROR: "
+                          + error_string());
+        }
+        PyErr_Restore(m_type.inc_ref().ptr(), m_value.inc_ref().ptr(), m_trace.inc_ref().ptr());
+        m_restore_called = true;
+    }
+
+    bool matches(handle exc) const {
+        return (PyErr_GivenExceptionMatches(m_type.ptr(), exc.ptr()) != 0);
+    }
+
+    // Not protecting these for simplicity.
+    object m_type, m_value, m_trace;
+
+private:
+    // Only protecting invariants.
+    mutable std::string m_lazy_error_string;
+    mutable bool m_lazy_error_string_completed = false;
+    mutable bool m_restore_called = false;
+};
+
+inline std::string error_string() {
+    return error_fetch_and_normalize("pybind11::detail::error_string").error_string();
+}
+
+PYBIND11_NAMESPACE_END(detail)
+
+/// Fetch and hold an error which was already set in Python.  An instance of this is typically
+/// thrown to propagate python-side errors back through C++ which can either be caught manually or
+/// else falls back to the function dispatcher (which then raises the captured error back to
+/// python).
+class PYBIND11_EXPORT_EXCEPTION error_already_set : public std::exception {
+public:
+    /// Fetches the current Python exception (using PyErr_Fetch()), which will clear the
+    /// current Python error indicator.
+    error_already_set()
+        : m_fetched_error{new detail::error_fetch_and_normalize("pybind11::error_already_set"),
+                          m_fetched_error_deleter} {}
+
+    /// The what() result is built lazily on demand.
+    /// WARNING: This member function needs to acquire the Python GIL. This can lead to
+    ///          crashes (undefined behavior) if the Python interpreter is finalizing.
+    const char *what() const noexcept override;
+
+    /// Restores the currently-held Python error (which will clear the Python error indicator first
+    /// if already set).
+    /// NOTE: This member function will always restore the normalized exception, which may or may
+    ///       not be the original Python exception.
+    /// WARNING: The GIL must be held when this member function is called!
+    void restore() { m_fetched_error->restore(); }
+
+    /// If it is impossible to raise the currently-held error, such as in a destructor, we can
+    /// write it out using Python's unraisable hook (`sys.unraisablehook`). The error context
+    /// should be some object whose `repr()` helps identify the location of the error. Python
+    /// already knows the type and value of the error, so there is no need to repeat that.
+    void discard_as_unraisable(object err_context) {
+        restore();
+        PyErr_WriteUnraisable(err_context.ptr());
+    }
+    /// An alternate version of `discard_as_unraisable()`, where a string provides information on
+    /// the location of the error. For example, `__func__` could be helpful.
+    /// WARNING: The GIL must be held when this member function is called!
+    void discard_as_unraisable(const char *err_context) {
+        discard_as_unraisable(reinterpret_steal<object>(PYBIND11_FROM_STRING(err_context)));
+    }
+
+    // Does nothing; provided for backwards compatibility.
+    PYBIND11_DEPRECATED("Use of error_already_set.clear() is deprecated")
+    void clear() {}
+
+    /// Check if the currently trapped error type matches the given Python exception class (or a
+    /// subclass thereof).  May also be passed a tuple to search for any exception class matches in
+    /// the given tuple.
+    bool matches(handle exc) const { return m_fetched_error->matches(exc); }
+
+    const object &type() const { return m_fetched_error->m_type; }
+    const object &value() const { return m_fetched_error->m_value; }
+    const object &trace() const { return m_fetched_error->m_trace; }
+
+private:
+    std::shared_ptr<detail::error_fetch_and_normalize> m_fetched_error;
+
+    /// WARNING: This custom deleter needs to acquire the Python GIL. This can lead to
+    ///          crashes (undefined behavior) if the Python interpreter is finalizing.
+    static void m_fetched_error_deleter(detail::error_fetch_and_normalize *raw_ptr);
+};
+
+/// Replaces the current Python error indicator with the chosen error, performing a
+/// 'raise from' to indicate that the chosen error was caused by the original error.
+inline void raise_from(PyObject *type, const char *message) {
+    // Based on _PyErr_FormatVFromCause:
+    // https://github.com/python/cpython/blob/467ab194fc6189d9f7310c89937c51abeac56839/Python/errors.c#L405
+    // See https://github.com/pybind/pybind11/pull/2112 for details.
+    PyObject *exc = nullptr, *val = nullptr, *val2 = nullptr, *tb = nullptr;
+
+    assert(PyErr_Occurred());
+    PyErr_Fetch(&exc, &val, &tb);
+    PyErr_NormalizeException(&exc, &val, &tb);
+    if (tb != nullptr) {
+        PyException_SetTraceback(val, tb);
+        Py_DECREF(tb);
+    }
+    Py_DECREF(exc);
+    assert(!PyErr_Occurred());
+
+    PyErr_SetString(type, message);
+
+    PyErr_Fetch(&exc, &val2, &tb);
+    PyErr_NormalizeException(&exc, &val2, &tb);
+    Py_INCREF(val);
+    PyException_SetCause(val2, val);
+    PyException_SetContext(val2, val);
+    PyErr_Restore(exc, val2, tb);
+}
+
+/// Sets the current Python error indicator with the chosen error, performing a 'raise from'
+/// from the error contained in error_already_set to indicate that the chosen error was
+/// caused by the original error.
+inline void raise_from(error_already_set &err, PyObject *type, const char *message) {
+    err.restore();
+    raise_from(type, message);
+}
+
+/** \defgroup python_builtins const_name
+    Unless stated otherwise, the following C++ functions behave the same
+    as their Python counterparts.
+ */
+
+/** \ingroup python_builtins
+    \rst
+    Return true if ``obj`` is an instance of ``T``. Type ``T`` must be a subclass of
+    `object` or a class which was exposed to Python as ``py::class_<T>``.
+\endrst */
+template <typename T, detail::enable_if_t<std::is_base_of<object, T>::value, int> = 0>
+bool isinstance(handle obj) {
+    return T::check_(obj);
+}
+
+template <typename T, detail::enable_if_t<!std::is_base_of<object, T>::value, int> = 0>
+bool isinstance(handle obj) {
+    return detail::isinstance_native_enum<T>(obj, typeid(T))
+           || detail::isinstance_generic(obj, typeid(T));
+}
+
+template <>
+inline bool isinstance<handle>(handle) = delete;
+template <>
+inline bool isinstance<object>(handle obj) {
+    return obj.ptr() != nullptr;
+}
+
+/// \ingroup python_builtins
+/// Return true if ``obj`` is an instance of the ``type``.
+inline bool isinstance(handle obj, handle type) {
+    const auto result = PyObject_IsInstance(obj.ptr(), type.ptr());
+    if (result == -1) {
+        throw error_already_set();
+    }
+    return result != 0;
+}
+
+/// \addtogroup python_builtins
+/// @{
+inline bool hasattr(handle obj, handle name) {
+    return PyObject_HasAttr(obj.ptr(), name.ptr()) == 1;
+}
+
+inline bool hasattr(handle obj, const char *name) {
+    return PyObject_HasAttrString(obj.ptr(), name) == 1;
+}
+
+inline void delattr(handle obj, handle name) {
+    if (PyObject_DelAttr(obj.ptr(), name.ptr()) != 0) {
+        throw error_already_set();
+    }
+}
+
+inline void delattr(handle obj, const char *name) {
+    if (PyObject_DelAttrString(obj.ptr(), name) != 0) {
+        throw error_already_set();
+    }
+}
+
+inline object getattr(handle obj, handle name) {
+    PyObject *result = PyObject_GetAttr(obj.ptr(), name.ptr());
+    if (!result) {
+        throw error_already_set();
+    }
+    return reinterpret_steal<object>(result);
+}
+
+inline object getattr(handle obj, const char *name) {
+    PyObject *result = PyObject_GetAttrString(obj.ptr(), name);
+    if (!result) {
+        throw error_already_set();
+    }
+    return reinterpret_steal<object>(result);
+}
+
+inline object getattr(handle obj, handle name, handle default_) {
+    if (PyObject *result = PyObject_GetAttr(obj.ptr(), name.ptr())) {
+        return reinterpret_steal<object>(result);
+    }
+    PyErr_Clear();
+    return reinterpret_borrow<object>(default_);
+}
+
+inline object getattr(handle obj, const char *name, handle default_) {
+    if (PyObject *result = PyObject_GetAttrString(obj.ptr(), name)) {
+        return reinterpret_steal<object>(result);
+    }
+    PyErr_Clear();
+    return reinterpret_borrow<object>(default_);
+}
+
+inline void setattr(handle obj, handle name, handle value) {
+    if (PyObject_SetAttr(obj.ptr(), name.ptr(), value.ptr()) != 0) {
+        throw error_already_set();
+    }
+}
+
+inline void setattr(handle obj, const char *name, handle value) {
+    if (PyObject_SetAttrString(obj.ptr(), name, value.ptr()) != 0) {
+        throw error_already_set();
+    }
+}
+
+inline ssize_t hash(handle obj) {
+    auto h = PyObject_Hash(obj.ptr());
+    if (h == -1) {
+        throw error_already_set();
+    }
+    return h;
+}
+
+/// @} python_builtins
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+inline handle get_function(handle value) {
+    if (value) {
+        if (PyInstanceMethod_Check(value.ptr())) {
+            value = PyInstanceMethod_GET_FUNCTION(value.ptr());
+        } else if (PyMethod_Check(value.ptr())) {
+            value = PyMethod_GET_FUNCTION(value.ptr());
+        }
+    }
+    return value;
+}
+
+// Reimplementation of python's dict helper functions to ensure that exceptions
+// aren't swallowed (see #2862)
+
+// copied from cpython _PyDict_GetItemStringWithError
+inline PyObject *dict_getitemstring(PyObject *v, const char *key) {
+    PyObject *kv = nullptr, *rv = nullptr;
+    kv = PyUnicode_FromString(key);
+    if (kv == nullptr) {
+        throw error_already_set();
+    }
+
+    rv = PyDict_GetItemWithError(v, kv);
+    Py_DECREF(kv);
+    if (rv == nullptr && PyErr_Occurred()) {
+        throw error_already_set();
+    }
+    return rv;
+}
+
+inline PyObject *dict_getitem(PyObject *v, PyObject *key) {
+    PyObject *rv = PyDict_GetItemWithError(v, key);
+    if (rv == nullptr && PyErr_Occurred()) {
+        throw error_already_set();
+    }
+    return rv;
+}
+
+inline PyObject *dict_getitemstringref(PyObject *v, const char *key) {
+#if PY_VERSION_HEX >= 0x030D0000
+    PyObject *rv;
+    if (PyDict_GetItemStringRef(v, key, &rv) < 0) {
+        throw error_already_set();
+    }
+    return rv;
+#else
+    PyObject *rv = dict_getitemstring(v, key);
+    if (rv == nullptr && PyErr_Occurred()) {
+        throw error_already_set();
+    }
+    Py_XINCREF(rv);
+    return rv;
+#endif
+}
+
+// Helper aliases/functions to support implicit casting of values given to python
+// accessors/methods. When given a pyobject, this simply returns the pyobject as-is; for other C++
+// type, the value goes through pybind11::cast(obj) to convert it to an `object`.
+template <typename T, enable_if_t<is_pyobject<T>::value, int> = 0>
+auto object_or_cast(T &&o) -> decltype(std::forward<T>(o)) {
+    return std::forward<T>(o);
+}
+// The following casting version is implemented in cast.h:
+template <typename T, enable_if_t<!is_pyobject<T>::value, int> = 0>
+object object_or_cast(T &&o);
+// Match a PyObject*, which we want to convert directly to handle via its converting constructor
+inline handle object_or_cast(PyObject *ptr) { return ptr; }
+
+PYBIND11_WARNING_PUSH
+PYBIND11_WARNING_DISABLE_MSVC(4522) // warning C4522: multiple assignment operators specified
+template <typename Policy>
+class accessor : public object_api<accessor<Policy>> {
+    using key_type = typename Policy::key_type;
+
+public:
+    accessor(handle obj, key_type key) : obj(obj), key(std::move(key)) {}
+    accessor(const accessor &) = default;
+    accessor(accessor &&) noexcept = default;
+
+    // accessor overload required to override default assignment operator (templates are not
+    // allowed to replace default compiler-generated assignments).
+    void operator=(const accessor &a) && { std::move(*this).operator=(handle(a)); }
+    void operator=(const accessor &a) & { operator=(handle(a)); }
+
+    template <typename T>
+    void operator=(T &&value) && {
+        Policy::set(obj, key, object_or_cast(std::forward<T>(value)));
+    }
+    template <typename T>
+    void operator=(T &&value) & {
+        get_cache() = ensure_object(object_or_cast(std::forward<T>(value)));
+    }
+
+    template <typename T = Policy>
+    PYBIND11_DEPRECATED(
+        "Use of obj.attr(...) as bool is deprecated in favor of pybind11::hasattr(obj, ...)")
+    explicit
+    operator enable_if_t<std::is_same<T, accessor_policies::str_attr>::value
+                             || std::is_same<T, accessor_policies::obj_attr>::value,
+                         bool>() const {
+        return hasattr(obj, key);
+    }
+    template <typename T = Policy>
+    PYBIND11_DEPRECATED("Use of obj[key] as bool is deprecated in favor of obj.contains(key)")
+    explicit
+    operator enable_if_t<std::is_same<T, accessor_policies::generic_item>::value, bool>() const {
+        return obj.contains(key);
+    }
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator object() const { return get_cache(); }
+    PyObject *ptr() const { return get_cache().ptr(); }
+    template <typename T>
+    T cast() const {
+        return get_cache().template cast<T>();
+    }
+
+private:
+    static object ensure_object(object &&o) { return std::move(o); }
+    static object ensure_object(handle h) { return reinterpret_borrow<object>(h); }
+
+    object &get_cache() const {
+        if (!cache) {
+            cache = Policy::get(obj, key);
+        }
+        return cache;
+    }
+
+private:
+    handle obj;
+    key_type key;
+    mutable object cache;
+};
+PYBIND11_WARNING_POP
+
+PYBIND11_NAMESPACE_BEGIN(accessor_policies)
+struct obj_attr {
+    using key_type = object;
+    static object get(handle obj, handle key) { return getattr(obj, key); }
+    static void set(handle obj, handle key, handle val) { setattr(obj, key, val); }
+};
+
+struct str_attr {
+    using key_type = const char *;
+    static object get(handle obj, const char *key) { return getattr(obj, key); }
+    static void set(handle obj, const char *key, handle val) { setattr(obj, key, val); }
+};
+
+struct generic_item {
+    using key_type = object;
+
+    static object get(handle obj, handle key) {
+        PyObject *result = PyObject_GetItem(obj.ptr(), key.ptr());
+        if (!result) {
+            throw error_already_set();
+        }
+        return reinterpret_steal<object>(result);
+    }
+
+    static void set(handle obj, handle key, handle val) {
+        if (PyObject_SetItem(obj.ptr(), key.ptr(), val.ptr()) != 0) {
+            throw error_already_set();
+        }
+    }
+};
+
+struct sequence_item {
+    using key_type = size_t;
+
+    template <typename IdxType, detail::enable_if_t<std::is_integral<IdxType>::value, int> = 0>
+    static object get(handle obj, const IdxType &index) {
+        PyObject *result = PySequence_GetItem(obj.ptr(), ssize_t_cast(index));
+        if (!result) {
+            throw error_already_set();
+        }
+        return reinterpret_steal<object>(result);
+    }
+
+    template <typename IdxType, detail::enable_if_t<std::is_integral<IdxType>::value, int> = 0>
+    static void set(handle obj, const IdxType &index, handle val) {
+        // PySequence_SetItem does not steal a reference to 'val'
+        if (PySequence_SetItem(obj.ptr(), ssize_t_cast(index), val.ptr()) != 0) {
+            throw error_already_set();
+        }
+    }
+};
+
+struct list_item {
+    using key_type = size_t;
+
+    template <typename IdxType, detail::enable_if_t<std::is_integral<IdxType>::value, int> = 0>
+    static object get(handle obj, const IdxType &index) {
+        PyObject *result = PyList_GetItem(obj.ptr(), ssize_t_cast(index));
+        if (!result) {
+            throw error_already_set();
+        }
+        return reinterpret_borrow<object>(result);
+    }
+
+    template <typename IdxType, detail::enable_if_t<std::is_integral<IdxType>::value, int> = 0>
+    static void set(handle obj, const IdxType &index, handle val) {
+        // PyList_SetItem steals a reference to 'val'
+        if (PyList_SetItem(obj.ptr(), ssize_t_cast(index), val.inc_ref().ptr()) != 0) {
+            throw error_already_set();
+        }
+    }
+};
+
+struct tuple_item {
+    using key_type = size_t;
+
+    template <typename IdxType, detail::enable_if_t<std::is_integral<IdxType>::value, int> = 0>
+    static object get(handle obj, const IdxType &index) {
+        PyObject *result = PyTuple_GetItem(obj.ptr(), ssize_t_cast(index));
+        if (!result) {
+            throw error_already_set();
+        }
+        return reinterpret_borrow<object>(result);
+    }
+
+    template <typename IdxType, detail::enable_if_t<std::is_integral<IdxType>::value, int> = 0>
+    static void set(handle obj, const IdxType &index, handle val) {
+        // PyTuple_SetItem steals a reference to 'val'
+        if (PyTuple_SetItem(obj.ptr(), ssize_t_cast(index), val.inc_ref().ptr()) != 0) {
+            throw error_already_set();
+        }
+    }
+};
+PYBIND11_NAMESPACE_END(accessor_policies)
+
+/// STL iterator template used for tuple, list, sequence and dict
+template <typename Policy>
+class generic_iterator : public Policy {
+    using It = generic_iterator;
+
+public:
+    using difference_type = ssize_t;
+    using iterator_category = typename Policy::iterator_category;
+    using value_type = typename Policy::value_type;
+    using reference = typename Policy::reference;
+    using pointer = typename Policy::pointer;
+
+    generic_iterator() = default;
+    generic_iterator(handle seq, ssize_t index) : Policy(seq, index) {}
+
+    // NOLINTNEXTLINE(readability-const-return-type) // PR #3263
+    reference operator*() const { return Policy::dereference(); }
+    // NOLINTNEXTLINE(readability-const-return-type) // PR #3263
+    reference operator[](difference_type n) const { return *(*this + n); }
+    pointer operator->() const { return **this; }
+
+    It &operator++() {
+        Policy::increment();
+        return *this;
+    }
+    It operator++(int) {
+        auto copy = *this;
+        Policy::increment();
+        return copy;
+    }
+    It &operator--() {
+        Policy::decrement();
+        return *this;
+    }
+    It operator--(int) {
+        auto copy = *this;
+        Policy::decrement();
+        return copy;
+    }
+    It &operator+=(difference_type n) {
+        Policy::advance(n);
+        return *this;
+    }
+    It &operator-=(difference_type n) {
+        Policy::advance(-n);
+        return *this;
+    }
+
+    friend It operator+(const It &a, difference_type n) {
+        auto copy = a;
+        return copy += n;
+    }
+    friend It operator+(difference_type n, const It &b) { return b + n; }
+    friend It operator-(const It &a, difference_type n) {
+        auto copy = a;
+        return copy -= n;
+    }
+    friend difference_type operator-(const It &a, const It &b) { return a.distance_to(b); }
+
+    friend bool operator==(const It &a, const It &b) { return a.equal(b); }
+    friend bool operator!=(const It &a, const It &b) { return !(a == b); }
+    friend bool operator<(const It &a, const It &b) { return b - a > 0; }
+    friend bool operator>(const It &a, const It &b) { return b < a; }
+    friend bool operator>=(const It &a, const It &b) { return !(a < b); }
+    friend bool operator<=(const It &a, const It &b) { return !(a > b); }
+};
+
+PYBIND11_NAMESPACE_BEGIN(iterator_policies)
+/// Quick proxy class needed to implement ``operator->`` for iterators which can't return pointers
+template <typename T>
+struct arrow_proxy {
+    T value;
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    arrow_proxy(T &&value) noexcept : value(std::move(value)) {}
+    T *operator->() const { return &value; }
+};
+
+/// Lightweight iterator policy using just a simple pointer: see ``PySequence_Fast_ITEMS``
+class sequence_fast_readonly {
+protected:
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = handle;
+    using reference = const handle; // PR #3263
+    using pointer = arrow_proxy<const handle>;
+
+    sequence_fast_readonly(handle obj, ssize_t n) : ptr(PySequence_Fast_ITEMS(obj.ptr()) + n) {}
+    sequence_fast_readonly() = default;
+
+    // NOLINTNEXTLINE(readability-const-return-type) // PR #3263
+    reference dereference() const { return *ptr; }
+    void increment() { ++ptr; }
+    void decrement() { --ptr; }
+    void advance(ssize_t n) { ptr += n; }
+    bool equal(const sequence_fast_readonly &b) const { return ptr == b.ptr; }
+    ssize_t distance_to(const sequence_fast_readonly &b) const { return ptr - b.ptr; }
+
+private:
+    PyObject **ptr;
+};
+
+/// Full read and write access using the sequence protocol: see ``detail::sequence_accessor``
+class sequence_slow_readwrite {
+protected:
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = object;
+    using reference = sequence_accessor;
+    using pointer = arrow_proxy<const sequence_accessor>;
+
+    sequence_slow_readwrite(handle obj, ssize_t index) : obj(obj), index(index) {}
+    sequence_slow_readwrite() = default;
+
+    reference dereference() const { return {obj, static_cast<size_t>(index)}; }
+    void increment() { ++index; }
+    void decrement() { --index; }
+    void advance(ssize_t n) { index += n; }
+    bool equal(const sequence_slow_readwrite &b) const { return index == b.index; }
+    ssize_t distance_to(const sequence_slow_readwrite &b) const { return index - b.index; }
+
+private:
+    handle obj;
+    ssize_t index;
+};
+
+/// Python's dictionary protocol permits this to be a forward iterator
+class dict_readonly {
+protected:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = std::pair<handle, handle>;
+    using reference = const value_type; // PR #3263
+    using pointer = arrow_proxy<const value_type>;
+
+    dict_readonly() = default;
+    dict_readonly(handle obj, ssize_t pos) : obj(obj), pos(pos) { increment(); }
+
+    // NOLINTNEXTLINE(readability-const-return-type) // PR #3263
+    reference dereference() const { return {key, value}; }
+    void increment() {
+        if (PyDict_Next(obj.ptr(), &pos, &key, &value) == 0) {
+            pos = -1;
+        }
+    }
+    bool equal(const dict_readonly &b) const { return pos == b.pos; }
+
+private:
+    handle obj;
+    PyObject *key = nullptr, *value = nullptr;
+    ssize_t pos = -1;
+};
+PYBIND11_NAMESPACE_END(iterator_policies)
+
+#if !defined(PYPY_VERSION)
+using tuple_iterator = generic_iterator<iterator_policies::sequence_fast_readonly>;
+using list_iterator = generic_iterator<iterator_policies::sequence_fast_readonly>;
+#else
+using tuple_iterator = generic_iterator<iterator_policies::sequence_slow_readwrite>;
+using list_iterator = generic_iterator<iterator_policies::sequence_slow_readwrite>;
+#endif
+
+using sequence_iterator = generic_iterator<iterator_policies::sequence_slow_readwrite>;
+using dict_iterator = generic_iterator<iterator_policies::dict_readonly>;
+
+inline bool PyIterable_Check(PyObject *obj) {
+    PyObject *iter = PyObject_GetIter(obj);
+    if (iter) {
+        Py_DECREF(iter);
+        return true;
+    }
+    PyErr_Clear();
+    return false;
+}
+
+inline bool PyNone_Check(PyObject *o) { return o == Py_None; }
+inline bool PyEllipsis_Check(PyObject *o) { return o == Py_Ellipsis; }
+
+#ifdef PYBIND11_STR_LEGACY_PERMISSIVE
+inline bool PyUnicode_Check_Permissive(PyObject *o) {
+    return PyUnicode_Check(o) || PYBIND11_BYTES_CHECK(o);
+}
+#    define PYBIND11_STR_CHECK_FUN detail::PyUnicode_Check_Permissive
+#else
+#    define PYBIND11_STR_CHECK_FUN PyUnicode_Check
+#endif
+
+inline bool PyStaticMethod_Check(PyObject *o) { return Py_TYPE(o) == &PyStaticMethod_Type; }
+
+class kwargs_proxy : public handle {
+public:
+    explicit kwargs_proxy(handle h) : handle(h) {}
+};
+
+class args_proxy : public handle {
+public:
+    explicit args_proxy(handle h) : handle(h) {}
+    kwargs_proxy operator*() const { return kwargs_proxy(*this); }
+};
+
+/// Python argument categories (using PEP 448 terms)
+template <typename T>
+using is_keyword = std::is_base_of<arg, T>;
+template <typename T>
+using is_s_unpacking = std::is_same<args_proxy, T>; // * unpacking
+template <typename T>
+using is_ds_unpacking = std::is_same<kwargs_proxy, T>; // ** unpacking
+template <typename T>
+using is_positional = satisfies_none_of<T, is_keyword, is_s_unpacking, is_ds_unpacking>;
+template <typename T>
+using is_keyword_or_ds = satisfies_any_of<T, is_keyword, is_ds_unpacking>;
+
+// Call argument collector forward declarations
+template <return_value_policy policy = return_value_policy::automatic_reference>
+class simple_collector;
+template <return_value_policy policy = return_value_policy::automatic_reference>
+class unpacking_collector;
+
+inline object get_scope_module(handle scope) {
+    if (scope) {
+        if (hasattr(scope, "__module__")) {
+            return scope.attr("__module__");
+        }
+        if (hasattr(scope, "__name__")) {
+            return scope.attr("__name__");
+        }
+    }
+    return object();
+}
+
+PYBIND11_NAMESPACE_END(detail)
+
+// TODO: After the deprecated constructors are removed, this macro can be simplified by
+//       inheriting ctors: `using Parent::Parent`. It's not an option right now because
+//       the `using` statement triggers the parent deprecation warning even if the ctor
+//       isn't even used.
+#define PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun)                                            \
+public:                                                                                           \
+    PYBIND11_DEPRECATED("Use reinterpret_borrow<" #Name ">() or reinterpret_steal<" #Name ">()")  \
+    Name(handle h, bool is_borrowed)                                                              \
+        : Parent(is_borrowed ? Parent(h, borrowed_t{}) : Parent(h, stolen_t{})) {}                \
+    Name(handle h, borrowed_t) : Parent(h, borrowed_t{}) {}                                       \
+    Name(handle h, stolen_t) : Parent(h, stolen_t{}) {}                                           \
+    PYBIND11_DEPRECATED("Use py::isinstance<py::python_type>(obj) instead")                       \
+    bool check() const { return m_ptr != nullptr && (CheckFun(m_ptr) != 0); }                     \
+    static bool check_(handle h) { return h.ptr() != nullptr && CheckFun(h.ptr()); }              \
+    template <typename Policy_> /* NOLINTNEXTLINE(google-explicit-constructor) */                 \
+    Name(const ::pybind11::detail::accessor<Policy_> &a) : Name(object(a)) {}
+
+#define PYBIND11_OBJECT_CVT(Name, Parent, CheckFun, ConvertFun)                                   \
+    PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun)                                                \
+    /* This is deliberately not 'explicit' to allow implicit conversion from object: */           \
+    /* NOLINTNEXTLINE(google-explicit-constructor) */                                             \
+    Name(const object &o)                                                                         \
+        : Parent(check_(o) ? o.inc_ref().ptr() : ConvertFun(o.ptr()), stolen_t{}) {               \
+        if (!m_ptr)                                                                               \
+            throw ::pybind11::error_already_set();                                                \
+    }                                                                                             \
+    /* NOLINTNEXTLINE(google-explicit-constructor) */                                             \
+    Name(object &&o) : Parent(check_(o) ? o.release().ptr() : ConvertFun(o.ptr()), stolen_t{}) {  \
+        if (!m_ptr)                                                                               \
+            throw ::pybind11::error_already_set();                                                \
+    }
+
+#define PYBIND11_OBJECT_CVT_DEFAULT(Name, Parent, CheckFun, ConvertFun)                           \
+    PYBIND11_OBJECT_CVT(Name, Parent, CheckFun, ConvertFun)                                       \
+    Name() = default;
+
+#define PYBIND11_OBJECT_CHECK_FAILED(Name, o_ptr)                                                 \
+    ::pybind11::type_error("Object of type '"                                                     \
+                           + ::pybind11::detail::get_fully_qualified_tp_name(Py_TYPE(o_ptr))      \
+                           + "' is not an instance of '" #Name "'")
+
+#define PYBIND11_OBJECT(Name, Parent, CheckFun)                                                   \
+    PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun)                                                \
+    /* This is deliberately not 'explicit' to allow implicit conversion from object: */           \
+    /* NOLINTNEXTLINE(google-explicit-constructor) */                                             \
+    Name(const object &o) : Parent(o) {                                                           \
+        if (m_ptr && !check_(m_ptr))                                                              \
+            throw PYBIND11_OBJECT_CHECK_FAILED(Name, m_ptr);                                      \
+    }                                                                                             \
+    /* NOLINTNEXTLINE(google-explicit-constructor) */                                             \
+    Name(object &&o) : Parent(std::move(o)) {                                                     \
+        if (m_ptr && !check_(m_ptr))                                                              \
+            throw PYBIND11_OBJECT_CHECK_FAILED(Name, m_ptr);                                      \
+    }
+
+#define PYBIND11_OBJECT_DEFAULT(Name, Parent, CheckFun)                                           \
+    PYBIND11_OBJECT(Name, Parent, CheckFun)                                                       \
+    Name() = default;
+
+/// \addtogroup pytypes
+/// @{
+
+/** \rst
+    Wraps a Python iterator so that it can also be used as a C++ input iterator
+
+    Caveat: copying an iterator does not (and cannot) clone the internal
+    state of the Python iterable. This also applies to the post-increment
+    operator. This iterator should only be used to retrieve the current
+    value using ``operator*()``.
+\endrst */
+class iterator : public object {
+public:
+    using iterator_category = std::input_iterator_tag;
+    using difference_type = ssize_t;
+    using value_type = handle;
+    using reference = const handle; // PR #3263
+    using pointer = const handle *;
+
+    PYBIND11_OBJECT_DEFAULT(iterator, object, PyIter_Check)
+
+    iterator &operator++() {
+        init();
+        advance();
+        return *this;
+    }
+
+    iterator operator++(int) {
+        // Note: We must call init() first so that rv.value is
+        // the same as this->value just before calling advance().
+        // Otherwise, dereferencing the returned iterator may call
+        // advance() again and return the 3rd item instead of the 1st.
+        init();
+        auto rv = *this;
+        advance();
+        return rv;
+    }
+
+    // NOLINTNEXTLINE(readability-const-return-type) // PR #3263
+    reference operator*() const {
+        init();
+        return value;
+    }
+
+    pointer operator->() const {
+        init();
+        return &value;
+    }
+
+    /** \rst
+         The value which marks the end of the iteration. ``it == iterator::sentinel()``
+         is equivalent to catching ``StopIteration`` in Python.
+
+         .. code-block:: cpp
+
+             void foo(py::iterator it) {
+                 while (it != py::iterator::sentinel()) {
+                    // use `*it`
+                    ++it;
+                 }
+             }
+    \endrst */
+    static iterator sentinel() { return {}; }
+
+    friend bool operator==(const iterator &a, const iterator &b) { return a->ptr() == b->ptr(); }
+    friend bool operator!=(const iterator &a, const iterator &b) { return a->ptr() != b->ptr(); }
+
+private:
+    void init() const {
+        if (m_ptr && !value.ptr()) {
+            auto &self = const_cast<iterator &>(*this);
+            self.advance();
+        }
+    }
+
+    void advance() {
+        value = reinterpret_steal<object>(PyIter_Next(m_ptr));
+        if (value.ptr() == nullptr && PyErr_Occurred()) {
+            throw error_already_set();
+        }
+    }
+
+private:
+    object value = {};
+};
+
+class type : public object {
+public:
+    PYBIND11_OBJECT(type, object, PyType_Check)
+
+    /// Return a type handle from a handle or an object
+    static handle handle_of(handle h) { return handle((PyObject *) Py_TYPE(h.ptr())); }
+
+    /// Return a type object from a handle or an object
+    static type of(handle h) { return type(type::handle_of(h), borrowed_t{}); }
+
+    // Defined in pybind11/cast.h
+    /// Convert C++ type to handle if previously registered. Does not convert
+    /// standard types, like int, float. etc. yet.
+    /// See https://github.com/pybind/pybind11/issues/2486
+    template <typename T>
+    static handle handle_of();
+
+    /// Convert C++ type to type if previously registered. Does not convert
+    /// standard types, like int, float. etc. yet.
+    /// See https://github.com/pybind/pybind11/issues/2486
+    template <typename T>
+    static type of() {
+        return type(type::handle_of<T>(), borrowed_t{});
+    }
+};
+
+class iterable : public object {
+public:
+    PYBIND11_OBJECT_DEFAULT(iterable, object, detail::PyIterable_Check)
+};
+
+class bytes;
+
+class str : public object {
+public:
+    PYBIND11_OBJECT_CVT(str, object, PYBIND11_STR_CHECK_FUN, raw_str)
+
+    template <typename SzType, detail::enable_if_t<std::is_integral<SzType>::value, int> = 0>
+    str(const char *c, const SzType &n)
+        : object(PyUnicode_FromStringAndSize(c, ssize_t_cast(n)), stolen_t{}) {
+        if (!m_ptr) {
+            if (PyErr_Occurred()) {
+                throw error_already_set();
+            }
+            pybind11_fail("Could not allocate string object!");
+        }
+    }
+
+    // 'explicit' is explicitly omitted from the following constructors to allow implicit
+    // conversion to py::str from C++ string-like objects
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    str(const char *c = "") : object(PyUnicode_FromString(c), stolen_t{}) {
+        if (!m_ptr) {
+            if (PyErr_Occurred()) {
+                throw error_already_set();
+            }
+            pybind11_fail("Could not allocate string object!");
+        }
+    }
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    str(const std::string &s) : str(s.data(), s.size()) {}
+
+#ifdef PYBIND11_HAS_STRING_VIEW
+    // enable_if is needed to avoid "ambiguous conversion" errors (see PR #3521).
+    template <typename T, detail::enable_if_t<std::is_same<T, std::string_view>::value, int> = 0>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    str(T s) : str(s.data(), s.size()) {}
+
+#    ifdef PYBIND11_HAS_U8STRING
+    // reinterpret_cast here is safe (C++20 guarantees char8_t has the same size/alignment as char)
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    str(std::u8string_view s) : str(reinterpret_cast<const char *>(s.data()), s.size()) {}
+#    endif
+
+#endif
+
+    explicit str(const bytes &b);
+
+    /** \rst
+        Return a string representation of the object. This is analogous to
+        the ``str()`` function in Python.
+    \endrst */
+    explicit str(handle h) : object(raw_str(h.ptr()), stolen_t{}) {
+        if (!m_ptr) {
+            throw error_already_set();
+        }
+    }
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator std::string() const {
+        object temp = *this;
+        if (PyUnicode_Check(m_ptr)) {
+            temp = reinterpret_steal<object>(PyUnicode_AsUTF8String(m_ptr));
+            if (!temp) {
+                throw error_already_set();
+            }
+        }
+        char *buffer = nullptr;
+        ssize_t length = 0;
+        if (PyBytes_AsStringAndSize(temp.ptr(), &buffer, &length) != 0) {
+            throw error_already_set();
+        }
+        return std::string(buffer, (size_t) length);
+    }
+
+    template <typename... Args>
+    str format(Args &&...args) const {
+        return attr("format")(std::forward<Args>(args)...);
+    }
+
+private:
+    /// Return string representation -- always returns a new reference, even if already a str
+    static PyObject *raw_str(PyObject *op) {
+        PyObject *str_value = PyObject_Str(op);
+        return str_value;
+    }
+};
+/// @} pytypes
+
+inline namespace literals {
+/** \rst
+    String literal version of `str`
+ \endrst */
+inline str
+#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ < 5
+operator"" _s // gcc 4.8.5 insists on having a space (hard error).
+#else
+operator""_s // clang 17 generates a deprecation warning if there is a space.
+#endif
+    (const char *s, size_t size) {
+    return {s, size};
+}
+} // namespace literals
+
+/// \addtogroup pytypes
+/// @{
+class bytes : public object {
+public:
+    PYBIND11_OBJECT(bytes, object, PYBIND11_BYTES_CHECK)
+
+    // Allow implicit conversion:
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    bytes(const char *c = "") : object(PYBIND11_BYTES_FROM_STRING(c), stolen_t{}) {
+        if (!m_ptr) {
+            pybind11_fail("Could not allocate bytes object!");
+        }
+    }
+
+    template <typename SzType, detail::enable_if_t<std::is_integral<SzType>::value, int> = 0>
+    bytes(const char *c, const SzType &n)
+        : object(PYBIND11_BYTES_FROM_STRING_AND_SIZE(c, ssize_t_cast(n)), stolen_t{}) {
+        if (!m_ptr) {
+            pybind11_fail("Could not allocate bytes object!");
+        }
+    }
+
+    // Allow implicit conversion:
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    bytes(const std::string &s) : bytes(s.data(), s.size()) {}
+
+    explicit bytes(const pybind11::str &s);
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator std::string() const { return string_op<std::string>(); }
+
+#ifdef PYBIND11_HAS_STRING_VIEW
+    // enable_if is needed to avoid "ambiguous conversion" errors (see PR #3521).
+    template <typename T, detail::enable_if_t<std::is_same<T, std::string_view>::value, int> = 0>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    bytes(T s) : bytes(s.data(), s.size()) {}
+
+    // Obtain a string view that views the current `bytes` buffer value.  Note that this is only
+    // valid so long as the `bytes` instance remains alive and so generally should not outlive the
+    // lifetime of the `bytes` instance.
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator std::string_view() const { return string_op<std::string_view>(); }
+#endif
+private:
+    template <typename T>
+    T string_op() const {
+        char *buffer = nullptr;
+        ssize_t length = 0;
+        if (PyBytes_AsStringAndSize(m_ptr, &buffer, &length) != 0) {
+            throw error_already_set();
+        }
+        return {buffer, static_cast<size_t>(length)};
+    }
+};
+// Note: breathe >= 4.17.0 will fail to build docs if the below two constructors
+// are included in the doxygen group; close here and reopen after as a workaround
+/// @} pytypes
+
+inline bytes::bytes(const pybind11::str &s) {
+    object temp = s;
+    if (PyUnicode_Check(s.ptr())) {
+        temp = reinterpret_steal<object>(PyUnicode_AsUTF8String(s.ptr()));
+        if (!temp) {
+            throw error_already_set();
+        }
+    }
+    char *buffer = nullptr;
+    ssize_t length = 0;
+    if (PyBytes_AsStringAndSize(temp.ptr(), &buffer, &length) != 0) {
+        throw error_already_set();
+    }
+    auto obj = reinterpret_steal<object>(PYBIND11_BYTES_FROM_STRING_AND_SIZE(buffer, length));
+    if (!obj) {
+        pybind11_fail("Could not allocate bytes object!");
+    }
+    m_ptr = obj.release().ptr();
+}
+
+inline str::str(const bytes &b) {
+    char *buffer = nullptr;
+    ssize_t length = 0;
+    if (PyBytes_AsStringAndSize(b.ptr(), &buffer, &length) != 0) {
+        throw error_already_set();
+    }
+    auto obj = reinterpret_steal<object>(PyUnicode_FromStringAndSize(buffer, length));
+    if (!obj) {
+        if (PyErr_Occurred()) {
+            throw error_already_set();
+        }
+        pybind11_fail("Could not allocate string object!");
+    }
+    m_ptr = obj.release().ptr();
+}
+
+/// \addtogroup pytypes
+/// @{
+class bytearray : public object {
+public:
+    PYBIND11_OBJECT_CVT(bytearray, object, PyByteArray_Check, PyByteArray_FromObject)
+
+    template <typename SzType, detail::enable_if_t<std::is_integral<SzType>::value, int> = 0>
+    bytearray(const char *c, const SzType &n)
+        : object(PyByteArray_FromStringAndSize(c, ssize_t_cast(n)), stolen_t{}) {
+        if (!m_ptr) {
+            pybind11_fail("Could not allocate bytearray object!");
+        }
+    }
+
+    bytearray() : bytearray("", 0) {}
+
+    explicit bytearray(const std::string &s) : bytearray(s.data(), s.size()) {}
+
+    size_t size() const { return static_cast<size_t>(PyByteArray_Size(m_ptr)); }
+
+    explicit operator std::string() const {
+        char *buffer = PyByteArray_AS_STRING(m_ptr);
+        ssize_t size = PyByteArray_GET_SIZE(m_ptr);
+        return std::string(buffer, static_cast<size_t>(size));
+    }
+};
+// Note: breathe >= 4.17.0 will fail to build docs if the below two constructors
+// are included in the doxygen group; close here and reopen after as a workaround
+/// @} pytypes
+
+/// \addtogroup pytypes
+/// @{
+class none : public object {
+public:
+    PYBIND11_OBJECT(none, object, detail::PyNone_Check)
+    none() : object(Py_None, borrowed_t{}) {}
+};
+
+class ellipsis : public object {
+public:
+    PYBIND11_OBJECT(ellipsis, object, detail::PyEllipsis_Check)
+    ellipsis() : object(Py_Ellipsis, borrowed_t{}) {}
+};
+
+class bool_ : public object {
+public:
+    PYBIND11_OBJECT_CVT(bool_, object, PyBool_Check, raw_bool)
+    bool_() : object(Py_False, borrowed_t{}) {}
+    // Allow implicit conversion from and to `bool`:
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    bool_(bool value) : object(value ? Py_True : Py_False, borrowed_t{}) {}
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator bool() const { return (m_ptr != nullptr) && PyLong_AsLong(m_ptr) != 0; }
+
+private:
+    /// Return the truth value of an object -- always returns a new reference
+    static PyObject *raw_bool(PyObject *op) {
+        const auto value = PyObject_IsTrue(op);
+        if (value == -1) {
+            return nullptr;
+        }
+        return handle(value != 0 ? Py_True : Py_False).inc_ref().ptr();
+    }
+};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+// Converts a value to the given unsigned type.  If an error occurs, you get back (Unsigned) -1;
+// otherwise you get back the unsigned long or unsigned long long value cast to (Unsigned).
+// (The distinction is critically important when casting a returned -1 error value to some other
+// unsigned type: (A)-1 != (B)-1 when A and B are unsigned types of different sizes).
+template <typename Unsigned>
+Unsigned as_unsigned(PyObject *o) {
+    if (sizeof(Unsigned) <= sizeof(unsigned long)) {
+        unsigned long v = PyLong_AsUnsignedLong(o);
+        return v == (unsigned long) -1 && PyErr_Occurred() ? (Unsigned) -1 : (Unsigned) v;
+    }
+    unsigned long long v = PyLong_AsUnsignedLongLong(o);
+    return v == (unsigned long long) -1 && PyErr_Occurred() ? (Unsigned) -1 : (Unsigned) v;
+}
+PYBIND11_NAMESPACE_END(detail)
+
+class int_ : public object {
+public:
+    PYBIND11_OBJECT_CVT(int_, object, PYBIND11_LONG_CHECK, PyNumber_Long)
+    int_() : object(PyLong_FromLong(0), stolen_t{}) {}
+    // Allow implicit conversion from C++ integral types:
+    template <typename T, detail::enable_if_t<std::is_integral<T>::value, int> = 0>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    int_(T value) {
+        if (sizeof(T) <= sizeof(long)) {
+            if (std::is_signed<T>::value) {
+                m_ptr = PyLong_FromLong((long) value);
+            } else {
+                m_ptr = PyLong_FromUnsignedLong((unsigned long) value);
+            }
+        } else {
+            if (std::is_signed<T>::value) {
+                m_ptr = PyLong_FromLongLong((long long) value);
+            } else {
+                m_ptr = PyLong_FromUnsignedLongLong((unsigned long long) value);
+            }
+        }
+        if (!m_ptr) {
+            pybind11_fail("Could not allocate int object!");
+        }
+    }
+
+    template <typename T, detail::enable_if_t<std::is_integral<T>::value, int> = 0>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator T() const {
+        return std::is_unsigned<T>::value  ? detail::as_unsigned<T>(m_ptr)
+               : sizeof(T) <= sizeof(long) ? (T) PyLong_AsLong(m_ptr)
+                                           : (T) PYBIND11_LONG_AS_LONGLONG(m_ptr);
+    }
+};
+
+class float_ : public object {
+public:
+    PYBIND11_OBJECT_CVT(float_, object, PyFloat_Check, PyNumber_Float)
+    // Allow implicit conversion from float/double:
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    float_(float value) : object(PyFloat_FromDouble((double) value), stolen_t{}) {
+        if (!m_ptr) {
+            pybind11_fail("Could not allocate float object!");
+        }
+    }
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    float_(double value = .0) : object(PyFloat_FromDouble((double) value), stolen_t{}) {
+        if (!m_ptr) {
+            pybind11_fail("Could not allocate float object!");
+        }
+    }
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator float() const { return (float) PyFloat_AsDouble(m_ptr); }
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator double() const { return (double) PyFloat_AsDouble(m_ptr); }
+};
+
+class weakref : public object {
+public:
+    PYBIND11_OBJECT_CVT_DEFAULT(weakref, object, PyWeakref_Check, raw_weakref)
+    explicit weakref(handle obj, handle callback = {})
+        : object(PyWeakref_NewRef(obj.ptr(), callback.ptr()), stolen_t{}) {
+        if (!m_ptr) {
+            if (PyErr_Occurred()) {
+                throw error_already_set();
+            }
+            pybind11_fail("Could not allocate weak reference!");
+        }
+    }
+
+private:
+    static PyObject *raw_weakref(PyObject *o) { return PyWeakref_NewRef(o, nullptr); }
+};
+
+class slice : public object {
+public:
+    PYBIND11_OBJECT(slice, object, PySlice_Check)
+    slice(handle start, handle stop, handle step)
+        : object(PySlice_New(start.ptr(), stop.ptr(), step.ptr()), stolen_t{}) {
+        if (!m_ptr) {
+            pybind11_fail("Could not allocate slice object!");
+        }
+    }
+    slice() : slice(none(), none(), none()) {}
+
+#ifdef PYBIND11_HAS_OPTIONAL
+    slice(std::optional<ssize_t> start, std::optional<ssize_t> stop, std::optional<ssize_t> step)
+        : slice(index_to_object(start), index_to_object(stop), index_to_object(step)) {}
+#else
+    slice(ssize_t start_, ssize_t stop_, ssize_t step_)
+        : slice(int_(start_), int_(stop_), int_(step_)) {}
+#endif
+
+    bool
+    compute(size_t length, size_t *start, size_t *stop, size_t *step, size_t *slicelength) const {
+        return PySlice_GetIndicesEx((PYBIND11_SLICE_OBJECT *) m_ptr,
+                                    (ssize_t) length,
+                                    (ssize_t *) start,
+                                    (ssize_t *) stop,
+                                    (ssize_t *) step,
+                                    (ssize_t *) slicelength)
+               == 0;
+    }
+    bool compute(
+        ssize_t length, ssize_t *start, ssize_t *stop, ssize_t *step, ssize_t *slicelength) const {
+        return PySlice_GetIndicesEx(
+                   (PYBIND11_SLICE_OBJECT *) m_ptr, length, start, stop, step, slicelength)
+               == 0;
+    }
+
+private:
+    template <typename T>
+    static object index_to_object(T index) {
+        return index ? object(int_(*index)) : object(none());
+    }
+};
+
+class capsule : public object {
+public:
+    PYBIND11_OBJECT_DEFAULT(capsule, object, PyCapsule_CheckExact)
+    PYBIND11_DEPRECATED("Use reinterpret_borrow<capsule>() or reinterpret_steal<capsule>()")
+    capsule(PyObject *ptr, bool is_borrowed)
+        : object(is_borrowed ? object(ptr, borrowed_t{}) : object(ptr, stolen_t{})) {}
+
+    explicit capsule(const void *value,
+                     const char *name = nullptr,
+                     PyCapsule_Destructor destructor = nullptr)
+        : object(PyCapsule_New(const_cast<void *>(value), name, destructor), stolen_t{}) {
+        if (!m_ptr) {
+            throw error_already_set();
+        }
+    }
+
+    PYBIND11_DEPRECATED("Please use the ctor with value, name, destructor args")
+    capsule(const void *value, PyCapsule_Destructor destructor)
+        : object(PyCapsule_New(const_cast<void *>(value), nullptr, destructor), stolen_t{}) {
+        if (!m_ptr) {
+            throw error_already_set();
+        }
+    }
+
+    /// Capsule name is nullptr.
+    capsule(const void *value, void (*destructor)(void *)) {
+        initialize_with_void_ptr_destructor(value, nullptr, destructor);
+    }
+
+    capsule(const void *value, const char *name, void (*destructor)(void *)) {
+        initialize_with_void_ptr_destructor(value, name, destructor);
+    }
+
+    explicit capsule(void (*destructor)()) {
+        m_ptr = PyCapsule_New(reinterpret_cast<void *>(destructor), nullptr, [](PyObject *o) {
+            const char *name = get_name_in_error_scope(o);
+            auto destructor = reinterpret_cast<void (*)()>(PyCapsule_GetPointer(o, name));
+            if (destructor == nullptr) {
+                throw error_already_set();
+            }
+            destructor();
+        });
+
+        if (!m_ptr) {
+            throw error_already_set();
+        }
+    }
+
+    template <typename T>
+    operator T *() const { // NOLINT(google-explicit-constructor)
+        return get_pointer<T>();
+    }
+
+    /// Get the pointer the capsule holds.
+    template <typename T = void>
+    T *get_pointer() const {
+        const auto *name = this->name();
+        T *result = static_cast<T *>(PyCapsule_GetPointer(m_ptr, name));
+        if (!result) {
+            throw error_already_set();
+        }
+        return result;
+    }
+
+    /// Replaces a capsule's pointer *without* calling the destructor on the existing one.
+    void set_pointer(const void *value) {
+        if (PyCapsule_SetPointer(m_ptr, const_cast<void *>(value)) != 0) {
+            throw error_already_set();
+        }
+    }
+
+    const char *name() const {
+        const char *name = PyCapsule_GetName(m_ptr);
+        if ((name == nullptr) && PyErr_Occurred()) {
+            throw error_already_set();
+        }
+        return name;
+    }
+
+    /// Replaces a capsule's name *without* calling the destructor on the existing one.
+    void set_name(const char *new_name) {
+        if (PyCapsule_SetName(m_ptr, new_name) != 0) {
+            throw error_already_set();
+        }
+    }
+
+private:
+    static const char *get_name_in_error_scope(PyObject *o) {
+        error_scope error_guard;
+
+        const char *name = PyCapsule_GetName(o);
+        if ((name == nullptr) && PyErr_Occurred()) {
+            // write out and consume error raised by call to PyCapsule_GetName
+            PyErr_WriteUnraisable(o);
+        }
+
+        return name;
+    }
+
+    void initialize_with_void_ptr_destructor(const void *value,
+                                             const char *name,
+                                             void (*destructor)(void *)) {
+        m_ptr = PyCapsule_New(const_cast<void *>(value), name, [](PyObject *o) {
+            // guard if destructor called while err indicator is set
+            error_scope error_guard;
+            auto destructor = reinterpret_cast<void (*)(void *)>(PyCapsule_GetContext(o));
+            if (destructor == nullptr && PyErr_Occurred()) {
+                throw error_already_set();
+            }
+            const char *name = get_name_in_error_scope(o);
+            void *ptr = PyCapsule_GetPointer(o, name);
+            if (ptr == nullptr) {
+                throw error_already_set();
+            }
+
+            if (destructor != nullptr) {
+                destructor(ptr);
+            }
+        });
+
+        if (!m_ptr || PyCapsule_SetContext(m_ptr, reinterpret_cast<void *>(destructor)) != 0) {
+            throw error_already_set();
+        }
+    }
+};
+
+class tuple : public object {
+public:
+    PYBIND11_OBJECT_CVT(tuple, object, PyTuple_Check, PySequence_Tuple)
+    template <typename SzType = ssize_t,
+              detail::enable_if_t<std::is_integral<SzType>::value, int> = 0>
+    // Some compilers generate link errors when using `const SzType &` here:
+    explicit tuple(SzType size = 0) : object(PyTuple_New(ssize_t_cast(size)), stolen_t{}) {
+        if (!m_ptr) {
+            pybind11_fail("Could not allocate tuple object!");
+        }
+    }
+    size_t size() const { return (size_t) PyTuple_Size(m_ptr); }
+    bool empty() const { return size() == 0; }
+    detail::tuple_accessor operator[](size_t index) const { return {*this, index}; }
+    template <typename T, detail::enable_if_t<detail::is_pyobject<T>::value, int> = 0>
+    detail::item_accessor operator[](T &&o) const {
+        return object::operator[](std::forward<T>(o));
+    }
+    detail::tuple_iterator begin() const { return {*this, 0}; }
+    detail::tuple_iterator end() const { return {*this, PyTuple_GET_SIZE(m_ptr)}; }
+};
+
+// We need to put this into a separate function because the Intel compiler
+// fails to compile enable_if_t<all_of<is_keyword_or_ds<Args>...>::value> part below
+// (tested with ICC 2021.1 Beta 20200827).
+template <typename... Args>
+constexpr bool args_are_all_keyword_or_ds() {
+    return detail::all_of<detail::is_keyword_or_ds<Args>...>::value;
+}
+
+class dict : public object {
+public:
+    PYBIND11_OBJECT_CVT(dict, object, PyDict_Check, raw_dict)
+    dict() : object(PyDict_New(), stolen_t{}) {
+        if (!m_ptr) {
+            pybind11_fail("Could not allocate dict object!");
+        }
+    }
+    template <typename... Args,
+              typename = detail::enable_if_t<args_are_all_keyword_or_ds<Args...>()>,
+              // MSVC workaround: it can't compile an out-of-line definition, so defer the
+              // collector
+              typename collector = detail::deferred_t<detail::unpacking_collector<>, Args...>>
+    explicit dict(Args &&...args) : dict(collector(std::forward<Args>(args)...).kwargs()) {}
+
+    size_t size() const { return (size_t) PyDict_Size(m_ptr); }
+    bool empty() const { return size() == 0; }
+    detail::dict_iterator begin() const { return {*this, 0}; }
+    detail::dict_iterator end() const { return {}; }
+    void clear() /* py-non-const */ { PyDict_Clear(ptr()); }
+    template <typename T>
+    bool contains(T &&key) const {
+        auto result = PyDict_Contains(m_ptr, detail::object_or_cast(std::forward<T>(key)).ptr());
+        if (result == -1) {
+            throw error_already_set();
+        }
+        return result == 1;
+    }
+
+private:
+    /// Call the `dict` Python type -- always returns a new reference
+    static PyObject *raw_dict(PyObject *op) {
+        if (PyDict_Check(op)) {
+            return handle(op).inc_ref().ptr();
+        }
+        return PyObject_CallFunctionObjArgs((PyObject *) &PyDict_Type, op, nullptr);
+    }
+};
+
+class sequence : public object {
+public:
+    PYBIND11_OBJECT_DEFAULT(sequence, object, PySequence_Check)
+    size_t size() const {
+        ssize_t result = PySequence_Size(m_ptr);
+        if (result == -1) {
+            throw error_already_set();
+        }
+        return (size_t) result;
+    }
+    bool empty() const { return size() == 0; }
+    detail::sequence_accessor operator[](size_t index) const { return {*this, index}; }
+    template <typename T, detail::enable_if_t<detail::is_pyobject<T>::value, int> = 0>
+    detail::item_accessor operator[](T &&o) const {
+        return object::operator[](std::forward<T>(o));
+    }
+    detail::sequence_iterator begin() const { return {*this, 0}; }
+    detail::sequence_iterator end() const { return {*this, PySequence_Size(m_ptr)}; }
+};
+
+class list : public object {
+public:
+    PYBIND11_OBJECT_CVT(list, object, PyList_Check, PySequence_List)
+    template <typename SzType = ssize_t,
+              detail::enable_if_t<std::is_integral<SzType>::value, int> = 0>
+    // Some compilers generate link errors when using `const SzType &` here:
+    explicit list(SzType size = 0) : object(PyList_New(ssize_t_cast(size)), stolen_t{}) {
+        if (!m_ptr) {
+            pybind11_fail("Could not allocate list object!");
+        }
+    }
+    size_t size() const { return (size_t) PyList_Size(m_ptr); }
+    bool empty() const { return size() == 0; }
+    detail::list_accessor operator[](size_t index) const { return {*this, index}; }
+    template <typename T, detail::enable_if_t<detail::is_pyobject<T>::value, int> = 0>
+    detail::item_accessor operator[](T &&o) const {
+        return object::operator[](std::forward<T>(o));
+    }
+    detail::list_iterator begin() const { return {*this, 0}; }
+    detail::list_iterator end() const { return {*this, PyList_GET_SIZE(m_ptr)}; }
+    template <typename T>
+    void append(T &&val) /* py-non-const */ {
+        if (PyList_Append(m_ptr, detail::object_or_cast(std::forward<T>(val)).ptr()) != 0) {
+            throw error_already_set();
+        }
+    }
+    template <typename IdxType,
+              typename ValType,
+              detail::enable_if_t<std::is_integral<IdxType>::value, int> = 0>
+    void insert(const IdxType &index, ValType &&val) /* py-non-const */ {
+        if (PyList_Insert(m_ptr,
+                          ssize_t_cast(index),
+                          detail::object_or_cast(std::forward<ValType>(val)).ptr())
+            != 0) {
+            throw error_already_set();
+        }
+    }
+    void clear() /* py-non-const */ {
+        if (PyList_SetSlice(m_ptr, 0, PyList_Size(m_ptr), nullptr) == -1) {
+            throw error_already_set();
+        }
+    }
+};
+
+class args : public tuple {
+    PYBIND11_OBJECT_DEFAULT(args, tuple, PyTuple_Check)
+};
+class kwargs : public dict {
+    PYBIND11_OBJECT_DEFAULT(kwargs, dict, PyDict_Check)
+};
+
+// Subclasses of args and kwargs to support type hinting
+// as defined in PEP 484. See #5357 for more info.
+template <typename T>
+class Args : public args {
+    using args::args;
+};
+
+template <typename T>
+class KWArgs : public kwargs {
+    using kwargs::kwargs;
+};
+
+class anyset : public object {
+public:
+    PYBIND11_OBJECT(anyset, object, PyAnySet_Check)
+    size_t size() const { return static_cast<size_t>(PySet_Size(m_ptr)); }
+    bool empty() const { return size() == 0; }
+    template <typename T>
+    bool contains(T &&val) const {
+        auto result = PySet_Contains(m_ptr, detail::object_or_cast(std::forward<T>(val)).ptr());
+        if (result == -1) {
+            throw error_already_set();
+        }
+        return result == 1;
+    }
+};
+
+class set : public anyset {
+public:
+    PYBIND11_OBJECT_CVT(set, anyset, PySet_Check, PySet_New)
+    set() : anyset(PySet_New(nullptr), stolen_t{}) {
+        if (!m_ptr) {
+            pybind11_fail("Could not allocate set object!");
+        }
+    }
+    template <typename T>
+    bool add(T &&val) /* py-non-const */ {
+        return PySet_Add(m_ptr, detail::object_or_cast(std::forward<T>(val)).ptr()) == 0;
+    }
+    void clear() /* py-non-const */ { PySet_Clear(m_ptr); }
+};
+
+class frozenset : public anyset {
+public:
+    PYBIND11_OBJECT_CVT(frozenset, anyset, PyFrozenSet_Check, PyFrozenSet_New)
+};
+
+class function : public object {
+public:
+    PYBIND11_OBJECT_DEFAULT(function, object, PyCallable_Check)
+    handle cpp_function() const {
+        handle fun = detail::get_function(m_ptr);
+        if (fun && PyCFunction_Check(fun.ptr())) {
+            return fun;
+        }
+        return handle();
+    }
+    bool is_cpp_function() const { return (bool) cpp_function(); }
+};
+
+class staticmethod : public object {
+public:
+    PYBIND11_OBJECT_CVT(staticmethod, object, detail::PyStaticMethod_Check, PyStaticMethod_New)
+};
+
+class buffer : public object {
+public:
+    PYBIND11_OBJECT_DEFAULT(buffer, object, PyObject_CheckBuffer)
+
+    buffer_info request(bool writable = false) const {
+        int flags = PyBUF_STRIDES | PyBUF_FORMAT;
+        if (writable) {
+            flags |= PyBUF_WRITABLE;
+        }
+        auto *view = new Py_buffer();
+        if (PyObject_GetBuffer(m_ptr, view, flags) != 0) {
+            delete view;
+            throw error_already_set();
+        }
+        return buffer_info(view);
+    }
+};
+
+class memoryview : public object {
+public:
+    PYBIND11_OBJECT_CVT(memoryview, object, PyMemoryView_Check, PyMemoryView_FromObject)
+
+    /** \rst
+        Creates ``memoryview`` from ``buffer_info``.
+
+        ``buffer_info`` must be created from ``buffer::request()``. Otherwise
+        throws an exception.
+
+        For creating a ``memoryview`` from objects that support buffer protocol,
+        use ``memoryview(const object& obj)`` instead of this constructor.
+     \endrst */
+    explicit memoryview(const buffer_info &info) {
+        if (!info.view()) {
+            pybind11_fail("Prohibited to create memoryview without Py_buffer");
+        }
+        // Note: PyMemoryView_FromBuffer never increments obj reference.
+        m_ptr = (info.view()->obj) ? PyMemoryView_FromObject(info.view()->obj)
+                                   : PyMemoryView_FromBuffer(info.view());
+        if (!m_ptr) {
+            pybind11_fail("Unable to create memoryview from buffer descriptor");
+        }
+    }
+
+    /** \rst
+        Creates ``memoryview`` from static buffer.
+
+        This method is meant for providing a ``memoryview`` for C/C++ buffer not
+        managed by Python. The caller is responsible for managing the lifetime
+        of ``ptr`` and ``format``, which MUST outlive the memoryview constructed
+        here.
+
+        See also: Python C API documentation for `PyMemoryView_FromBuffer`_.
+
+        .. _PyMemoryView_FromBuffer:
+           https://docs.python.org/c-api/memoryview.html#c.PyMemoryView_FromBuffer
+
+        :param ptr: Pointer to the buffer.
+        :param itemsize: Byte size of an element.
+        :param format: Pointer to the null-terminated format string. For
+            homogeneous Buffers, this should be set to
+            ``format_descriptor<T>::value``.
+        :param shape: Shape of the tensor (1 entry per dimension).
+        :param strides: Number of bytes between adjacent entries (for each
+            per dimension).
+        :param readonly: Flag to indicate if the underlying storage may be
+            written to.
+     \endrst */
+    static memoryview from_buffer(void *ptr,
+                                  ssize_t itemsize,
+                                  const char *format,
+                                  detail::any_container<ssize_t> shape,
+                                  detail::any_container<ssize_t> strides,
+                                  bool readonly = false);
+
+    static memoryview from_buffer(const void *ptr,
+                                  ssize_t itemsize,
+                                  const char *format,
+                                  detail::any_container<ssize_t> shape,
+                                  detail::any_container<ssize_t> strides) {
+        return memoryview::from_buffer(
+            const_cast<void *>(ptr), itemsize, format, std::move(shape), std::move(strides), true);
+    }
+
+    template <typename T>
+    static memoryview from_buffer(T *ptr,
+                                  detail::any_container<ssize_t> shape,
+                                  detail::any_container<ssize_t> strides,
+                                  bool readonly = false) {
+        return memoryview::from_buffer(reinterpret_cast<void *>(ptr),
+                                       sizeof(T),
+                                       format_descriptor<T>::value,
+                                       std::move(shape),
+                                       std::move(strides),
+                                       readonly);
+    }
+
+    template <typename T>
+    static memoryview from_buffer(const T *ptr,
+                                  detail::any_container<ssize_t> shape,
+                                  detail::any_container<ssize_t> strides) {
+        return memoryview::from_buffer(
+            const_cast<T *>(ptr), std::move(shape), std::move(strides), true);
+    }
+
+    /** \rst
+        Creates ``memoryview`` from static memory.
+
+        This method is meant for providing a ``memoryview`` for C/C++ buffer not
+        managed by Python. The caller is responsible for managing the lifetime
+        of ``mem``, which MUST outlive the memoryview constructed here.
+
+        See also: Python C API documentation for `PyMemoryView_FromBuffer`_.
+
+        .. _PyMemoryView_FromMemory:
+           https://docs.python.org/c-api/memoryview.html#c.PyMemoryView_FromMemory
+     \endrst */
+    static memoryview from_memory(void *mem, ssize_t size, bool readonly = false) {
+        PyObject *ptr = PyMemoryView_FromMemory(
+            reinterpret_cast<char *>(mem), size, (readonly) ? PyBUF_READ : PyBUF_WRITE);
+        if (!ptr) {
+            pybind11_fail("Could not allocate memoryview object!");
+        }
+        return memoryview(object(ptr, stolen_t{}));
+    }
+
+    static memoryview from_memory(const void *mem, ssize_t size) {
+        return memoryview::from_memory(const_cast<void *>(mem), size, true);
+    }
+
+#ifdef PYBIND11_HAS_STRING_VIEW
+    static memoryview from_memory(std::string_view mem) {
+        return from_memory(const_cast<char *>(mem.data()), static_cast<ssize_t>(mem.size()), true);
+    }
+#endif
+};
+
+/// @cond DUPLICATE
+inline memoryview memoryview::from_buffer(void *ptr,
+                                          ssize_t itemsize,
+                                          const char *format,
+                                          detail::any_container<ssize_t> shape,
+                                          detail::any_container<ssize_t> strides,
+                                          bool readonly) {
+    size_t ndim = shape->size();
+    if (ndim != strides->size()) {
+        pybind11_fail("memoryview: shape length doesn't match strides length");
+    }
+    ssize_t size = ndim != 0u ? 1 : 0;
+    for (size_t i = 0; i < ndim; ++i) {
+        size *= (*shape)[i];
+    }
+    Py_buffer view;
+    view.buf = ptr;
+    view.obj = nullptr;
+    view.len = size * itemsize;
+    view.readonly = static_cast<int>(readonly);
+    view.itemsize = itemsize;
+    view.format = const_cast<char *>(format);
+    view.ndim = static_cast<int>(ndim);
+    view.shape = shape->data();
+    view.strides = strides->data();
+    view.suboffsets = nullptr;
+    view.internal = nullptr;
+    PyObject *obj = PyMemoryView_FromBuffer(&view);
+    if (!obj) {
+        throw error_already_set();
+    }
+    return memoryview(object(obj, stolen_t{}));
+}
+/// @endcond
+/// @} pytypes
+
+/// \addtogroup python_builtins
+/// @{
+
+/// Get the length of a Python object.
+inline size_t len(handle h) {
+    ssize_t result = PyObject_Length(h.ptr());
+    if (result < 0) {
+        throw error_already_set();
+    }
+    return (size_t) result;
+}
+
+/// Get the length hint of a Python object.
+/// Returns 0 when this cannot be determined.
+inline size_t len_hint(handle h) {
+    ssize_t result = PyObject_LengthHint(h.ptr(), 0);
+    if (result < 0) {
+        // Sometimes a length can't be determined at all (eg generators)
+        // In which case simply return 0
+        PyErr_Clear();
+        return 0;
+    }
+    return (size_t) result;
+}
+
+inline str repr(handle h) {
+    PyObject *str_value = PyObject_Repr(h.ptr());
+    if (!str_value) {
+        throw error_already_set();
+    }
+    return reinterpret_steal<str>(str_value);
+}
+
+inline iterator iter(handle obj) {
+    PyObject *result = PyObject_GetIter(obj.ptr());
+    if (!result) {
+        throw error_already_set();
+    }
+    return reinterpret_steal<iterator>(result);
+}
+/// @} python_builtins
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+template <typename D>
+iterator object_api<D>::begin() const {
+    return iter(derived());
+}
+template <typename D>
+iterator object_api<D>::end() const {
+    return iterator::sentinel();
+}
+template <typename D>
+item_accessor object_api<D>::operator[](handle key) const {
+    return {derived(), reinterpret_borrow<object>(key)};
+}
+template <typename D>
+item_accessor object_api<D>::operator[](object &&key) const {
+    return {derived(), std::move(key)};
+}
+template <typename D>
+item_accessor object_api<D>::operator[](const char *key) const {
+    return {derived(), pybind11::str(key)};
+}
+template <typename D>
+obj_attr_accessor object_api<D>::attr(handle key) const {
+    return {derived(), reinterpret_borrow<object>(key)};
+}
+template <typename D>
+obj_attr_accessor object_api<D>::attr(object &&key) const {
+    return {derived(), std::move(key)};
+}
+template <typename D>
+str_attr_accessor object_api<D>::attr(const char *key) const {
+    return {derived(), key};
+}
+template <typename D>
+args_proxy object_api<D>::operator*() const {
+    return args_proxy(derived().ptr());
+}
+template <typename D>
+template <typename T>
+bool object_api<D>::contains(T &&item) const {
+    return attr("__contains__")(std::forward<T>(item)).template cast<bool>();
+}
+
+template <typename D>
+pybind11::str object_api<D>::str() const {
+    return pybind11::str(derived());
+}
+
+template <typename D>
+str_attr_accessor object_api<D>::doc() const {
+    return attr("__doc__");
+}
+
+template <typename D>
+object object_api<D>::annotations() const {
+// This is needed again because of the lazy annotations added in 3.14+
+#if PY_VERSION_HEX < 0x030A0000 || PY_VERSION_HEX >= 0x030E0000
+    // https://docs.python.org/3/howto/annotations.html#accessing-the-annotations-dict-of-an-object-in-python-3-9-and-older
+    if (!hasattr(derived(), "__annotations__")) {
+        setattr(derived(), "__annotations__", dict());
+    }
+    return attr("__annotations__");
+#else
+    return getattr(derived(), "__annotations__", dict());
+#endif
+}
+
+template <typename D>
+handle object_api<D>::get_type() const {
+    return type::handle_of(derived());
+}
+
+template <typename D>
+bool object_api<D>::rich_compare(object_api const &other, int value) const {
+    int rv = PyObject_RichCompareBool(derived().ptr(), other.derived().ptr(), value);
+    if (rv == -1) {
+        throw error_already_set();
+    }
+    return rv == 1;
+}
+
+#define PYBIND11_MATH_OPERATOR_UNARY(op, fn)                                                      \
+    template <typename D>                                                                         \
+    object object_api<D>::op() const {                                                            \
+        object result = reinterpret_steal<object>(fn(derived().ptr()));                           \
+        if (!result.ptr())                                                                        \
+            throw error_already_set();                                                            \
+        return result;                                                                            \
+    }
+
+#define PYBIND11_MATH_OPERATOR_BINARY(op, fn)                                                     \
+    template <typename D>                                                                         \
+    object object_api<D>::op(object_api const &other) const {                                     \
+        object result = reinterpret_steal<object>(fn(derived().ptr(), other.derived().ptr()));    \
+        if (!result.ptr())                                                                        \
+            throw error_already_set();                                                            \
+        return result;                                                                            \
+    }
+
+#define PYBIND11_MATH_OPERATOR_BINARY_INPLACE(iop, fn)                                            \
+    template <typename D>                                                                         \
+    object object_api<D>::iop(object_api const &other) {                                          \
+        object result = reinterpret_steal<object>(fn(derived().ptr(), other.derived().ptr()));    \
+        if (!result.ptr())                                                                        \
+            throw error_already_set();                                                            \
+        return result;                                                                            \
+    }
+
+PYBIND11_MATH_OPERATOR_UNARY(operator~, PyNumber_Invert)
+PYBIND11_MATH_OPERATOR_UNARY(operator-, PyNumber_Negative)
+PYBIND11_MATH_OPERATOR_BINARY(operator+, PyNumber_Add)
+PYBIND11_MATH_OPERATOR_BINARY_INPLACE(operator+=, PyNumber_InPlaceAdd)
+PYBIND11_MATH_OPERATOR_BINARY(operator-, PyNumber_Subtract)
+PYBIND11_MATH_OPERATOR_BINARY_INPLACE(operator-=, PyNumber_InPlaceSubtract)
+PYBIND11_MATH_OPERATOR_BINARY(operator*, PyNumber_Multiply)
+PYBIND11_MATH_OPERATOR_BINARY_INPLACE(operator*=, PyNumber_InPlaceMultiply)
+PYBIND11_MATH_OPERATOR_BINARY(operator/, PyNumber_TrueDivide)
+PYBIND11_MATH_OPERATOR_BINARY_INPLACE(operator/=, PyNumber_InPlaceTrueDivide)
+PYBIND11_MATH_OPERATOR_BINARY(operator|, PyNumber_Or)
+PYBIND11_MATH_OPERATOR_BINARY_INPLACE(operator|=, PyNumber_InPlaceOr)
+PYBIND11_MATH_OPERATOR_BINARY(operator&, PyNumber_And)
+PYBIND11_MATH_OPERATOR_BINARY_INPLACE(operator&=, PyNumber_InPlaceAnd)
+PYBIND11_MATH_OPERATOR_BINARY(operator^, PyNumber_Xor)
+PYBIND11_MATH_OPERATOR_BINARY_INPLACE(operator^=, PyNumber_InPlaceXor)
+PYBIND11_MATH_OPERATOR_BINARY(operator<<, PyNumber_Lshift)
+PYBIND11_MATH_OPERATOR_BINARY_INPLACE(operator<<=, PyNumber_InPlaceLshift)
+PYBIND11_MATH_OPERATOR_BINARY(operator>>, PyNumber_Rshift)
+PYBIND11_MATH_OPERATOR_BINARY_INPLACE(operator>>=, PyNumber_InPlaceRshift)
+
+#undef PYBIND11_MATH_OPERATOR_UNARY
+#undef PYBIND11_MATH_OPERATOR_BINARY
+#undef PYBIND11_MATH_OPERATOR_BINARY_INPLACE
+
+// Meant to return a Python str, but this is not checked.
+inline object get_module_name_if_available(handle scope) {
+    if (scope) {
+        if (hasattr(scope, "__module__")) {
+            return scope.attr("__module__");
+        }
+        if (hasattr(scope, "__name__")) {
+            return scope.attr("__name__");
+        }
+    }
+    return object();
+}
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/stl.h b/local_pybind11/pybind11/include/pybind11/stl.h
new file mode 100644
index 000000000..01be0b47c
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/stl.h
@@ -0,0 +1,666 @@
+/*
+    pybind11/stl.h: Transparent conversion for STL data types
+
+    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "pybind11.h"
+#include "detail/common.h"
+#include "detail/descr.h"
+#include "detail/type_caster_base.h"
+
+#include <deque>
+#include <initializer_list>
+#include <list>
+#include <map>
+#include <memory>
+#include <ostream>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <valarray>
+
+// See `detail/common.h` for implementation of these guards.
+#if defined(PYBIND11_HAS_OPTIONAL)
+#    include <optional>
+#elif defined(PYBIND11_HAS_EXP_OPTIONAL)
+#    include <experimental/optional>
+#endif
+
+#if defined(PYBIND11_HAS_VARIANT)
+#    include <variant>
+#endif
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+//
+// Begin: Equivalent of
+//        https://github.com/google/clif/blob/ae4eee1de07cdf115c0c9bf9fec9ff28efce6f6c/clif/python/runtime.cc#L388-L438
+/*
+The three `object_is_convertible_to_*()` functions below are
+the result of converging the behaviors of pybind11 and PyCLIF
+(http://github.com/google/clif).
+
+Originally PyCLIF was extremely far on the permissive side of the spectrum,
+while pybind11 was very far on the strict side. Originally PyCLIF accepted any
+Python iterable as input for a C++ `vector`/`set`/`map` argument, as long as
+the elements were convertible. The obvious (in hindsight) problem was that
+any empty Python iterable could be passed to any of these C++ types, e.g. `{}`
+was accepted for C++ `vector`/`set` arguments, or `[]` for C++ `map` arguments.
+
+The functions below strike a practical permissive-vs-strict compromise,
+informed by tens of thousands of use cases in the wild. A main objective is
+to prevent accidents and improve readability:
+
+- Python literals must match the C++ types.
+
+- For C++ `set`: The potentially reducing conversion from a Python sequence
+  (e.g. Python `list` or `tuple`) to a C++ `set` must be explicit, by going
+  through a Python `set`.
+
+- However, a Python `set` can still be passed to a C++ `vector`. The rationale
+  is that this conversion is not reducing. Implicit conversions of this kind
+  are also fairly commonly used, therefore enforcing explicit conversions
+  would have an unfavorable cost : benefit ratio; more sloppily speaking,
+  such an enforcement would be more annoying than helpful.
+
+Additional checks have been added to allow types derived from `collections.abc.Set` and
+`collections.abc.Mapping` (`collections.abc.Sequence` is already allowed by `PySequence_Check`).
+*/
+
+inline bool object_is_instance_with_one_of_tp_names(PyObject *obj,
+                                                    std::initializer_list<const char *> tp_names) {
+    if (PyType_Check(obj)) {
+        return false;
+    }
+    const char *obj_tp_name = Py_TYPE(obj)->tp_name;
+    for (const auto *tp_name : tp_names) {
+        if (std::strcmp(obj_tp_name, tp_name) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+inline bool object_is_convertible_to_std_vector(const handle &src) {
+    // Allow sequence-like objects, but not (byte-)string-like objects.
+    if (PySequence_Check(src.ptr()) != 0) {
+        return !PyUnicode_Check(src.ptr()) && !PyBytes_Check(src.ptr());
+    }
+    // Allow generators, set/frozenset and several common iterable types.
+    return (PyGen_Check(src.ptr()) != 0) || (PyAnySet_Check(src.ptr()) != 0)
+           || object_is_instance_with_one_of_tp_names(
+               src.ptr(), {"dict_keys", "dict_values", "dict_items", "map", "zip"});
+}
+
+inline bool object_is_convertible_to_std_set(const handle &src, bool convert) {
+    // Allow set/frozenset and dict keys.
+    // In convert mode: also allow types derived from collections.abc.Set.
+    return ((PyAnySet_Check(src.ptr()) != 0)
+            || object_is_instance_with_one_of_tp_names(src.ptr(), {"dict_keys"}))
+           || (convert && isinstance(src, module_::import("collections.abc").attr("Set")));
+}
+
+inline bool object_is_convertible_to_std_map(const handle &src, bool convert) {
+    // Allow dict.
+    if (PyDict_Check(src.ptr())) {
+        return true;
+    }
+    // Allow types conforming to Mapping Protocol.
+    // According to https://docs.python.org/3/c-api/mapping.html, `PyMappingCheck()` checks for
+    // `__getitem__()` without checking the type of keys. In order to restrict the allowed types
+    // closer to actual Mapping-like types, we also check for the `items()` method.
+    if (PyMapping_Check(src.ptr()) != 0) {
+        PyObject *items = PyObject_GetAttrString(src.ptr(), "items");
+        if (items != nullptr) {
+            bool is_convertible = (PyCallable_Check(items) != 0);
+            Py_DECREF(items);
+            if (is_convertible) {
+                return true;
+            }
+        } else {
+            PyErr_Clear();
+        }
+    }
+    // In convert mode: Allow types derived from collections.abc.Mapping
+    return convert && isinstance(src, module_::import("collections.abc").attr("Mapping"));
+}
+
+//
+// End: Equivalent of clif/python/runtime.cc
+//
+
+/// Extracts an const lvalue reference or rvalue reference for U based on the type of T (e.g. for
+/// forwarding a container element).  Typically used indirect via forwarded_type(), below.
+template <typename T, typename U>
+using forwarded_type = conditional_t<std::is_lvalue_reference<T>::value,
+                                     remove_reference_t<U> &,
+                                     remove_reference_t<U> &&>;
+
+/// Forwards a value U as rvalue or lvalue according to whether T is rvalue or lvalue; typically
+/// used for forwarding a container's elements.
+template <typename T, typename U>
+constexpr forwarded_type<T, U> forward_like(U &&u) {
+    return std::forward<detail::forwarded_type<T, U>>(std::forward<U>(u));
+}
+
+// Checks if a container has a STL style reserve method.
+// This will only return true for a `reserve()` with a `void` return.
+template <typename C>
+using has_reserve_method = std::is_same<decltype(std::declval<C>().reserve(0)), void>;
+
+template <typename Type, typename Key>
+struct set_caster {
+    using type = Type;
+    using key_conv = make_caster<Key>;
+
+private:
+    template <typename T = Type, enable_if_t<has_reserve_method<T>::value, int> = 0>
+    void reserve_maybe(const anyset &s, Type *) {
+        value.reserve(s.size());
+    }
+    void reserve_maybe(const anyset &, void *) {}
+
+    bool convert_iterable(const iterable &itbl, bool convert) {
+        for (const auto &it : itbl) {
+            key_conv conv;
+            if (!conv.load(it, convert)) {
+                return false;
+            }
+            value.insert(cast_op<Key &&>(std::move(conv)));
+        }
+        return true;
+    }
+
+    bool convert_anyset(const anyset &s, bool convert) {
+        value.clear();
+        reserve_maybe(s, &value);
+        return convert_iterable(s, convert);
+    }
+
+public:
+    bool load(handle src, bool convert) {
+        if (!object_is_convertible_to_std_set(src, convert)) {
+            return false;
+        }
+        if (isinstance<anyset>(src)) {
+            value.clear();
+            return convert_anyset(reinterpret_borrow<anyset>(src), convert);
+        }
+        if (!convert) {
+            return false;
+        }
+        assert(isinstance<iterable>(src));
+        value.clear();
+        return convert_iterable(reinterpret_borrow<iterable>(src), convert);
+    }
+
+    template <typename T>
+    static handle cast(T &&src, return_value_policy policy, handle parent) {
+        if (!std::is_lvalue_reference<T>::value) {
+            policy = return_value_policy_override<Key>::policy(policy);
+        }
+        pybind11::set s;
+        for (auto &&value : src) {
+            auto value_ = reinterpret_steal<object>(
+                key_conv::cast(detail::forward_like<T>(value), policy, parent));
+            if (!value_ || !s.add(std::move(value_))) {
+                return handle();
+            }
+        }
+        return s.release();
+    }
+
+    PYBIND11_TYPE_CASTER(type,
+                         io_name("collections.abc.Set", "set") + const_name("[") + key_conv::name
+                             + const_name("]"));
+};
+
+template <typename Type, typename Key, typename Value>
+struct map_caster {
+    using key_conv = make_caster<Key>;
+    using value_conv = make_caster<Value>;
+
+private:
+    template <typename T = Type, enable_if_t<has_reserve_method<T>::value, int> = 0>
+    void reserve_maybe(const dict &d, Type *) {
+        value.reserve(d.size());
+    }
+    void reserve_maybe(const dict &, void *) {}
+
+    bool convert_elements(const dict &d, bool convert) {
+        value.clear();
+        reserve_maybe(d, &value);
+        for (const auto &it : d) {
+            key_conv kconv;
+            value_conv vconv;
+            if (!kconv.load(it.first.ptr(), convert) || !vconv.load(it.second.ptr(), convert)) {
+                return false;
+            }
+            value.emplace(cast_op<Key &&>(std::move(kconv)), cast_op<Value &&>(std::move(vconv)));
+        }
+        return true;
+    }
+
+public:
+    bool load(handle src, bool convert) {
+        if (!object_is_convertible_to_std_map(src, convert)) {
+            return false;
+        }
+        if (isinstance<dict>(src)) {
+            return convert_elements(reinterpret_borrow<dict>(src), convert);
+        }
+        if (!convert) {
+            return false;
+        }
+        auto items = reinterpret_steal<object>(PyMapping_Items(src.ptr()));
+        if (!items) {
+            throw error_already_set();
+        }
+        assert(isinstance<iterable>(items));
+        return convert_elements(dict(reinterpret_borrow<iterable>(items)), convert);
+    }
+
+    template <typename T>
+    static handle cast(T &&src, return_value_policy policy, handle parent) {
+        dict d;
+        return_value_policy policy_key = policy;
+        return_value_policy policy_value = policy;
+        if (!std::is_lvalue_reference<T>::value) {
+            policy_key = return_value_policy_override<Key>::policy(policy_key);
+            policy_value = return_value_policy_override<Value>::policy(policy_value);
+        }
+        for (auto &&kv : src) {
+            auto key = reinterpret_steal<object>(
+                key_conv::cast(detail::forward_like<T>(kv.first), policy_key, parent));
+            auto value = reinterpret_steal<object>(
+                value_conv::cast(detail::forward_like<T>(kv.second), policy_value, parent));
+            if (!key || !value) {
+                return handle();
+            }
+            d[std::move(key)] = std::move(value);
+        }
+        return d.release();
+    }
+
+    PYBIND11_TYPE_CASTER(Type,
+                         io_name("collections.abc.Mapping", "dict") + const_name("[")
+                             + key_conv::name + const_name(", ") + value_conv::name
+                             + const_name("]"));
+};
+
+template <typename Type, typename Value>
+struct list_caster {
+    using value_conv = make_caster<Value>;
+
+    bool load(handle src, bool convert) {
+        if (!object_is_convertible_to_std_vector(src)) {
+            return false;
+        }
+        if (isinstance<sequence>(src)) {
+            return convert_elements(src, convert);
+        }
+        if (!convert) {
+            return false;
+        }
+        // Designed to be behavior-equivalent to passing tuple(src) from Python:
+        // The conversion to a tuple will first exhaust the generator object, to ensure that
+        // the generator is not left in an unpredictable (to the caller) partially-consumed
+        // state.
+        assert(isinstance<iterable>(src));
+        return convert_elements(tuple(reinterpret_borrow<iterable>(src)), convert);
+    }
+
+private:
+    template <typename T = Type, enable_if_t<has_reserve_method<T>::value, int> = 0>
+    void reserve_maybe(const sequence &s, Type *) {
+        value.reserve(s.size());
+    }
+    void reserve_maybe(const sequence &, void *) {}
+
+    bool convert_elements(handle seq, bool convert) {
+        auto s = reinterpret_borrow<sequence>(seq);
+        value.clear();
+        reserve_maybe(s, &value);
+        for (const auto &it : seq) {
+            value_conv conv;
+            if (!conv.load(it, convert)) {
+                return false;
+            }
+            value.push_back(cast_op<Value &&>(std::move(conv)));
+        }
+        return true;
+    }
+
+public:
+    template <typename T>
+    static handle cast(T &&src, return_value_policy policy, handle parent) {
+        if (!std::is_lvalue_reference<T>::value) {
+            policy = return_value_policy_override<Value>::policy(policy);
+        }
+        list l(src.size());
+        ssize_t index = 0;
+        for (auto &&value : src) {
+            auto value_ = reinterpret_steal<object>(
+                value_conv::cast(detail::forward_like<T>(value), policy, parent));
+            if (!value_) {
+                return handle();
+            }
+            PyList_SET_ITEM(l.ptr(), index++, value_.release().ptr()); // steals a reference
+        }
+        return l.release();
+    }
+
+    PYBIND11_TYPE_CASTER(Type,
+                         io_name("collections.abc.Sequence", "list") + const_name("[")
+                             + value_conv::name + const_name("]"));
+};
+
+template <typename Type, typename Alloc>
+struct type_caster<std::vector<Type, Alloc>> : list_caster<std::vector<Type, Alloc>, Type> {};
+
+template <typename Type, typename Alloc>
+struct type_caster<std::deque<Type, Alloc>> : list_caster<std::deque<Type, Alloc>, Type> {};
+
+template <typename Type, typename Alloc>
+struct type_caster<std::list<Type, Alloc>> : list_caster<std::list<Type, Alloc>, Type> {};
+
+template <typename ArrayType, typename V, size_t... I>
+ArrayType vector_to_array_impl(V &&v, index_sequence<I...>) {
+    return {{std::move(v[I])...}};
+}
+
+// Based on https://en.cppreference.com/w/cpp/container/array/to_array
+template <typename ArrayType, size_t N, typename V>
+ArrayType vector_to_array(V &&v) {
+    return vector_to_array_impl<ArrayType, V>(std::forward<V>(v), make_index_sequence<N>{});
+}
+
+template <typename ArrayType, typename Value, bool Resizable, size_t Size = 0>
+struct array_caster {
+    using value_conv = make_caster<Value>;
+
+private:
+    std::unique_ptr<ArrayType> value;
+
+    template <bool R = Resizable, enable_if_t<R, int> = 0>
+    bool convert_elements(handle seq, bool convert) {
+        auto l = reinterpret_borrow<sequence>(seq);
+        value.reset(new ArrayType{});
+        // Using `resize` to preserve the behavior exactly as it was before PR #5305
+        // For the `resize` to work, `Value` must be default constructible.
+        // For `std::valarray`, this is a requirement:
+        // https://en.cppreference.com/w/cpp/named_req/NumericType
+        value->resize(l.size());
+        size_t ctr = 0;
+        for (const auto &it : l) {
+            value_conv conv;
+            if (!conv.load(it, convert)) {
+                return false;
+            }
+            (*value)[ctr++] = cast_op<Value &&>(std::move(conv));
+        }
+        return true;
+    }
+
+    template <bool R = Resizable, enable_if_t<!R, int> = 0>
+    bool convert_elements(handle seq, bool convert) {
+        auto l = reinterpret_borrow<sequence>(seq);
+        if (l.size() != Size) {
+            return false;
+        }
+        // The `temp` storage is needed to support `Value` types that are not
+        // default-constructible.
+        // Deliberate choice: no template specializations, for simplicity, and
+        // because the compile time overhead for the specializations is deemed
+        // more significant than the runtime overhead for the `temp` storage.
+        std::vector<Value> temp;
+        temp.reserve(l.size());
+        for (auto it : l) {
+            value_conv conv;
+            if (!conv.load(it, convert)) {
+                return false;
+            }
+            temp.emplace_back(cast_op<Value &&>(std::move(conv)));
+        }
+        value.reset(new ArrayType(vector_to_array<ArrayType, Size>(std::move(temp))));
+        return true;
+    }
+
+public:
+    bool load(handle src, bool convert) {
+        if (!object_is_convertible_to_std_vector(src)) {
+            return false;
+        }
+        if (isinstance<sequence>(src)) {
+            return convert_elements(src, convert);
+        }
+        if (!convert) {
+            return false;
+        }
+        // Designed to be behavior-equivalent to passing tuple(src) from Python:
+        // The conversion to a tuple will first exhaust the generator object, to ensure that
+        // the generator is not left in an unpredictable (to the caller) partially-consumed
+        // state.
+        assert(isinstance<iterable>(src));
+        return convert_elements(tuple(reinterpret_borrow<iterable>(src)), convert);
+    }
+
+    template <typename T>
+    static handle cast(T &&src, return_value_policy policy, handle parent) {
+        list l(src.size());
+        ssize_t index = 0;
+        for (auto &&value : src) {
+            auto value_ = reinterpret_steal<object>(
+                value_conv::cast(detail::forward_like<T>(value), policy, parent));
+            if (!value_) {
+                return handle();
+            }
+            PyList_SET_ITEM(l.ptr(), index++, value_.release().ptr()); // steals a reference
+        }
+        return l.release();
+    }
+
+    // Code copied from PYBIND11_TYPE_CASTER macro.
+    // Intentionally preserving the behavior exactly as it was before PR #5305
+    template <typename T_, enable_if_t<std::is_same<ArrayType, remove_cv_t<T_>>::value, int> = 0>
+    static handle cast(T_ *src, return_value_policy policy, handle parent) {
+        if (!src) {
+            return none().release();
+        }
+        if (policy == return_value_policy::take_ownership) {
+            auto h = cast(std::move(*src), policy, parent);
+            delete src; // WARNING: Assumes `src` was allocated with `new`.
+            return h;
+        }
+        return cast(*src, policy, parent);
+    }
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator ArrayType *() { return &(*value); }
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator ArrayType &() { return *value; }
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator ArrayType &&() && { return std::move(*value); }
+
+    template <typename T_>
+    using cast_op_type = movable_cast_op_type<T_>;
+
+    static constexpr auto name
+        = const_name<Resizable>(const_name(""), const_name("typing.Annotated["))
+          + io_name("collections.abc.Sequence", "list") + const_name("[") + value_conv::name
+          + const_name("]")
+          + const_name<Resizable>(const_name(""),
+                                  const_name(", \"FixedSize(") + const_name<Size>()
+                                      + const_name(")\"]"));
+};
+
+template <typename Type, size_t Size>
+struct type_caster<std::array<Type, Size>>
+    : array_caster<std::array<Type, Size>, Type, false, Size> {};
+
+template <typename Type>
+struct type_caster<std::valarray<Type>> : array_caster<std::valarray<Type>, Type, true> {};
+
+template <typename Key, typename Compare, typename Alloc>
+struct type_caster<std::set<Key, Compare, Alloc>>
+    : set_caster<std::set<Key, Compare, Alloc>, Key> {};
+
+template <typename Key, typename Hash, typename Equal, typename Alloc>
+struct type_caster<std::unordered_set<Key, Hash, Equal, Alloc>>
+    : set_caster<std::unordered_set<Key, Hash, Equal, Alloc>, Key> {};
+
+template <typename Key, typename Value, typename Compare, typename Alloc>
+struct type_caster<std::map<Key, Value, Compare, Alloc>>
+    : map_caster<std::map<Key, Value, Compare, Alloc>, Key, Value> {};
+
+template <typename Key, typename Value, typename Hash, typename Equal, typename Alloc>
+struct type_caster<std::unordered_map<Key, Value, Hash, Equal, Alloc>>
+    : map_caster<std::unordered_map<Key, Value, Hash, Equal, Alloc>, Key, Value> {};
+
+// This type caster is intended to be used for std::optional and std::experimental::optional
+template <typename Type, typename Value = typename Type::value_type>
+struct optional_caster {
+    using value_conv = make_caster<Value>;
+
+    template <typename T>
+    static handle cast(T &&src, return_value_policy policy, handle parent) {
+        if (!src) {
+            return none().release();
+        }
+        if (!std::is_lvalue_reference<T>::value) {
+            policy = return_value_policy_override<Value>::policy(policy);
+        }
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+        return value_conv::cast(*std::forward<T>(src), policy, parent);
+    }
+
+    bool load(handle src, bool convert) {
+        if (!src) {
+            return false;
+        }
+        if (src.is_none()) {
+            return true; // default-constructed value is already empty
+        }
+        value_conv inner_caster;
+        if (!inner_caster.load(src, convert)) {
+            return false;
+        }
+
+        value.emplace(cast_op<Value &&>(std::move(inner_caster)));
+        return true;
+    }
+
+    PYBIND11_TYPE_CASTER(Type, value_conv::name | make_caster<none>::name);
+};
+
+#if defined(PYBIND11_HAS_OPTIONAL)
+template <typename T>
+struct type_caster<std::optional<T>> : public optional_caster<std::optional<T>> {};
+
+template <>
+struct type_caster<std::nullopt_t> : public void_caster<std::nullopt_t> {};
+#endif
+
+#if defined(PYBIND11_HAS_EXP_OPTIONAL)
+template <typename T>
+struct type_caster<std::experimental::optional<T>>
+    : public optional_caster<std::experimental::optional<T>> {};
+
+template <>
+struct type_caster<std::experimental::nullopt_t>
+    : public void_caster<std::experimental::nullopt_t> {};
+#endif
+
+/// Visit a variant and cast any found type to Python
+struct variant_caster_visitor {
+    return_value_policy policy;
+    handle parent;
+
+    using result_type = handle; // required by boost::variant in C++11
+
+    template <typename T>
+    result_type operator()(T &&src) const {
+        return make_caster<T>::cast(std::forward<T>(src), policy, parent);
+    }
+};
+
+/// Helper class which abstracts away variant's `visit` function. `std::variant` and similar
+/// `namespace::variant` types which provide a `namespace::visit()` function are handled here
+/// automatically using argument-dependent lookup. Users can provide specializations for other
+/// variant-like classes, e.g. `boost::variant` and `boost::apply_visitor`.
+template <template <typename...> class Variant>
+struct visit_helper {
+    template <typename... Args>
+    static auto call(Args &&...args) -> decltype(visit(std::forward<Args>(args)...)) {
+        return visit(std::forward<Args>(args)...);
+    }
+};
+
+/// Generic variant caster
+template <typename Variant>
+struct variant_caster;
+
+template <template <typename...> class V, typename... Ts>
+struct variant_caster<V<Ts...>> {
+    static_assert(sizeof...(Ts) > 0, "Variant must consist of at least one alternative.");
+
+    template <typename U, typename... Us>
+    bool load_alternative(handle src, bool convert, type_list<U, Us...>) {
+        auto caster = make_caster<U>();
+        if (caster.load(src, convert)) {
+            value = cast_op<U>(std::move(caster));
+            return true;
+        }
+        return load_alternative(src, convert, type_list<Us...>{});
+    }
+
+    bool load_alternative(handle, bool, type_list<>) { return false; }
+
+    bool load(handle src, bool convert) {
+        // Do a first pass without conversions to improve constructor resolution.
+        // E.g. `py::int_(1).cast<variant<double, int>>()` needs to fill the `int`
+        // slot of the variant. Without two-pass loading `double` would be filled
+        // because it appears first and a conversion is possible.
+        if (convert && load_alternative(src, false, type_list<Ts...>{})) {
+            return true;
+        }
+        return load_alternative(src, convert, type_list<Ts...>{});
+    }
+
+    template <typename Variant>
+    static handle cast(Variant &&src, return_value_policy policy, handle parent) {
+        return visit_helper<V>::call(variant_caster_visitor{policy, parent},
+                                     std::forward<Variant>(src));
+    }
+
+    using Type = V<Ts...>;
+    PYBIND11_TYPE_CASTER(Type, ::pybind11::detail::union_concat(make_caster<Ts>::name...));
+};
+
+#if defined(PYBIND11_HAS_VARIANT)
+template <typename... Ts>
+struct type_caster<std::variant<Ts...>> : variant_caster<std::variant<Ts...>> {};
+
+template <>
+struct type_caster<std::monostate> : public void_caster<std::monostate> {};
+#endif
+
+PYBIND11_NAMESPACE_END(detail)
+
+inline std::ostream &operator<<(std::ostream &os, const handle &obj) {
+#ifdef PYBIND11_HAS_STRING_VIEW
+    os << str(obj).cast<std::string_view>();
+#else
+    os << (std::string) str(obj);
+#endif
+    return os;
+}
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/stl/filesystem.h b/local_pybind11/pybind11/include/pybind11/stl/filesystem.h
new file mode 100644
index 000000000..1c0b18c1e
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/stl/filesystem.h
@@ -0,0 +1,114 @@
+// Copyright (c) 2021 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#pragma once
+
+#include <pybind11/cast.h>
+#include <pybind11/detail/common.h>
+#include <pybind11/detail/descr.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/pytypes.h>
+
+#include <string>
+
+#if defined(PYBIND11_HAS_FILESYSTEM)
+#    include <filesystem>
+#elif defined(PYBIND11_HAS_EXPERIMENTAL_FILESYSTEM)
+#    include <experimental/filesystem>
+#else
+#    error "Neither #include <filesystem> nor #include <experimental/filesystem is available."
+#endif
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+#ifdef PYPY_VERSION
+#    define PYBIND11_REINTERPRET_CAST_VOID_PTR_IF_NOT_PYPY(...) (__VA_ARGS__)
+#else
+#    define PYBIND11_REINTERPRET_CAST_VOID_PTR_IF_NOT_PYPY(...)                                   \
+        (reinterpret_cast<void *>(__VA_ARGS__))
+#endif
+
+#if defined(PYBIND11_HAS_FILESYSTEM) || defined(PYBIND11_HAS_EXPERIMENTAL_FILESYSTEM)
+template <typename T>
+struct path_caster {
+
+private:
+    static PyObject *unicode_from_fs_native(const std::string &w) {
+#    if !defined(PYPY_VERSION)
+        return PyUnicode_DecodeFSDefaultAndSize(w.c_str(), ssize_t(w.size()));
+#    else
+        // PyPy mistakenly declares the first parameter as non-const.
+        return PyUnicode_DecodeFSDefaultAndSize(const_cast<char *>(w.c_str()), ssize_t(w.size()));
+#    endif
+    }
+
+    static PyObject *unicode_from_fs_native(const std::wstring &w) {
+        return PyUnicode_FromWideChar(w.c_str(), ssize_t(w.size()));
+    }
+
+public:
+    static handle cast(const T &path, return_value_policy, handle) {
+        if (auto py_str = unicode_from_fs_native(path.native())) {
+            return module_::import("pathlib")
+                .attr("Path")(reinterpret_steal<object>(py_str))
+                .release();
+        }
+        return nullptr;
+    }
+
+    bool load(handle handle, bool) {
+        // PyUnicode_FSConverter and PyUnicode_FSDecoder normally take care of
+        // calling PyOS_FSPath themselves, but that's broken on PyPy (PyPy
+        // issue #3168) so we do it ourselves instead.
+        PyObject *buf = PyOS_FSPath(handle.ptr());
+        if (!buf) {
+            PyErr_Clear();
+            return false;
+        }
+        PyObject *native = nullptr;
+        if constexpr (std::is_same_v<typename T::value_type, char>) {
+            if (PyUnicode_FSConverter(buf, PYBIND11_REINTERPRET_CAST_VOID_PTR_IF_NOT_PYPY(&native))
+                != 0) {
+                if (auto *c_str = PyBytes_AsString(native)) {
+                    // AsString returns a pointer to the internal buffer, which
+                    // must not be free'd.
+                    value = c_str;
+                }
+            }
+        } else if constexpr (std::is_same_v<typename T::value_type, wchar_t>) {
+            if (PyUnicode_FSDecoder(buf, PYBIND11_REINTERPRET_CAST_VOID_PTR_IF_NOT_PYPY(&native))
+                != 0) {
+                if (auto *c_str = PyUnicode_AsWideCharString(native, nullptr)) {
+                    // AsWideCharString returns a new string that must be free'd.
+                    value = c_str; // Copies the string.
+                    PyMem_Free(c_str);
+                }
+            }
+        }
+        Py_XDECREF(native);
+        Py_DECREF(buf);
+        if (PyErr_Occurred()) {
+            PyErr_Clear();
+            return false;
+        }
+        return true;
+    }
+
+    PYBIND11_TYPE_CASTER(T, io_name("os.PathLike | str | bytes", "pathlib.Path"));
+};
+
+#endif // PYBIND11_HAS_FILESYSTEM || defined(PYBIND11_HAS_EXPERIMENTAL_FILESYSTEM)
+
+#if defined(PYBIND11_HAS_FILESYSTEM)
+template <>
+struct type_caster<std::filesystem::path> : public path_caster<std::filesystem::path> {};
+#elif defined(PYBIND11_HAS_EXPERIMENTAL_FILESYSTEM)
+template <>
+struct type_caster<std::experimental::filesystem::path>
+    : public path_caster<std::experimental::filesystem::path> {};
+#endif
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/stl_bind.h b/local_pybind11/pybind11/include/pybind11/stl_bind.h
new file mode 100644
index 000000000..3eb1e53f4
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/stl_bind.h
@@ -0,0 +1,858 @@
+/*
+    pybind11/std_bind.h: Binding generators for STL data types
+
+    Copyright (c) 2016 Sergey Lyskov and Wenzel Jakob
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "detail/common.h"
+#include "detail/type_caster_base.h"
+#include "cast.h"
+#include "operators.h"
+
+#include <algorithm>
+#include <sstream>
+#include <type_traits>
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+/* SFINAE helper class used by 'is_comparable */
+template <typename T>
+struct container_traits {
+    template <typename T2>
+    static std::true_type
+    test_comparable(decltype(std::declval<const T2 &>() == std::declval<const T2 &>()) *);
+    template <typename T2>
+    static std::false_type test_comparable(...);
+    template <typename T2>
+    static std::true_type test_value(typename T2::value_type *);
+    template <typename T2>
+    static std::false_type test_value(...);
+    template <typename T2>
+    static std::true_type test_pair(typename T2::first_type *, typename T2::second_type *);
+    template <typename T2>
+    static std::false_type test_pair(...);
+
+    static constexpr const bool is_comparable
+        = std::is_same<std::true_type, decltype(test_comparable<T>(nullptr))>::value;
+    static constexpr const bool is_pair
+        = std::is_same<std::true_type, decltype(test_pair<T>(nullptr, nullptr))>::value;
+    static constexpr const bool is_vector
+        = std::is_same<std::true_type, decltype(test_value<T>(nullptr))>::value;
+    static constexpr const bool is_element = !is_pair && !is_vector;
+};
+
+/* Default: is_comparable -> std::false_type */
+template <typename T, typename SFINAE = void>
+struct is_comparable : std::false_type {};
+
+/* For non-map data structures, check whether operator== can be instantiated */
+template <typename T>
+struct is_comparable<
+    T,
+    enable_if_t<container_traits<T>::is_element && container_traits<T>::is_comparable>>
+    : std::true_type {};
+
+/* For a vector/map data structure, recursively check the value type
+   (which is std::pair for maps) */
+template <typename T>
+struct is_comparable<T, enable_if_t<container_traits<T>::is_vector>>
+    : is_comparable<typename recursive_container_traits<T>::type_to_check_recursively> {};
+
+template <>
+struct is_comparable<recursive_bottom> : std::true_type {};
+
+/* For pairs, recursively check the two data types */
+template <typename T>
+struct is_comparable<T, enable_if_t<container_traits<T>::is_pair>> {
+    static constexpr const bool value = is_comparable<typename T::first_type>::value
+                                        && is_comparable<typename T::second_type>::value;
+};
+
+/* Fallback functions */
+template <typename, typename, typename... Args>
+void vector_if_copy_constructible(const Args &...) {}
+template <typename, typename, typename... Args>
+void vector_if_equal_operator(const Args &...) {}
+template <typename, typename, typename... Args>
+void vector_if_insertion_operator(const Args &...) {}
+template <typename, typename, typename... Args>
+void vector_modifiers(const Args &...) {}
+
+template <typename Vector, typename Class_>
+void vector_if_copy_constructible(enable_if_t<is_copy_constructible<Vector>::value, Class_> &cl) {
+    cl.def(init<const Vector &>(), "Copy constructor");
+}
+
+template <typename Vector, typename Class_>
+void vector_if_equal_operator(enable_if_t<is_comparable<Vector>::value, Class_> &cl) {
+    using T = typename Vector::value_type;
+
+    cl.def(self == self);
+    cl.def(self != self);
+
+    cl.def(
+        "count",
+        [](const Vector &v, const T &x) { return std::count(v.begin(), v.end(), x); },
+        arg("x"),
+        "Return the number of times ``x`` appears in the list");
+
+    cl.def(
+        "remove",
+        [](Vector &v, const T &x) {
+            auto p = std::find(v.begin(), v.end(), x);
+            if (p != v.end()) {
+                v.erase(p);
+            } else {
+                throw value_error();
+            }
+        },
+        arg("x"),
+        "Remove the first item from the list whose value is x. "
+        "It is an error if there is no such item.");
+
+    cl.def(
+        "__contains__",
+        [](const Vector &v, const T &x) { return std::find(v.begin(), v.end(), x) != v.end(); },
+        arg("x"),
+        "Return true the container contains ``x``");
+}
+
+// Vector modifiers -- requires a copyable vector_type:
+// (Technically, some of these (pop and __delitem__) don't actually require copyability, but it
+// seems silly to allow deletion but not insertion, so include them here too.)
+template <typename Vector, typename Class_>
+void vector_modifiers(
+    enable_if_t<is_copy_constructible<typename Vector::value_type>::value, Class_> &cl) {
+    using T = typename Vector::value_type;
+    using SizeType = typename Vector::size_type;
+    using DiffType = typename Vector::difference_type;
+
+    auto wrap_i = [](DiffType i, SizeType n) {
+        if (i < 0) {
+            i += n;
+        }
+        if (i < 0 || (SizeType) i >= n) {
+            throw index_error();
+        }
+        return i;
+    };
+
+    cl.def(
+        "append",
+        [](Vector &v, const T &value) { v.push_back(value); },
+        arg("x"),
+        "Add an item to the end of the list");
+
+    cl.def(init([](const iterable &it) {
+        auto v = std::unique_ptr<Vector>(new Vector());
+        v->reserve(len_hint(it));
+        for (handle h : it) {
+            v->push_back(h.cast<T>());
+        }
+        return v.release();
+    }));
+
+    cl.def("clear", [](Vector &v) { v.clear(); }, "Clear the contents");
+
+    cl.def(
+        "extend",
+        [](Vector &v, const Vector &src) { v.insert(v.end(), src.begin(), src.end()); },
+        arg("L"),
+        "Extend the list by appending all the items in the given list");
+
+    cl.def(
+        "extend",
+        [](Vector &v, const iterable &it) {
+            const size_t old_size = v.size();
+            v.reserve(old_size + len_hint(it));
+            try {
+                for (handle h : it) {
+                    v.push_back(h.cast<T>());
+                }
+            } catch (const cast_error &) {
+                v.erase(v.begin() + static_cast<typename Vector::difference_type>(old_size),
+                        v.end());
+                try {
+                    v.shrink_to_fit();
+                } catch (const std::exception &) { // NOLINT(bugprone-empty-catch)
+                    // Do nothing
+                }
+                throw;
+            }
+        },
+        arg("L"),
+        "Extend the list by appending all the items in the given list");
+
+    cl.def(
+        "insert",
+        [](Vector &v, DiffType i, const T &x) {
+            // Can't use wrap_i; i == v.size() is OK
+            if (i < 0) {
+                i += v.size();
+            }
+            if (i < 0 || (SizeType) i > v.size()) {
+                throw index_error();
+            }
+            v.insert(v.begin() + i, x);
+        },
+        arg("i"),
+        arg("x"),
+        "Insert an item at a given position.");
+
+    cl.def(
+        "pop",
+        [](Vector &v) {
+            if (v.empty()) {
+                throw index_error();
+            }
+            T t = std::move(v.back());
+            v.pop_back();
+            return t;
+        },
+        "Remove and return the last item");
+
+    cl.def(
+        "pop",
+        [wrap_i](Vector &v, DiffType i) {
+            i = wrap_i(i, v.size());
+            T t = std::move(v[(SizeType) i]);
+            v.erase(std::next(v.begin(), i));
+            return t;
+        },
+        arg("i"),
+        "Remove and return the item at index ``i``");
+
+    cl.def("__setitem__", [wrap_i](Vector &v, DiffType i, const T &t) {
+        i = wrap_i(i, v.size());
+        v[(SizeType) i] = t;
+    });
+
+    /// Slicing protocol
+    cl.def(
+        "__getitem__",
+        [](const Vector &v, const slice &slice) -> Vector * {
+            size_t start = 0, stop = 0, step = 0, slicelength = 0;
+
+            if (!slice.compute(v.size(), &start, &stop, &step, &slicelength)) {
+                throw error_already_set();
+            }
+
+            auto *seq = new Vector();
+            seq->reserve((size_t) slicelength);
+
+            for (size_t i = 0; i < slicelength; ++i) {
+                seq->push_back(v[start]);
+                start += step;
+            }
+            return seq;
+        },
+        arg("s"),
+        "Retrieve list elements using a slice object");
+
+    cl.def(
+        "__setitem__",
+        [](Vector &v, const slice &slice, const Vector &value) {
+            size_t start = 0, stop = 0, step = 0, slicelength = 0;
+            if (!slice.compute(v.size(), &start, &stop, &step, &slicelength)) {
+                throw error_already_set();
+            }
+
+            if (slicelength != value.size()) {
+                throw std::runtime_error(
+                    "Left and right hand size of slice assignment have different sizes!");
+            }
+
+            for (size_t i = 0; i < slicelength; ++i) {
+                v[start] = value[i];
+                start += step;
+            }
+        },
+        "Assign list elements using a slice object");
+
+    cl.def(
+        "__delitem__",
+        [wrap_i](Vector &v, DiffType i) {
+            i = wrap_i(i, v.size());
+            v.erase(v.begin() + i);
+        },
+        "Delete the list elements at index ``i``");
+
+    cl.def(
+        "__delitem__",
+        [](Vector &v, const slice &slice) {
+            size_t start = 0, stop = 0, step = 0, slicelength = 0;
+
+            if (!slice.compute(v.size(), &start, &stop, &step, &slicelength)) {
+                throw error_already_set();
+            }
+
+            if (step == 1 && false) {
+                v.erase(v.begin() + (DiffType) start, v.begin() + DiffType(start + slicelength));
+            } else {
+                for (size_t i = 0; i < slicelength; ++i) {
+                    v.erase(v.begin() + DiffType(start));
+                    start += step - 1;
+                }
+            }
+        },
+        "Delete list elements using a slice object");
+}
+
+// If the type has an operator[] that doesn't return a reference (most notably std::vector<bool>),
+// we have to access by copying; otherwise we return by reference.
+template <typename Vector>
+using vector_needs_copy
+    = negation<std::is_same<decltype(std::declval<Vector>()[typename Vector::size_type()]),
+                            typename Vector::value_type &>>;
+
+// The usual case: access and iterate by reference
+template <typename Vector, typename Class_>
+void vector_accessor(enable_if_t<!vector_needs_copy<Vector>::value, Class_> &cl) {
+    using T = typename Vector::value_type;
+    using SizeType = typename Vector::size_type;
+    using DiffType = typename Vector::difference_type;
+    using ItType = typename Vector::iterator;
+
+    auto wrap_i = [](DiffType i, SizeType n) {
+        if (i < 0) {
+            i += n;
+        }
+        if (i < 0 || (SizeType) i >= n) {
+            throw index_error();
+        }
+        return i;
+    };
+
+    cl.def(
+        "__getitem__",
+        [wrap_i](Vector &v, DiffType i) -> T & {
+            i = wrap_i(i, v.size());
+            return v[(SizeType) i];
+        },
+        return_value_policy::reference_internal // ref + keepalive
+    );
+
+    cl.def(
+        "__iter__",
+        [](Vector &v) {
+            return make_iterator<return_value_policy::reference_internal, ItType, ItType, T &>(
+                v.begin(), v.end());
+        },
+        keep_alive<0, 1>() /* Essential: keep list alive while iterator exists */
+    );
+}
+
+// The case for special objects, like std::vector<bool>, that have to be returned-by-copy:
+template <typename Vector, typename Class_>
+void vector_accessor(enable_if_t<vector_needs_copy<Vector>::value, Class_> &cl) {
+    using T = typename Vector::value_type;
+    using SizeType = typename Vector::size_type;
+    using DiffType = typename Vector::difference_type;
+    using ItType = typename Vector::iterator;
+    cl.def("__getitem__", [](const Vector &v, DiffType i) -> T {
+        if (i < 0) {
+            i += v.size();
+            if (i < 0) {
+                throw index_error();
+            }
+        }
+        auto i_st = static_cast<SizeType>(i);
+        if (i_st >= v.size()) {
+            throw index_error();
+        }
+        return v[i_st];
+    });
+
+    cl.def(
+        "__iter__",
+        [](Vector &v) {
+            return make_iterator<return_value_policy::copy, ItType, ItType, T>(v.begin(), v.end());
+        },
+        keep_alive<0, 1>() /* Essential: keep list alive while iterator exists */
+    );
+}
+
+template <typename Vector, typename Class_>
+auto vector_if_insertion_operator(Class_ &cl, std::string const &name)
+    -> decltype(std::declval<std::ostream &>() << std::declval<typename Vector::value_type>(),
+                void()) {
+    using size_type = typename Vector::size_type;
+
+    cl.def(
+        "__repr__",
+        [name](Vector &v) {
+            std::ostringstream s;
+            s << name << '[';
+            for (size_type i = 0; i < v.size(); ++i) {
+                s << v[i];
+                if (i != v.size() - 1) {
+                    s << ", ";
+                }
+            }
+            s << ']';
+            return s.str();
+        },
+        "Return the canonical string representation of this list.");
+}
+
+// Provide the buffer interface for vectors if we have data() and we have a format for it
+// GCC seems to have "void std::vector<bool>::data()" - doing SFINAE on the existence of data()
+// is insufficient, we need to check it returns an appropriate pointer
+template <typename Vector, typename = void>
+struct vector_has_data_and_format : std::false_type {};
+template <typename Vector>
+struct vector_has_data_and_format<
+    Vector,
+    enable_if_t<std::is_same<decltype(format_descriptor<typename Vector::value_type>::format(),
+                                      std::declval<Vector>().data()),
+                             typename Vector::value_type *>::value>> : std::true_type {};
+
+// [workaround(intel)] Separate function required here
+// Workaround as the Intel compiler does not compile the enable_if_t part below
+// (tested with icc (ICC) 2021.1 Beta 20200827)
+template <typename... Args>
+constexpr bool args_any_are_buffer() {
+    return detail::any_of<std::is_same<Args, buffer_protocol>...>::value;
+}
+
+// [workaround(intel)] Separate function required here
+// [workaround(msvc)] Can't use constexpr bool in return type
+
+// Add the buffer interface to a vector
+template <typename Vector, typename Class_, typename... Args>
+void vector_buffer_impl(Class_ &cl, std::true_type) {
+    using T = typename Vector::value_type;
+
+    static_assert(vector_has_data_and_format<Vector>::value,
+                  "There is not an appropriate format descriptor for this vector");
+
+    // numpy.h declares this for arbitrary types, but it may raise an exception and crash hard
+    // at runtime if PYBIND11_NUMPY_DTYPE hasn't been called, so check here
+    format_descriptor<T>::format();
+
+    cl.def_buffer([](Vector &v) -> buffer_info {
+        return buffer_info(v.data(),
+                           static_cast<ssize_t>(sizeof(T)),
+                           format_descriptor<T>::format(),
+                           1,
+                           {v.size()},
+                           {sizeof(T)});
+    });
+
+    cl.def(init([](const buffer &buf) {
+        auto info = buf.request();
+        if (info.ndim != 1 || info.strides[0] % static_cast<ssize_t>(sizeof(T))) {
+            throw type_error("Only valid 1D buffers can be copied to a vector");
+        }
+        if (!detail::compare_buffer_info<T>::compare(info)
+            || (ssize_t) sizeof(T) != info.itemsize) {
+            throw type_error("Format mismatch (Python: " + info.format
+                             + " C++: " + format_descriptor<T>::format() + ")");
+        }
+
+        T *p = static_cast<T *>(info.ptr);
+        ssize_t step = info.strides[0] / static_cast<ssize_t>(sizeof(T));
+        T *end = p + info.shape[0] * step;
+        if (step == 1) {
+            return Vector(p, end);
+        }
+        Vector vec;
+        vec.reserve((size_t) info.shape[0]);
+        for (; p != end; p += step) {
+            vec.push_back(*p);
+        }
+        return vec;
+    }));
+
+    return;
+}
+
+template <typename Vector, typename Class_, typename... Args>
+void vector_buffer_impl(Class_ &, std::false_type) {}
+
+template <typename Vector, typename Class_, typename... Args>
+void vector_buffer(Class_ &cl) {
+    vector_buffer_impl<Vector, Class_, Args...>(
+        cl, detail::any_of<std::is_same<Args, buffer_protocol>...>{});
+}
+
+PYBIND11_NAMESPACE_END(detail)
+
+//
+// std::vector
+//
+template <typename Vector, typename holder_type = default_holder_type<Vector>, typename... Args>
+class_<Vector, holder_type> bind_vector(handle scope, std::string const &name, Args &&...args) {
+    using Class_ = class_<Vector, holder_type>;
+
+    // If the value_type is unregistered (e.g. a converting type) or is itself registered
+    // module-local then make the vector binding module-local as well:
+    using vtype = typename Vector::value_type;
+    auto *vtype_info = detail::get_type_info(typeid(vtype));
+    bool local = !vtype_info || vtype_info->module_local;
+
+    Class_ cl(scope, name.c_str(), pybind11::module_local(local), std::forward<Args>(args)...);
+
+    // Declare the buffer interface if a buffer_protocol() is passed in
+    detail::vector_buffer<Vector, Class_, Args...>(cl);
+
+    cl.def(init<>());
+
+    // Register copy constructor (if possible)
+    detail::vector_if_copy_constructible<Vector, Class_>(cl);
+
+    // Register comparison-related operators and functions (if possible)
+    detail::vector_if_equal_operator<Vector, Class_>(cl);
+
+    // Register stream insertion operator (if possible)
+    detail::vector_if_insertion_operator<Vector, Class_>(cl, name);
+
+    // Modifiers require copyable vector value type
+    detail::vector_modifiers<Vector, Class_>(cl);
+
+    // Accessor and iterator; return by value if copyable, otherwise we return by ref + keep-alive
+    detail::vector_accessor<Vector, Class_>(cl);
+
+    cl.def(
+        "__bool__",
+        [](const Vector &v) -> bool { return !v.empty(); },
+        "Check whether the list is nonempty");
+
+    cl.def("__len__", [](const Vector &vec) { return vec.size(); });
+
+#if 0
+    // C++ style functions deprecated, leaving it here as an example
+    cl.def(init<size_type>());
+
+    cl.def("resize",
+         (void (Vector::*) (size_type count)) & Vector::resize,
+         "changes the number of elements stored");
+
+    cl.def("erase",
+        [](Vector &v, SizeType i) {
+        if (i >= v.size())
+            throw index_error();
+        v.erase(v.begin() + i);
+    }, "erases element at index ``i``");
+
+    cl.def("empty",         &Vector::empty,         "checks whether the container is empty");
+    cl.def("size",          &Vector::size,          "returns the number of elements");
+    cl.def("push_back", (void (Vector::*)(const T&)) &Vector::push_back, "adds an element to the end");
+    cl.def("pop_back",                               &Vector::pop_back, "removes the last element");
+
+    cl.def("max_size",      &Vector::max_size,      "returns the maximum possible number of elements");
+    cl.def("reserve",       &Vector::reserve,       "reserves storage");
+    cl.def("capacity",      &Vector::capacity,      "returns the number of elements that can be held in currently allocated storage");
+    cl.def("shrink_to_fit", &Vector::shrink_to_fit, "reduces memory usage by freeing unused memory");
+
+    cl.def("clear", &Vector::clear, "clears the contents");
+    cl.def("swap",   &Vector::swap, "swaps the contents");
+
+    cl.def("front", [](Vector &v) {
+        if (v.size()) return v.front();
+        else throw index_error();
+    }, "access the first element");
+
+    cl.def("back", [](Vector &v) {
+        if (v.size()) return v.back();
+        else throw index_error();
+    }, "access the last element ");
+
+#endif
+
+    return cl;
+}
+
+//
+// std::map, std::unordered_map
+//
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+/* Fallback functions */
+template <typename, typename, typename... Args>
+void map_if_insertion_operator(const Args &...) {}
+template <typename, typename, typename... Args>
+void map_assignment(const Args &...) {}
+
+// Map assignment when copy-assignable: just copy the value
+template <typename Map, typename Class_>
+void map_assignment(
+    enable_if_t<is_copy_assignable<typename Map::mapped_type>::value, Class_> &cl) {
+    using KeyType = typename Map::key_type;
+    using MappedType = typename Map::mapped_type;
+
+    cl.def("__setitem__", [](Map &m, const KeyType &k, const MappedType &v) {
+        auto it = m.find(k);
+        if (it != m.end()) {
+            it->second = v;
+        } else {
+            m.emplace(k, v);
+        }
+    });
+}
+
+// Not copy-assignable, but still copy-constructible: we can update the value by erasing and
+// reinserting
+template <typename Map, typename Class_>
+void map_assignment(enable_if_t<!is_copy_assignable<typename Map::mapped_type>::value
+                                    && is_copy_constructible<typename Map::mapped_type>::value,
+                                Class_> &cl) {
+    using KeyType = typename Map::key_type;
+    using MappedType = typename Map::mapped_type;
+
+    cl.def("__setitem__", [](Map &m, const KeyType &k, const MappedType &v) {
+        // We can't use m[k] = v; because value type might not be default constructable
+        auto r = m.emplace(k, v);
+        if (!r.second) {
+            // value type is not copy assignable so the only way to insert it is to erase it
+            // first...
+            m.erase(r.first);
+            m.emplace(k, v);
+        }
+    });
+}
+
+template <typename Map, typename Class_>
+auto map_if_insertion_operator(Class_ &cl, std::string const &name)
+    -> decltype(std::declval<std::ostream &>() << std::declval<typename Map::key_type>()
+                                               << std::declval<typename Map::mapped_type>(),
+                void()) {
+
+    cl.def(
+        "__repr__",
+        [name](Map &m) {
+            std::ostringstream s;
+            s << name << '{';
+            bool f = false;
+            for (auto const &kv : m) {
+                if (f) {
+                    s << ", ";
+                }
+                s << kv.first << ": " << kv.second;
+                f = true;
+            }
+            s << '}';
+            return s.str();
+        },
+        "Return the canonical string representation of this map.");
+}
+
+struct keys_view {
+    virtual size_t len() = 0;
+    virtual iterator iter() = 0;
+    virtual bool contains(const handle &k) = 0;
+    virtual ~keys_view() = default;
+};
+
+struct values_view {
+    virtual size_t len() = 0;
+    virtual iterator iter() = 0;
+    virtual ~values_view() = default;
+};
+
+struct items_view {
+    virtual size_t len() = 0;
+    virtual iterator iter() = 0;
+    virtual ~items_view() = default;
+};
+
+template <typename Map>
+struct KeysViewImpl : public detail::keys_view {
+    explicit KeysViewImpl(Map &map) : map(map) {}
+    size_t len() override { return map.size(); }
+    iterator iter() override { return make_key_iterator(map.begin(), map.end()); }
+    bool contains(const handle &k) override {
+        try {
+            return map.find(k.template cast<typename Map::key_type>()) != map.end();
+        } catch (const cast_error &) {
+            return false;
+        }
+    }
+    Map &map;
+};
+
+template <typename Map>
+struct ValuesViewImpl : public detail::values_view {
+    explicit ValuesViewImpl(Map &map) : map(map) {}
+    size_t len() override { return map.size(); }
+    iterator iter() override { return make_value_iterator(map.begin(), map.end()); }
+    Map &map;
+};
+
+template <typename Map>
+struct ItemsViewImpl : public detail::items_view {
+    explicit ItemsViewImpl(Map &map) : map(map) {}
+    size_t len() override { return map.size(); }
+    iterator iter() override { return make_iterator(map.begin(), map.end()); }
+    Map &map;
+};
+
+inline str format_message_key_error_key_object(handle py_key) {
+    str message = "pybind11::bind_map key";
+    if (!py_key) {
+        return message;
+    }
+    try {
+        message = str(py_key);
+    } catch (const std::exception &) {
+        try {
+            message = repr(py_key);
+        } catch (const std::exception &) {
+            return message;
+        }
+    }
+    const ssize_t cut_length = 100;
+    if (len(message) > 2 * cut_length + 3) {
+        return str(message[slice(0, cut_length, 1)]) + str("✄✄✄")
+               + str(message[slice(-cut_length, static_cast<ssize_t>(len(message)), 1)]);
+    }
+    return message;
+}
+
+template <typename KeyType>
+str format_message_key_error(const KeyType &key) {
+    object py_key;
+    try {
+        py_key = cast(key);
+    } catch (const std::exception &) {
+        do { // Trick to avoid "empty catch" warning/error.
+        } while (false);
+    }
+    return format_message_key_error_key_object(py_key);
+}
+
+PYBIND11_NAMESPACE_END(detail)
+
+template <typename Map, typename holder_type = default_holder_type<Map>, typename... Args>
+class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args &&...args) {
+    using KeyType = typename Map::key_type;
+    using MappedType = typename Map::mapped_type;
+    using KeysView = detail::keys_view;
+    using ValuesView = detail::values_view;
+    using ItemsView = detail::items_view;
+    using Class_ = class_<Map, holder_type>;
+
+    // If either type is a non-module-local bound type then make the map binding non-local as well;
+    // otherwise (e.g. both types are either module-local or converting) the map will be
+    // module-local.
+    auto *tinfo = detail::get_type_info(typeid(MappedType));
+    bool local = !tinfo || tinfo->module_local;
+    if (local) {
+        tinfo = detail::get_type_info(typeid(KeyType));
+        local = !tinfo || tinfo->module_local;
+    }
+
+    Class_ cl(scope, name.c_str(), pybind11::module_local(local), std::forward<Args>(args)...);
+
+    // Wrap KeysView if it wasn't already wrapped
+    if (!detail::get_type_info(typeid(KeysView))) {
+        class_<KeysView> keys_view(scope, "KeysView", pybind11::module_local(local));
+        keys_view.def("__len__", &KeysView::len);
+        keys_view.def("__iter__",
+                      &KeysView::iter,
+                      keep_alive<0, 1>() /* Essential: keep view alive while iterator exists */
+        );
+        keys_view.def("__contains__", &KeysView::contains);
+    }
+    // Similarly for ValuesView:
+    if (!detail::get_type_info(typeid(ValuesView))) {
+        class_<ValuesView> values_view(scope, "ValuesView", pybind11::module_local(local));
+        values_view.def("__len__", &ValuesView::len);
+        values_view.def("__iter__",
+                        &ValuesView::iter,
+                        keep_alive<0, 1>() /* Essential: keep view alive while iterator exists */
+        );
+    }
+    // Similarly for ItemsView:
+    if (!detail::get_type_info(typeid(ItemsView))) {
+        class_<ItemsView> items_view(scope, "ItemsView", pybind11::module_local(local));
+        items_view.def("__len__", &ItemsView::len);
+        items_view.def("__iter__",
+                       &ItemsView::iter,
+                       keep_alive<0, 1>() /* Essential: keep view alive while iterator exists */
+        );
+    }
+
+    cl.def(init<>());
+
+    // Register stream insertion operator (if possible)
+    detail::map_if_insertion_operator<Map, Class_>(cl, name);
+
+    cl.def(
+        "__bool__",
+        [](const Map &m) -> bool { return !m.empty(); },
+        "Check whether the map is nonempty");
+
+    cl.def(
+        "__iter__",
+        [](Map &m) { return make_key_iterator(m.begin(), m.end()); },
+        keep_alive<0, 1>() /* Essential: keep map alive while iterator exists */
+    );
+
+    cl.def(
+        "keys",
+        [](Map &m) { return std::unique_ptr<KeysView>(new detail::KeysViewImpl<Map>(m)); },
+        keep_alive<0, 1>() /* Essential: keep map alive while view exists */
+    );
+
+    cl.def(
+        "values",
+        [](Map &m) { return std::unique_ptr<ValuesView>(new detail::ValuesViewImpl<Map>(m)); },
+        keep_alive<0, 1>() /* Essential: keep map alive while view exists */
+    );
+
+    cl.def(
+        "items",
+        [](Map &m) { return std::unique_ptr<ItemsView>(new detail::ItemsViewImpl<Map>(m)); },
+        keep_alive<0, 1>() /* Essential: keep map alive while view exists */
+    );
+
+    cl.def(
+        "__getitem__",
+        [](Map &m, const KeyType &k) -> MappedType & {
+            auto it = m.find(k);
+            if (it == m.end()) {
+                set_error(PyExc_KeyError, detail::format_message_key_error(k));
+                throw error_already_set();
+            }
+            return it->second;
+        },
+        return_value_policy::reference_internal // ref + keepalive
+    );
+
+    cl.def("__contains__", [](Map &m, const KeyType &k) -> bool {
+        auto it = m.find(k);
+        if (it == m.end()) {
+            return false;
+        }
+        return true;
+    });
+    // Fallback for when the object is not of the key type
+    cl.def("__contains__", [](Map &, const object &) -> bool { return false; });
+
+    // Assignment provided only if the type is copyable
+    detail::map_assignment<Map, Class_>(cl);
+
+    cl.def("__delitem__", [](Map &m, const KeyType &k) {
+        auto it = m.find(k);
+        if (it == m.end()) {
+            set_error(PyExc_KeyError, detail::format_message_key_error(k));
+            throw error_already_set();
+        }
+        m.erase(it);
+    });
+
+    // Always use a lambda in case of `using` declaration
+    cl.def("__len__", [](const Map &m) { return m.size(); });
+
+    return cl;
+}
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/subinterpreter.h b/local_pybind11/pybind11/include/pybind11/subinterpreter.h
new file mode 100644
index 000000000..4b208ed9b
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/subinterpreter.h
@@ -0,0 +1,299 @@
+/*
+    pybind11/subinterpreter.h: Support for creating and using subinterpreters
+
+    Copyright (c) 2025 The Pybind Development Team.
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "detail/common.h"
+#include "detail/internals.h"
+#include "gil.h"
+
+#include <stdexcept>
+
+#ifndef PYBIND11_HAS_SUBINTERPRETER_SUPPORT
+#    error "This platform does not support subinterpreters, do not include this file."
+#endif
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+inline PyInterpreterState *get_interpreter_state_unchecked() {
+    auto cur_tstate = get_thread_state_unchecked();
+    if (cur_tstate)
+        return cur_tstate->interp;
+    else
+        return nullptr;
+}
+PYBIND11_NAMESPACE_END(detail)
+
+class subinterpreter;
+
+/// Activate the subinterpreter and acquire its GIL, while also releasing any GIL and interpreter
+/// currently held. Upon exiting the scope, the previous subinterpreter (if any) and its
+/// associated GIL are restored to their state as they were before the scope was entered.
+class subinterpreter_scoped_activate {
+public:
+    explicit subinterpreter_scoped_activate(subinterpreter const &si);
+    ~subinterpreter_scoped_activate();
+
+    subinterpreter_scoped_activate(subinterpreter_scoped_activate &&) = delete;
+    subinterpreter_scoped_activate(subinterpreter_scoped_activate const &) = delete;
+    subinterpreter_scoped_activate &operator=(subinterpreter_scoped_activate &) = delete;
+    subinterpreter_scoped_activate &operator=(subinterpreter_scoped_activate const &) = delete;
+
+private:
+    PyThreadState *old_tstate_ = nullptr;
+    PyThreadState *tstate_ = nullptr;
+    PyGILState_STATE gil_state_;
+    bool simple_gil_ = false;
+};
+
+/// Holds a Python subinterpreter instance
+class subinterpreter {
+public:
+    /// empty/unusable, but move-assignable.  use create() to create a subinterpreter.
+    subinterpreter() = default;
+
+    subinterpreter(subinterpreter const &copy) = delete;
+    subinterpreter &operator=(subinterpreter const &copy) = delete;
+
+    subinterpreter(subinterpreter &&old) noexcept
+        : istate_(old.istate_), creation_tstate_(old.creation_tstate_) {
+        old.istate_ = nullptr;
+        old.creation_tstate_ = nullptr;
+    }
+
+    subinterpreter &operator=(subinterpreter &&old) noexcept {
+        std::swap(old.istate_, istate_);
+        std::swap(old.creation_tstate_, creation_tstate_);
+        return *this;
+    }
+
+    /// Create a new subinterpreter with the specified configuration
+    /// @note This function acquires (and then releases) the main interpreter GIL, but the main
+    /// interpreter and its GIL are not required to be held prior to calling this function.
+    static inline subinterpreter create(PyInterpreterConfig const &cfg) {
+
+        error_scope err_scope;
+        subinterpreter result;
+        {
+            // we must hold the main GIL in order to create a subinterpreter
+            subinterpreter_scoped_activate main_guard(main());
+
+            auto prev_tstate = PyThreadState_Get();
+
+            PyStatus status;
+
+            {
+                /*
+                Several internal CPython modules are lacking proper subinterpreter support in 3.12
+                even though it is "stable" in that version.  This most commonly seems to cause
+                crashes when two interpreters concurrently initialize, which imports several things
+                (like builtins, unicode, codecs).
+                */
+#if PY_VERSION_HEX < 0x030D0000 && defined(Py_MOD_PER_INTERPRETER_GIL_SUPPORTED)
+                static std::mutex one_at_a_time;
+                std::lock_guard<std::mutex> guard(one_at_a_time);
+#endif
+                status = Py_NewInterpreterFromConfig(&result.creation_tstate_, &cfg);
+            }
+
+            // this doesn't raise a normal Python exception, it provides an exit() status code.
+            if (PyStatus_Exception(status)) {
+                pybind11_fail("failed to create new sub-interpreter");
+            }
+
+            // upon success, the new interpreter is activated in this thread
+            result.istate_ = result.creation_tstate_->interp;
+            detail::get_num_interpreters_seen() += 1; // there are now many interpreters
+            detail::get_internals(); // initialize internals.tstate, amongst other things...
+
+            // In 3.13+ this state should be deleted right away, and the memory will be reused for
+            // the next threadstate on this interpreter. However, on 3.12 we cannot do that, we
+            // must keep it around (but not use it) ... see destructor.
+#if PY_VERSION_HEX >= 0x030D0000
+            PyThreadState_Clear(result.creation_tstate_);
+            PyThreadState_DeleteCurrent();
+#endif
+
+            // we have to switch back to main, and then the scopes will handle cleanup
+            PyThreadState_Swap(prev_tstate);
+        }
+        return result;
+    }
+
+    /// Calls create() with a default configuration of an isolated interpreter that disallows fork,
+    /// exec, and Python threads.
+    static inline subinterpreter create() {
+        // same as the default config in the python docs
+        PyInterpreterConfig cfg;
+        std::memset(&cfg, 0, sizeof(cfg));
+        cfg.allow_threads = 1;
+        cfg.check_multi_interp_extensions = 1;
+        cfg.gil = PyInterpreterConfig_OWN_GIL;
+        return create(cfg);
+    }
+
+    ~subinterpreter() {
+        if (!creation_tstate_) {
+            // non-owning wrapper, do nothing.
+            return;
+        }
+
+        PyThreadState *destroy_tstate;
+        PyThreadState *old_tstate;
+
+        // Python 3.12 requires us to keep the original PyThreadState alive until we are ready to
+        // destroy the interpreter.  We prefer to use that to destroy the interpreter.
+#if PY_VERSION_HEX < 0x030D0000
+        // The tstate passed to Py_EndInterpreter MUST have been created on the current OS thread.
+        bool same_thread = false;
+#    ifdef PY_HAVE_THREAD_NATIVE_ID
+        same_thread = PyThread_get_thread_native_id() == creation_tstate_->native_thread_id;
+#    endif
+        if (same_thread) {
+            // OK it is safe to use the creation state here
+            destroy_tstate = creation_tstate_;
+            old_tstate = PyThreadState_Swap(destroy_tstate);
+        } else {
+            // We have to make a new tstate on this thread and use that.
+            destroy_tstate = PyThreadState_New(istate_);
+            old_tstate = PyThreadState_Swap(destroy_tstate);
+
+            // We can use the one we just created, so we must delete the creation state.
+            PyThreadState_Clear(creation_tstate_);
+            PyThreadState_Delete(creation_tstate_);
+        }
+#else
+        destroy_tstate = PyThreadState_New(istate_);
+        old_tstate = PyThreadState_Swap(destroy_tstate);
+#endif
+
+        bool switch_back = old_tstate && old_tstate->interp != istate_;
+
+        // Internals always exists in the subinterpreter, this class enforces it when it creates
+        // the subinterpreter. Even if it didn't, this only creates the pointer-to-pointer, not the
+        // internals themselves.
+        detail::get_internals_pp_manager().get_pp();
+        detail::get_local_internals_pp_manager().get_pp();
+
+        // End it
+        Py_EndInterpreter(destroy_tstate);
+
+        // It's possible for the  internals to be created during endinterpreter (e.g. if a
+        // py::capsule calls `get_internals()` during destruction), so we destroy afterward.
+        detail::get_internals_pp_manager().destroy();
+        detail::get_local_internals_pp_manager().destroy();
+
+        // switch back to the old tstate and old GIL (if there was one)
+        if (switch_back)
+            PyThreadState_Swap(old_tstate);
+    }
+
+    /// Get a handle to the main interpreter that can be used with subinterpreter_scoped_activate
+    /// Note that destructing the handle is a noop, the main interpreter can only be ended by
+    /// py::finalize_interpreter()
+    static subinterpreter main() {
+        subinterpreter m;
+        m.istate_ = PyInterpreterState_Main();
+        m.disarm(); // make destruct a noop
+        return m;
+    }
+
+    /// Get a non-owning wrapper of the currently active interpreter (if any)
+    static subinterpreter current() {
+        subinterpreter c;
+        c.istate_ = detail::get_interpreter_state_unchecked();
+        c.disarm(); // make destruct a noop, we don't own this...
+        return c;
+    }
+
+    /// Get the numerical identifier for the sub-interpreter
+    int64_t id() const {
+        if (istate_ != nullptr)
+            return PyInterpreterState_GetID(istate_);
+        else
+            return -1; // CPython uses one-up numbers from 0, so negative should be safe to return
+                       // here.
+    }
+
+    /// Get the interpreter's state dict.  This interpreter's GIL must be held before calling!
+    dict state_dict() { return reinterpret_borrow<dict>(PyInterpreterState_GetDict(istate_)); }
+
+    /// abandon cleanup of this subinterpreter (leak it). this might be needed during
+    /// finalization...
+    void disarm() { creation_tstate_ = nullptr; }
+
+    /// An empty wrapper cannot be activated
+    bool empty() const { return istate_ == nullptr; }
+
+    /// Is this wrapper non-empty
+    explicit operator bool() const { return !empty(); }
+
+private:
+    friend class subinterpreter_scoped_activate;
+    PyInterpreterState *istate_ = nullptr;
+    PyThreadState *creation_tstate_ = nullptr;
+};
+
+class scoped_subinterpreter {
+public:
+    scoped_subinterpreter() : si_(subinterpreter::create()), scope_(si_) {}
+
+    explicit scoped_subinterpreter(PyInterpreterConfig const &cfg)
+        : si_(subinterpreter::create(cfg)), scope_(si_) {}
+
+private:
+    subinterpreter si_;
+    subinterpreter_scoped_activate scope_;
+};
+
+inline subinterpreter_scoped_activate::subinterpreter_scoped_activate(subinterpreter const &si) {
+    if (!si.istate_) {
+        pybind11_fail("null subinterpreter");
+    }
+
+    if (detail::get_interpreter_state_unchecked() == si.istate_) {
+        // we are already on this interpreter, make sure we hold the GIL
+        simple_gil_ = true;
+        gil_state_ = PyGILState_Ensure();
+        return;
+    }
+
+    // we can't really interact with the interpreter at all until we switch to it
+    // not even to, for example, look in its state dict or touch its internals
+    tstate_ = PyThreadState_New(si.istate_);
+
+    // make the interpreter active and acquire the GIL
+    old_tstate_ = PyThreadState_Swap(tstate_);
+
+    // save this in internals for scoped_gil calls
+    detail::get_internals().tstate = tstate_;
+}
+
+inline subinterpreter_scoped_activate::~subinterpreter_scoped_activate() {
+    if (simple_gil_) {
+        // We were on this interpreter already, so just make sure the GIL goes back as it was
+        PyGILState_Release(gil_state_);
+    } else {
+        if (tstate_) {
+#if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
+            if (detail::get_thread_state_unchecked() != tstate_) {
+                pybind11_fail("~subinterpreter_scoped_activate: thread state must be current!");
+            }
+#endif
+            detail::get_internals().tstate.reset();
+            PyThreadState_Clear(tstate_);
+            PyThreadState_DeleteCurrent();
+        }
+
+        // Go back the previous interpreter (if any) and acquire THAT gil
+        PyThreadState_Swap(old_tstate_);
+    }
+}
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/trampoline_self_life_support.h b/local_pybind11/pybind11/include/pybind11/trampoline_self_life_support.h
new file mode 100644
index 000000000..cbfec7f97
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/trampoline_self_life_support.h
@@ -0,0 +1,65 @@
+// Copyright (c) 2021 The Pybind Development Team.
+// All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#pragma once
+
+#include "detail/common.h"
+#include "detail/using_smart_holder.h"
+#include "detail/value_and_holder.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+// PYBIND11:REMINDER: Needs refactoring of existing pybind11 code.
+inline bool deregister_instance(instance *self, void *valptr, const type_info *tinfo);
+PYBIND11_NAMESPACE_END(detail)
+
+// The original core idea for this struct goes back to PyCLIF:
+// https://github.com/google/clif/blob/07f95d7e69dca2fcf7022978a55ef3acff506c19/clif/python/runtime.cc#L37
+// URL provided here mainly to give proper credit.
+struct trampoline_self_life_support {
+    // NOTE: PYBIND11_INTERNALS_VERSION needs to be bumped if changes are made to this struct.
+    detail::value_and_holder v_h;
+
+    trampoline_self_life_support() = default;
+
+    void activate_life_support(const detail::value_and_holder &v_h_) {
+        Py_INCREF((PyObject *) v_h_.inst);
+        v_h = v_h_;
+    }
+
+    void deactivate_life_support() {
+        Py_DECREF((PyObject *) v_h.inst);
+        v_h = detail::value_and_holder();
+    }
+
+    ~trampoline_self_life_support() {
+        if (v_h.inst != nullptr && v_h.vh != nullptr) {
+            void *value_void_ptr = v_h.value_ptr();
+            if (value_void_ptr != nullptr) {
+                PyGILState_STATE threadstate = PyGILState_Ensure();
+                v_h.value_ptr() = nullptr;
+                v_h.holder<smart_holder>().release_disowned();
+                detail::deregister_instance(v_h.inst, value_void_ptr, v_h.type);
+                Py_DECREF((PyObject *) v_h.inst); // Must be after deregister.
+                PyGILState_Release(threadstate);
+            }
+        }
+    }
+
+    // For the next two, the default implementations generate undefined behavior (ASAN failures
+    // manually verified). The reason is that v_h needs to be kept default-initialized.
+    trampoline_self_life_support(const trampoline_self_life_support &) {}
+    trampoline_self_life_support(trampoline_self_life_support &&) noexcept {}
+
+    // These should never be needed (please provide test cases if you think they are).
+    trampoline_self_life_support &operator=(const trampoline_self_life_support &) = delete;
+    trampoline_self_life_support &operator=(trampoline_self_life_support &&) = delete;
+};
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+using get_trampoline_self_life_support_fn = trampoline_self_life_support *(*) (void *);
+PYBIND11_NAMESPACE_END(detail)
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/type_caster_pyobject_ptr.h b/local_pybind11/pybind11/include/pybind11/type_caster_pyobject_ptr.h
new file mode 100644
index 000000000..aa914f9e1
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/type_caster_pyobject_ptr.h
@@ -0,0 +1,61 @@
+// Copyright (c) 2023 The pybind Community.
+
+#pragma once
+
+#include "detail/common.h"
+#include "detail/descr.h"
+#include "cast.h"
+#include "pytypes.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+template <>
+class type_caster<PyObject> {
+public:
+    static constexpr auto name = const_name("object"); // See discussion under PR #4601.
+
+    // This overload is purely to guard against accidents.
+    template <typename T,
+              detail::enable_if_t<!is_same_ignoring_cvref<T, PyObject *>::value, int> = 0>
+    static handle cast(T &&, return_value_policy, handle /*parent*/) {
+        static_assert(is_same_ignoring_cvref<T, PyObject *>::value,
+                      "Invalid C++ type T for to-Python conversion (type_caster<PyObject>).");
+        return nullptr; // Unreachable.
+    }
+
+    static handle cast(PyObject *src, return_value_policy policy, handle /*parent*/) {
+        if (src == nullptr) {
+            throw error_already_set();
+        }
+        if (PyErr_Occurred()) {
+            raise_from(PyExc_SystemError, "src != nullptr but PyErr_Occurred()");
+            throw error_already_set();
+        }
+        if (policy == return_value_policy::take_ownership) {
+            return src;
+        }
+        if (policy == return_value_policy::reference
+            || policy == return_value_policy::automatic_reference) {
+            return handle(src).inc_ref();
+        }
+        pybind11_fail("type_caster<PyObject>::cast(): unsupported return_value_policy: "
+                      + std::to_string(static_cast<int>(policy)));
+    }
+
+    bool load(handle src, bool) {
+        value = reinterpret_borrow<object>(src);
+        return true;
+    }
+
+    template <typename T>
+    using cast_op_type = PyObject *;
+
+    explicit operator PyObject *() { return value.ptr(); }
+
+private:
+    object value;
+};
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/typing.h b/local_pybind11/pybind11/include/pybind11/typing.h
new file mode 100644
index 000000000..1715026ef
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/typing.h
@@ -0,0 +1,298 @@
+/*
+    pybind11/typing.h: Convenience wrapper classes for basic Python types
+    with more explicit annotations.
+
+    Copyright (c) 2023 Dustin Spicuzza <dustin@virtualroadside.com>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "detail/common.h"
+#include "cast.h"
+#include "pytypes.h"
+
+#include <algorithm>
+
+#if defined(__cpp_nontype_template_args) && __cpp_nontype_template_args >= 201911L
+#    define PYBIND11_TYPING_H_HAS_STRING_LITERAL
+#    include <numeric>
+#    include <ranges>
+#    include <string_view>
+#endif
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(typing)
+
+/*
+    The following types can be used to direct pybind11-generated docstrings
+    to have have more explicit types (e.g., `list[str]` instead of `list`).
+    Just use these in place of existing types.
+
+    There is no additional enforcement of types at runtime.
+*/
+
+template <typename... Types>
+class Tuple : public tuple {
+    using tuple::tuple;
+};
+
+template <typename K, typename V>
+class Dict : public dict {
+    using dict::dict;
+};
+
+template <typename T>
+class List : public list {
+    using list::list;
+};
+
+template <typename T>
+class Set : public set {
+    using set::set;
+};
+
+template <typename T>
+class Iterable : public iterable {
+    using iterable::iterable;
+};
+
+template <typename T>
+class Iterator : public iterator {
+    using iterator::iterator;
+};
+
+template <typename Signature>
+class Callable;
+
+template <typename Return, typename... Args>
+class Callable<Return(Args...)> : public function {
+    using function::function;
+};
+
+template <typename T>
+class Type : public type {
+    using type::type;
+};
+
+template <typename... Types>
+class Union : public object {
+    PYBIND11_OBJECT_DEFAULT(Union, object, PyObject_Type)
+    using object::object;
+};
+
+template <typename T>
+class Optional : public object {
+    PYBIND11_OBJECT_DEFAULT(Optional, object, PyObject_Type)
+    using object::object;
+};
+
+template <typename T>
+class Final : public object {
+    PYBIND11_OBJECT_DEFAULT(Final, object, PyObject_Type)
+    using object::object;
+};
+
+template <typename T>
+class ClassVar : public object {
+    PYBIND11_OBJECT_DEFAULT(ClassVar, object, PyObject_Type)
+    using object::object;
+};
+
+template <typename T>
+class TypeGuard : public bool_ {
+    using bool_::bool_;
+};
+
+template <typename T>
+class TypeIs : public bool_ {
+    using bool_::bool_;
+};
+
+class NoReturn : public none {
+    using none::none;
+};
+
+class Never : public none {
+    using none::none;
+};
+
+#if defined(PYBIND11_TYPING_H_HAS_STRING_LITERAL)
+template <size_t N>
+struct StringLiteral {
+    constexpr StringLiteral(const char (&str)[N]) { std::copy_n(str, N, name); }
+    char name[N];
+};
+
+template <StringLiteral... StrLits>
+class Literal : public object {
+    PYBIND11_OBJECT_DEFAULT(Literal, object, PyObject_Type)
+};
+
+// Example syntax for creating a TypeVar.
+// typedef typing::TypeVar<"T"> TypeVarT;
+template <StringLiteral>
+class TypeVar : public object {
+    PYBIND11_OBJECT_DEFAULT(TypeVar, object, PyObject_Type)
+    using object::object;
+};
+#endif
+
+PYBIND11_NAMESPACE_END(typing)
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+template <typename... Types>
+struct handle_type_name<typing::Tuple<Types...>> {
+    static constexpr auto name = const_name("tuple[")
+                                 + ::pybind11::detail::concat(make_caster<Types>::name...)
+                                 + const_name("]");
+};
+
+template <>
+struct handle_type_name<typing::Tuple<>> {
+    // PEP 484 specifies this syntax for an empty tuple
+    static constexpr auto name = const_name("tuple[()]");
+};
+
+template <typename T>
+struct handle_type_name<typing::Tuple<T, ellipsis>> {
+    // PEP 484 specifies this syntax for a variable-length tuple
+    static constexpr auto name
+        = const_name("tuple[") + make_caster<T>::name + const_name(", ...]");
+};
+
+template <typename K, typename V>
+struct handle_type_name<typing::Dict<K, V>> {
+    static constexpr auto name = const_name("dict[") + make_caster<K>::name + const_name(", ")
+                                 + make_caster<V>::name + const_name("]");
+};
+
+template <typename T>
+struct handle_type_name<typing::List<T>> {
+    static constexpr auto name = const_name("list[") + make_caster<T>::name + const_name("]");
+};
+
+template <typename T>
+struct handle_type_name<typing::Set<T>> {
+    static constexpr auto name = const_name("set[") + make_caster<T>::name + const_name("]");
+};
+
+template <typename T>
+struct handle_type_name<typing::Iterable<T>> {
+    static constexpr auto name
+        = const_name("collections.abc.Iterable[") + make_caster<T>::name + const_name("]");
+};
+
+template <typename T>
+struct handle_type_name<typing::Iterator<T>> {
+    static constexpr auto name
+        = const_name("collections.abc.Iterator[") + make_caster<T>::name + const_name("]");
+};
+
+template <typename Return, typename... Args>
+struct handle_type_name<typing::Callable<Return(Args...)>> {
+    using retval_type = conditional_t<std::is_same<Return, void>::value, void_type, Return>;
+    static constexpr auto name
+        = const_name("collections.abc.Callable[[")
+          + ::pybind11::detail::concat(::pybind11::detail::arg_descr(make_caster<Args>::name)...)
+          + const_name("], ") + ::pybind11::detail::return_descr(make_caster<retval_type>::name)
+          + const_name("]");
+};
+
+template <typename Return>
+struct handle_type_name<typing::Callable<Return(ellipsis)>> {
+    // PEP 484 specifies this syntax for defining only return types of callables
+    using retval_type = conditional_t<std::is_same<Return, void>::value, void_type, Return>;
+    static constexpr auto name = const_name("collections.abc.Callable[..., ")
+                                 + ::pybind11::detail::return_descr(make_caster<retval_type>::name)
+                                 + const_name("]");
+};
+
+template <typename T>
+struct handle_type_name<typing::Type<T>> {
+    static constexpr auto name = const_name("type[") + make_caster<T>::name + const_name("]");
+};
+
+template <typename... Types>
+struct handle_type_name<typing::Union<Types...>> {
+    static constexpr auto name = ::pybind11::detail::union_concat(make_caster<Types>::name...);
+};
+
+template <typename T>
+struct handle_type_name<typing::Optional<T>> {
+    static constexpr auto name = make_caster<T>::name | make_caster<none>::name;
+};
+
+template <typename T>
+struct handle_type_name<typing::Final<T>> {
+    static constexpr auto name = const_name("typing.Final[")
+                                 + ::pybind11::detail::return_descr(make_caster<T>::name)
+                                 + const_name("]");
+};
+
+template <typename T>
+struct handle_type_name<typing::ClassVar<T>> {
+    static constexpr auto name
+        = const_name("typing.ClassVar[") + make_caster<T>::name + const_name("]");
+};
+
+template <typename T>
+struct handle_type_name<typing::TypeGuard<T>> {
+    static constexpr auto name = const_name(PYBIND11_TYPE_GUARD_TYPE_HINT) + const_name("[")
+                                 + make_caster<T>::name + const_name("]");
+};
+
+template <typename T>
+struct handle_type_name<typing::TypeIs<T>> {
+    static constexpr auto name = const_name(PYBIND11_TYPE_IS_TYPE_HINT) + const_name("[")
+                                 + make_caster<T>::name + const_name("]");
+};
+
+template <>
+struct handle_type_name<typing::NoReturn> {
+    static constexpr auto name = const_name("typing.NoReturn");
+};
+
+template <>
+struct handle_type_name<typing::Never> {
+    static constexpr auto name = const_name(PYBIND11_NEVER_TYPE_HINT);
+};
+
+#if defined(PYBIND11_TYPING_H_HAS_STRING_LITERAL)
+template <typing::StringLiteral StrLit>
+consteval auto sanitize_string_literal() {
+    constexpr std::string_view v(StrLit.name);
+    constexpr std::string_view special_chars("!@%{}-");
+    constexpr auto num_special_chars = std::accumulate(
+        special_chars.begin(), special_chars.end(), (size_t) 0, [&v](auto acc, const char &c) {
+            return std::move(acc) + std::ranges::count(v, c);
+        });
+    char result[v.size() + num_special_chars + 1];
+    size_t i = 0;
+    for (auto c : StrLit.name) {
+        if (special_chars.find(c) != std::string_view::npos) {
+            result[i++] = '!';
+        }
+        result[i++] = c;
+    }
+    return typing::StringLiteral(result);
+}
+
+template <typing::StringLiteral... Literals>
+struct handle_type_name<typing::Literal<Literals...>> {
+    static constexpr auto name
+        = const_name("typing.Literal[")
+          + pybind11::detail::concat(const_name(sanitize_string_literal<Literals>().name)...)
+          + const_name("]");
+};
+template <typing::StringLiteral StrLit>
+struct handle_type_name<typing::TypeVar<StrLit>> {
+    static constexpr auto name = const_name(sanitize_string_literal<StrLit>().name);
+};
+#endif
+
+PYBIND11_NAMESPACE_END(detail)
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/include/pybind11/warnings.h b/local_pybind11/pybind11/include/pybind11/warnings.h
new file mode 100644
index 000000000..263b2990e
--- /dev/null
+++ b/local_pybind11/pybind11/include/pybind11/warnings.h
@@ -0,0 +1,75 @@
+/*
+    pybind11/warnings.h: Python warnings wrappers.
+
+    Copyright (c) 2024 Jan Iwaszkiewicz <jiwaszkiewicz6@gmail.com>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "pybind11.h"
+#include "detail/common.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+inline bool PyWarning_Check(PyObject *obj) {
+    int result = PyObject_IsSubclass(obj, PyExc_Warning);
+    if (result == 1) {
+        return true;
+    }
+    if (result == -1) {
+        raise_from(PyExc_SystemError,
+                   "pybind11::detail::PyWarning_Check(): PyObject_IsSubclass() call failed.");
+        throw error_already_set();
+    }
+    return false;
+}
+
+PYBIND11_NAMESPACE_END(detail)
+
+PYBIND11_NAMESPACE_BEGIN(warnings)
+
+inline object
+new_warning_type(handle scope, const char *name, handle base = PyExc_RuntimeWarning) {
+    if (!detail::PyWarning_Check(base.ptr())) {
+        pybind11_fail("pybind11::warnings::new_warning_type(): cannot create custom warning, base "
+                      "must be a subclass of "
+                      "PyExc_Warning!");
+    }
+    if (hasattr(scope, name)) {
+        pybind11_fail("pybind11::warnings::new_warning_type(): an attribute with name \""
+                      + std::string(name) + "\" exists already.");
+    }
+    std::string full_name = scope.attr("__name__").cast<std::string>() + std::string(".") + name;
+    handle h(PyErr_NewException(full_name.c_str(), base.ptr(), nullptr));
+    if (!h) {
+        raise_from(PyExc_SystemError,
+                   "pybind11::warnings::new_warning_type(): PyErr_NewException() call failed.");
+        throw error_already_set();
+    }
+    auto obj = reinterpret_steal<object>(h);
+    scope.attr(name) = obj;
+    return obj;
+}
+
+// Similar to Python `warnings.warn()`
+inline void
+warn(const char *message, handle category = PyExc_RuntimeWarning, int stack_level = 2) {
+    if (!detail::PyWarning_Check(category.ptr())) {
+        pybind11_fail(
+            "pybind11::warnings::warn(): cannot raise warning, category must be a subclass of "
+            "PyExc_Warning!");
+    }
+
+    if (PyErr_WarnEx(category.ptr(), message, stack_level) == -1) {
+        throw error_already_set();
+    }
+}
+
+PYBIND11_NAMESPACE_END(warnings)
+
+PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
diff --git a/local_pybind11/pybind11/py.typed b/local_pybind11/pybind11/py.typed
new file mode 100644
index 000000000..e69de29bb
diff --git a/local_pybind11/pybind11/setup_helpers.py b/local_pybind11/pybind11/setup_helpers.py
new file mode 100644
index 000000000..f24291818
--- /dev/null
+++ b/local_pybind11/pybind11/setup_helpers.py
@@ -0,0 +1,500 @@
+"""
+This module provides helpers for C++11+ projects using pybind11.
+
+LICENSE:
+
+Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>, 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.
+"""
+
+# IMPORTANT: If you change this file in the pybind11 repo, also review
+# setup_helpers.pyi for matching changes.
+#
+# If you copy this file in, you don't
+# need the .pyi file; it's just an interface file for static type checkers.
+from __future__ import annotations
+
+import contextlib
+import os
+import platform
+import shlex
+import shutil
+import sys
+import sysconfig
+import tempfile
+import threading
+import warnings
+from functools import lru_cache
+from pathlib import Path
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Tuple,
+    TypeVar,
+    Union,
+)
+
+try:
+    from setuptools import Extension as _Extension
+    from setuptools.command.build_ext import build_ext as _build_ext
+except ImportError:
+    from distutils.command.build_ext import (  # type: ignore[assignment]
+        build_ext as _build_ext,
+    )
+    from distutils.extension import Extension as _Extension  # type: ignore[assignment]
+
+import distutils.ccompiler
+import distutils.errors
+
+WIN = sys.platform.startswith("win32") and "mingw" not in sysconfig.get_platform()
+MACOS = sys.platform.startswith("darwin")
+STD_TMPL = "/std:c++{}" if WIN else "-std=c++{}"
+
+
+# It is recommended to use PEP 518 builds if using this module. However, this
+# file explicitly supports being copied into a user's project directory
+# standalone, and pulling pybind11 with the deprecated setup_requires feature.
+# If you copy the file, remember to add it to your MANIFEST.in, and add the current
+# directory into your path if it sits beside your setup.py.
+
+
+class Pybind11Extension(_Extension):
+    """
+    Build a C++11+ Extension module with pybind11. This automatically adds the
+    recommended flags when you init the extension and assumes C++ sources - you
+    can further modify the options yourself.
+
+    The customizations are:
+
+    * ``/EHsc`` and ``/bigobj`` on Windows
+    * ``stdlib=libc++`` on macOS
+    * ``visibility=hidden`` and ``-g0`` on Unix
+
+    Finally, you can set ``cxx_std`` via constructor or afterwards to enable
+    flags for C++ std, and a few extra helper flags related to the C++ standard
+    level. It is _highly_ recommended you either set this, or use the provided
+    ``build_ext``, which will search for the highest supported extension for
+    you if the ``cxx_std`` property is not set. Do not set the ``cxx_std``
+    property more than once, as flags are added when you set it. Set the
+    property to None to disable the addition of C++ standard flags.
+
+    If you want to add pybind11 headers manually, for example for an exact
+    git checkout, then set ``include_pybind11=False``.
+    """
+
+    # flags are prepended, so that they can be further overridden, e.g. by
+    # ``extra_compile_args=["-g"]``.
+
+    def _add_cflags(self, flags: list[str]) -> None:
+        self.extra_compile_args[:0] = flags
+
+    def _add_ldflags(self, flags: list[str]) -> None:
+        self.extra_link_args[:0] = flags
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self._cxx_level = 0
+        cxx_std = kwargs.pop("cxx_std", 0)
+
+        if "language" not in kwargs:
+            kwargs["language"] = "c++"
+
+        include_pybind11 = kwargs.pop("include_pybind11", True)
+
+        super().__init__(*args, **kwargs)
+
+        # Include the installed package pybind11 headers
+        if include_pybind11:
+            # If using setup_requires, this fails the first time - that's okay
+            try:
+                import pybind11
+
+                pyinc = pybind11.get_include()
+
+                if pyinc not in self.include_dirs:
+                    self.include_dirs.append(pyinc)
+            except ModuleNotFoundError:
+                pass
+
+        self.cxx_std = cxx_std
+
+        cflags = []
+        if WIN:
+            cflags += ["/EHsc", "/bigobj"]
+        else:
+            cflags += ["-fvisibility=hidden"]
+            env_cflags = os.environ.get("CFLAGS", "")
+            env_cppflags = os.environ.get("CPPFLAGS", "")
+            c_cpp_flags = shlex.split(env_cflags) + shlex.split(env_cppflags)
+            if not any(opt.startswith("-g") for opt in c_cpp_flags):
+                cflags += ["-g0"]
+        self._add_cflags(cflags)
+
+    @property
+    def cxx_std(self) -> int:
+        """
+        The CXX standard level. If set, will add the required flags. If left at
+        0, it will trigger an automatic search when pybind11's build_ext is
+        used. If None, will have no effect.  Besides just the flags, this may
+        add a macos-min 10.9 or 10.14 flag if MACOSX_DEPLOYMENT_TARGET is
+        unset.
+        """
+        return self._cxx_level
+
+    @cxx_std.setter
+    def cxx_std(self, level: int) -> None:
+        if self._cxx_level:
+            warnings.warn(
+                "You cannot safely change the cxx_level after setting it!", stacklevel=2
+            )
+
+        # MSVC 2015 Update 3 and later only have 14 (and later 17) modes, so
+        # force a valid flag here.
+        if WIN and level == 11:
+            level = 14
+
+        self._cxx_level = level
+
+        if not level:
+            return
+
+        cflags = [STD_TMPL.format(level)]
+        ldflags = []
+
+        if MACOS and "MACOSX_DEPLOYMENT_TARGET" not in os.environ:
+            # C++17 requires a higher min version of macOS. An earlier version
+            # (10.12 or 10.13) can be set manually via environment variable if
+            # you are careful in your feature usage, but 10.14 is the safest
+            # setting for general use. However, never set higher than the
+            # current macOS version!
+            current_macos = tuple(int(x) for x in platform.mac_ver()[0].split(".")[:2])
+            desired_macos = (10, 9) if level < 17 else (10, 14)
+            macos_string = ".".join(str(x) for x in min(current_macos, desired_macos))
+            macosx_min = f"-mmacosx-version-min={macos_string}"
+            cflags += [macosx_min]
+            ldflags += [macosx_min]
+
+        self._add_cflags(cflags)
+        self._add_ldflags(ldflags)
+
+
+# Just in case someone clever tries to multithread
+tmp_chdir_lock = threading.Lock()
+
+
+@contextlib.contextmanager
+def tmp_chdir() -> Iterator[str]:
+    "Prepare and enter a temporary directory, cleanup when done"
+
+    # Threadsafe
+    with tmp_chdir_lock:
+        olddir = os.getcwd()
+        try:
+            tmpdir = tempfile.mkdtemp()
+            os.chdir(tmpdir)
+            yield tmpdir
+        finally:
+            os.chdir(olddir)
+            shutil.rmtree(tmpdir)
+
+
+# cf http://bugs.python.org/issue26689
+def has_flag(compiler: Any, flag: str) -> bool:
+    """
+    Return the flag if a flag name is supported on the
+    specified compiler, otherwise None (can be used as a boolean).
+    If multiple flags are passed, return the first that matches.
+    """
+
+    with tmp_chdir():
+        fname = Path("flagcheck.cpp")
+        # Don't trigger -Wunused-parameter.
+        fname.write_text("int main (int, char **) { return 0; }", encoding="utf-8")
+
+        try:
+            compiler.compile([str(fname)], extra_postargs=[flag])
+        except distutils.errors.CompileError:
+            return False
+        return True
+
+
+# Every call will cache the result
+cpp_flag_cache = None
+
+
+@lru_cache
+def auto_cpp_level(compiler: Any) -> str | int:
+    """
+    Return the max supported C++ std level (17, 14, or 11). Returns latest on Windows.
+    """
+
+    if WIN:
+        return "latest"
+
+    levels = [17, 14, 11]
+
+    for level in levels:
+        if has_flag(compiler, STD_TMPL.format(level)):
+            return level
+
+    msg = "Unsupported compiler -- at least C++11 support is needed!"
+    raise RuntimeError(msg)
+
+
+class build_ext(_build_ext):  # noqa: N801
+    """
+    Customized build_ext that allows an auto-search for the highest supported
+    C++ level for Pybind11Extension. This is only needed for the auto-search
+    for now, and is completely optional otherwise.
+    """
+
+    def build_extensions(self) -> None:
+        """
+        Build extensions, injecting C++ std for Pybind11Extension if needed.
+        """
+
+        for ext in self.extensions:
+            if hasattr(ext, "_cxx_level") and ext._cxx_level == 0:
+                ext.cxx_std = auto_cpp_level(self.compiler)
+
+        super().build_extensions()
+
+
+def intree_extensions(
+    paths: Iterable[str], package_dir: dict[str, str] | None = None
+) -> list[Pybind11Extension]:
+    """
+    Generate Pybind11Extensions from source files directly located in a Python
+    source tree.
+
+    ``package_dir`` behaves as in ``setuptools.setup``.  If unset, the Python
+    package root parent is determined as the first parent directory that does
+    not contain an ``__init__.py`` file.
+    """
+    exts = []
+
+    if package_dir is None:
+        for path in paths:
+            parent, _ = os.path.split(path)
+            while os.path.exists(os.path.join(parent, "__init__.py")):
+                parent, _ = os.path.split(parent)
+            relname, _ = os.path.splitext(os.path.relpath(path, parent))
+            qualified_name = relname.replace(os.path.sep, ".")
+            exts.append(Pybind11Extension(qualified_name, [path]))
+        return exts
+
+    for path in paths:
+        for prefix, parent in package_dir.items():
+            if path.startswith(parent):
+                relname, _ = os.path.splitext(os.path.relpath(path, parent))
+                qualified_name = relname.replace(os.path.sep, ".")
+                if prefix:
+                    qualified_name = prefix + "." + qualified_name
+                exts.append(Pybind11Extension(qualified_name, [path]))
+                break
+        else:
+            msg = (
+                f"path {path} is not a child of any of the directories listed "
+                f"in 'package_dir' ({package_dir})"
+            )
+            raise ValueError(msg)
+
+    return exts
+
+
+def naive_recompile(obj: str, src: str) -> bool:
+    """
+    This will recompile only if the source file changes. It does not check
+    header files, so a more advanced function or Ccache is better if you have
+    editable header files in your package.
+    """
+    return os.stat(obj).st_mtime < os.stat(src).st_mtime
+
+
+def no_recompile(obg: str, src: str) -> bool:  # noqa: ARG001
+    """
+    This is the safest but slowest choice (and is the default) - will always
+    recompile sources.
+    """
+    return True
+
+
+S = TypeVar("S", bound="ParallelCompile")
+
+CCompilerMethod = Callable[
+    [
+        distutils.ccompiler.CCompiler,
+        List[str],
+        Optional[str],
+        Optional[List[Union[Tuple[str], Tuple[str, Optional[str]]]]],
+        Optional[List[str]],
+        bool,
+        Optional[List[str]],
+        Optional[List[str]],
+        Optional[List[str]],
+    ],
+    List[str],
+]
+
+
+# Optional parallel compile utility
+# inspired by: http://stackoverflow.com/questions/11013851/speeding-up-build-process-with-distutils
+# and: https://github.com/tbenthompson/cppimport/blob/stable/cppimport/build_module.py
+# and NumPy's parallel distutils module:
+#              https://github.com/numpy/numpy/blob/master/numpy/distutils/ccompiler.py
+class ParallelCompile:
+    """
+    Make a parallel compile function. Inspired by
+    numpy.distutils.ccompiler.CCompiler.compile and cppimport.
+
+    This takes several arguments that allow you to customize the compile
+    function created:
+
+    envvar:
+        Set an environment variable to control the compilation threads, like
+        NPY_NUM_BUILD_JOBS
+    default:
+        0 will automatically multithread, or 1 will only multithread if the
+        envvar is set.
+    max:
+        The limit for automatic multithreading if non-zero
+    needs_recompile:
+        A function of (obj, src) that returns True when recompile is needed.  No
+        effect in isolated mode; use ccache instead, see
+        https://github.com/matplotlib/matplotlib/issues/1507/
+
+    To use::
+
+        ParallelCompile("NPY_NUM_BUILD_JOBS").install()
+
+    or::
+
+        with ParallelCompile("NPY_NUM_BUILD_JOBS"):
+            setup(...)
+
+    By default, this assumes all files need to be recompiled. A smarter
+    function can be provided via needs_recompile.  If the output has not yet
+    been generated, the compile will always run, and this function is not
+    called.
+    """
+
+    __slots__ = ("envvar", "default", "max", "_old", "needs_recompile")
+
+    def __init__(
+        self,
+        envvar: str | None = None,
+        default: int = 0,
+        max: int = 0,  # pylint: disable=redefined-builtin
+        needs_recompile: Callable[[str, str], bool] = no_recompile,
+    ) -> None:
+        self.envvar = envvar
+        self.default = default
+        self.max = max
+        self.needs_recompile = needs_recompile
+        self._old: list[CCompilerMethod] = []
+
+    def function(self) -> CCompilerMethod:
+        """
+        Builds a function object usable as distutils.ccompiler.CCompiler.compile.
+        """
+
+        def compile_function(
+            compiler: distutils.ccompiler.CCompiler,
+            sources: list[str],
+            output_dir: str | None = None,
+            macros: list[tuple[str] | tuple[str, str | None]] | None = None,
+            include_dirs: list[str] | None = None,
+            debug: bool = False,
+            extra_preargs: list[str] | None = None,
+            extra_postargs: list[str] | None = None,
+            depends: list[str] | None = None,
+        ) -> Any:
+            # These lines are directly from distutils.ccompiler.CCompiler
+            macros, objects, extra_postargs, pp_opts, build = compiler._setup_compile(  # type: ignore[attr-defined]
+                output_dir, macros, include_dirs, sources, depends, extra_postargs
+            )
+            cc_args = compiler._get_cc_args(pp_opts, debug, extra_preargs)  # type: ignore[attr-defined]
+
+            # The number of threads; start with default.
+            threads = self.default
+
+            # Determine the number of compilation threads, unless set by an environment variable.
+            if self.envvar is not None:
+                threads = int(os.environ.get(self.envvar, self.default))
+
+            def _single_compile(obj: Any) -> None:
+                try:
+                    src, ext = build[obj]
+                except KeyError:
+                    return
+
+                if not os.path.exists(obj) or self.needs_recompile(obj, src):
+                    compiler._compile(obj, src, ext, cc_args, extra_postargs, pp_opts)  # type: ignore[attr-defined]
+
+            try:
+                # Importing .synchronize checks for platforms that have some multiprocessing
+                # capabilities but lack semaphores, such as AWS Lambda and Android Termux.
+                import multiprocessing.synchronize
+                from multiprocessing.pool import ThreadPool
+            except ImportError:
+                threads = 1
+
+            if threads == 0:
+                try:
+                    threads = multiprocessing.cpu_count()
+                    threads = self.max if self.max and self.max < threads else threads
+                except NotImplementedError:
+                    threads = 1
+
+            if threads > 1:
+                with ThreadPool(threads) as pool:
+                    for _ in pool.imap_unordered(_single_compile, objects):
+                        pass
+            else:
+                for ob in objects:
+                    _single_compile(ob)
+
+            return objects
+
+        return compile_function
+
+    def install(self: S) -> S:
+        """
+        Installs the compile function into distutils.ccompiler.CCompiler.compile.
+        """
+        distutils.ccompiler.CCompiler.compile = self.function()  # type: ignore[assignment]
+        return self
+
+    def __enter__(self: S) -> S:
+        self._old.append(distutils.ccompiler.CCompiler.compile)
+        return self.install()
+
+    def __exit__(self, *args: Any) -> None:
+        distutils.ccompiler.CCompiler.compile = self._old.pop()  # type: ignore[assignment]
diff --git a/local_pybind11/pybind11/share/__init__.py b/local_pybind11/pybind11/share/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/local_pybind11/pybind11/share/__pycache__/__init__.cpython-313.pyc b/local_pybind11/pybind11/share/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8eccc5341a243dd61a6d3fde2a11a5d1c166c457
GIT binary patch
literal 159
zcmey&%ge<81iZ{jnIQTxh=2h`DC08=kTI1Zok5e)ZzV$!6Oi{ABz4P9za+OnzaX<f
zw<NJBJ+(yF&@#QGG%4OxKPNLuzo4=tBR>yFC1vKN7#ivqXCxM->c_`t=4F<|$LkeT
h-r}&y%}*)KNwq6t1sVskt{BAl$jr#dSi}ru0RTFvB=-OS

literal 0
HcmV?d00001

diff --git a/local_pybind11/pybind11/share/cmake/pybind11/FindPythonLibsNew.cmake b/local_pybind11/pybind11/share/cmake/pybind11/FindPythonLibsNew.cmake
new file mode 100644
index 000000000..7351bcaa6
--- /dev/null
+++ b/local_pybind11/pybind11/share/cmake/pybind11/FindPythonLibsNew.cmake
@@ -0,0 +1,320 @@
+# - Find python libraries
+# This module finds the libraries corresponding to the Python interpreter
+# FindPythonInterp provides.
+# This code sets the following variables:
+#
+#  PYTHONLIBS_FOUND           - have the Python libs been found
+#  PYTHON_PREFIX              - path to the Python installation
+#  PYTHON_LIBRARIES           - path to the python library
+#  PYTHON_INCLUDE_DIRS        - path to where Python.h is found
+#  PYTHON_MODULE_EXTENSION    - lib extension, e.g. '.so' or '.pyd'
+#  PYTHON_MODULE_PREFIX       - lib name prefix: usually an empty string
+#  PYTHON_SITE_PACKAGES       - path to installation site-packages
+#  PYTHON_IS_DEBUG            - whether the Python interpreter is a debug build
+#
+# Thanks to talljimbo for the patch adding the 'LDVERSION' config
+# variable usage.
+
+#=============================================================================
+# Copyright 2001-2009 Kitware, Inc.
+# Copyright 2012 Continuum Analytics, Inc.
+#
+# 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 names of Kitware, Inc., the Insight Software Consortium,
+# nor the names of their 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.
+#=============================================================================
+
+# Checking for the extension makes sure that `LibsNew` was found and not just `Libs`.
+if(PYTHONLIBS_FOUND AND PYTHON_MODULE_EXTENSION)
+  return()
+endif()
+
+if(PythonLibsNew_FIND_QUIETLY)
+  set(_pythonlibs_quiet QUIET)
+else()
+  set(_pythonlibs_quiet "")
+endif()
+
+if(PythonLibsNew_FIND_REQUIRED)
+  set(_pythonlibs_required REQUIRED)
+endif()
+
+# Check to see if the `python` command is present and from a virtual
+# environment, conda, or GHA activation - if it is, try to use that.
+
+if(NOT DEFINED PYTHON_EXECUTABLE)
+  if(DEFINED ENV{VIRTUAL_ENV})
+    find_program(
+      PYTHON_EXECUTABLE python
+      PATHS "$ENV{VIRTUAL_ENV}" "$ENV{VIRTUAL_ENV}/bin"
+      NO_DEFAULT_PATH)
+  elseif(DEFINED ENV{CONDA_PREFIX})
+    find_program(
+      PYTHON_EXECUTABLE python
+      PATHS "$ENV{CONDA_PREFIX}" "$ENV{CONDA_PREFIX}/bin"
+      NO_DEFAULT_PATH)
+  elseif(DEFINED ENV{pythonLocation})
+    find_program(
+      PYTHON_EXECUTABLE python
+      PATHS "$ENV{pythonLocation}" "$ENV{pythonLocation}/bin"
+      NO_DEFAULT_PATH)
+  endif()
+  if(NOT PYTHON_EXECUTABLE)
+    unset(PYTHON_EXECUTABLE)
+  endif()
+endif()
+
+# Use the Python interpreter to find the libs.
+if(NOT PythonLibsNew_FIND_VERSION)
+  set(PythonLibsNew_FIND_VERSION "3.8")
+endif()
+
+if(NOT CMAKE_VERSION VERSION_LESS "3.27")
+  cmake_policy(GET CMP0148 _pybind11_cmp0148)
+  if(NOT _pybind11_cmp0148)
+    message(
+      AUTHOR_WARNING
+        "Policy CMP0148 is not set: The FindPythonInterp and FindPythonLibs "
+        "modules are removed.  Run \"cmake --help-policy CMP0148\" for policy "
+        "details.  Use the cmake_policy command to set the policy and suppress "
+        "this warning, or preferably upgrade to using FindPython, either by "
+        "calling it explicitly before pybind11, or by setting "
+        "PYBIND11_FINDPYTHON ON before pybind11.")
+  endif()
+  cmake_policy(SET CMP0148 OLD)
+  unset(_pybind11_cmp0148)
+endif()
+
+find_package(PythonInterp ${PythonLibsNew_FIND_VERSION} ${_pythonlibs_required}
+             ${_pythonlibs_quiet})
+
+if(NOT PYTHONINTERP_FOUND)
+  set(PYTHONLIBS_FOUND FALSE)
+  set(PythonLibsNew_FOUND FALSE)
+  return()
+endif()
+
+# According to https://stackoverflow.com/questions/646518/python-how-to-detect-debug-interpreter
+# testing whether sys has the gettotalrefcount function is a reliable, cross-platform
+# way to detect a CPython debug interpreter.
+#
+# The library suffix is from the config var LDVERSION sometimes, otherwise
+# VERSION. VERSION will typically be like "2.7" on unix, and "27" on windows.
+execute_process(
+  COMMAND
+    "${PYTHON_EXECUTABLE}" "-c" "
+import sys;import struct;
+import sysconfig as s
+USE_SYSCONFIG = sys.version_info >= (3, 10)
+if not USE_SYSCONFIG:
+    from distutils import sysconfig as ds
+print('.'.join(str(v) for v in sys.version_info));
+print(sys.prefix);
+if USE_SYSCONFIG:
+    scheme = s.get_default_scheme()
+    if scheme == 'posix_local':
+        # Debian's default scheme installs to /usr/local/ but we want to find headers in /usr/
+        scheme = 'posix_prefix'
+    print(s.get_path('platinclude', scheme))
+    print(s.get_path('platlib'))
+    print(s.get_config_var('EXT_SUFFIX') or s.get_config_var('SO'))
+else:
+    print(ds.get_python_inc(plat_specific=True));
+    print(ds.get_python_lib(plat_specific=True));
+    print(ds.get_config_var('EXT_SUFFIX') or ds.get_config_var('SO'));
+print(hasattr(sys, 'gettotalrefcount')+0);
+print(struct.calcsize('@P'));
+print(s.get_config_var('LDVERSION') or s.get_config_var('VERSION'));
+print(s.get_config_var('LIBDIR') or '');
+print(s.get_config_var('MULTIARCH') or '');
+"
+  RESULT_VARIABLE _PYTHON_SUCCESS
+  OUTPUT_VARIABLE _PYTHON_VALUES
+  ERROR_VARIABLE _PYTHON_ERROR_VALUE)
+
+if(NOT _PYTHON_SUCCESS MATCHES 0)
+  if(PythonLibsNew_FIND_REQUIRED)
+    message(FATAL_ERROR "Python config failure:\n${_PYTHON_ERROR_VALUE}")
+  endif()
+  set(PYTHONLIBS_FOUND FALSE)
+  set(PythonLibsNew_FOUND FALSE)
+  return()
+endif()
+
+option(
+  PYBIND11_PYTHONLIBS_OVERWRITE
+  "Overwrite cached values read from Python library (classic search). Turn off if cross-compiling and manually setting these values."
+  ON)
+# Can manually set values when cross-compiling
+macro(_PYBIND11_GET_IF_UNDEF lst index name)
+  if(PYBIND11_PYTHONLIBS_OVERWRITE OR NOT DEFINED "${name}")
+    list(GET "${lst}" "${index}" "${name}")
+  endif()
+endmacro()
+
+# Convert the process output into a list
+if(WIN32)
+  string(REGEX REPLACE "\\\\" "/" _PYTHON_VALUES ${_PYTHON_VALUES})
+endif()
+string(REGEX REPLACE ";" "\\\\;" _PYTHON_VALUES ${_PYTHON_VALUES})
+string(REGEX REPLACE "\n" ";" _PYTHON_VALUES ${_PYTHON_VALUES})
+_pybind11_get_if_undef(_PYTHON_VALUES 0 _PYTHON_VERSION_LIST)
+_pybind11_get_if_undef(_PYTHON_VALUES 1 PYTHON_PREFIX)
+_pybind11_get_if_undef(_PYTHON_VALUES 2 PYTHON_INCLUDE_DIR)
+_pybind11_get_if_undef(_PYTHON_VALUES 3 PYTHON_SITE_PACKAGES)
+_pybind11_get_if_undef(_PYTHON_VALUES 5 PYTHON_IS_DEBUG)
+_pybind11_get_if_undef(_PYTHON_VALUES 6 PYTHON_SIZEOF_VOID_P)
+_pybind11_get_if_undef(_PYTHON_VALUES 7 PYTHON_LIBRARY_SUFFIX)
+_pybind11_get_if_undef(_PYTHON_VALUES 8 PYTHON_LIBDIR)
+_pybind11_get_if_undef(_PYTHON_VALUES 9 PYTHON_MULTIARCH)
+
+list(GET _PYTHON_VALUES 4 _PYTHON_MODULE_EXT_SUFFIX)
+if(PYBIND11_PYTHONLIBS_OVERWRITE OR NOT DEFINED PYTHON_MODULE_DEBUG_POSTFIX)
+  get_filename_component(PYTHON_MODULE_DEBUG_POSTFIX "${_PYTHON_MODULE_EXT_SUFFIX}" NAME_WE)
+endif()
+if(PYBIND11_PYTHONLIBS_OVERWRITE OR NOT DEFINED PYTHON_MODULE_EXTENSION)
+  get_filename_component(PYTHON_MODULE_EXTENSION "${_PYTHON_MODULE_EXT_SUFFIX}" EXT)
+  if((NOT "$ENV{SETUPTOOLS_EXT_SUFFIX}" STREQUAL "") AND (NOT "$ENV{SETUPTOOLS_EXT_SUFFIX}"
+                                                          STREQUAL "${PYTHON_MODULE_EXTENSION}"))
+    message(
+      AUTHOR_WARNING,
+      "SETUPTOOLS_EXT_SUFFIX is set to \"$ENV{SETUPTOOLS_EXT_SUFFIX}\", "
+      "but the auto-calculated Python extension suffix is \"${PYTHON_MODULE_EXTENSION}\". "
+      "This may cause problems when importing the Python extensions. "
+      "If you are using cross-compiling Python, you may need to "
+      "set PYTHON_MODULE_EXTENSION manually.")
+  endif()
+endif()
+
+# Make sure the Python has the same pointer-size as the chosen compiler
+# Skip if CMAKE_SIZEOF_VOID_P is not defined
+# This should be skipped for (non-Apple) cross-compiles (like EMSCRIPTEN)
+if(NOT _PYBIND11_CROSSCOMPILING
+   AND CMAKE_SIZEOF_VOID_P
+   AND (NOT "${PYTHON_SIZEOF_VOID_P}" STREQUAL "${CMAKE_SIZEOF_VOID_P}"))
+  if(PythonLibsNew_FIND_REQUIRED)
+    math(EXPR _PYTHON_BITS "${PYTHON_SIZEOF_VOID_P} * 8")
+    math(EXPR _CMAKE_BITS "${CMAKE_SIZEOF_VOID_P} * 8")
+    message(FATAL_ERROR "Python config failure: Python is ${_PYTHON_BITS}-bit, "
+                        "chosen compiler is  ${_CMAKE_BITS}-bit")
+  endif()
+  set(PYTHONLIBS_FOUND FALSE)
+  set(PythonLibsNew_FOUND FALSE)
+  return()
+endif()
+
+# The built-in FindPython didn't always give the version numbers
+string(REGEX REPLACE "\\." ";" _PYTHON_VERSION_LIST ${_PYTHON_VERSION_LIST})
+list(GET _PYTHON_VERSION_LIST 0 PYTHON_VERSION_MAJOR)
+list(GET _PYTHON_VERSION_LIST 1 PYTHON_VERSION_MINOR)
+list(GET _PYTHON_VERSION_LIST 2 PYTHON_VERSION_PATCH)
+set(PYTHON_VERSION "${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}.${PYTHON_VERSION_PATCH}")
+
+# Make sure all directory separators are '/'
+string(REGEX REPLACE "\\\\" "/" PYTHON_PREFIX "${PYTHON_PREFIX}")
+string(REGEX REPLACE "\\\\" "/" PYTHON_INCLUDE_DIR "${PYTHON_INCLUDE_DIR}")
+string(REGEX REPLACE "\\\\" "/" PYTHON_SITE_PACKAGES "${PYTHON_SITE_PACKAGES}")
+
+if(DEFINED PYTHON_LIBRARY)
+  # Don't write to PYTHON_LIBRARY if it's already set
+elseif(CMAKE_HOST_WIN32)
+  set(PYTHON_LIBRARY "${PYTHON_PREFIX}/libs/python${PYTHON_LIBRARY_SUFFIX}.lib")
+
+  # when run in a venv, PYTHON_PREFIX points to it. But the libraries remain in the
+  # original python installation. They may be found relative to PYTHON_INCLUDE_DIR.
+  if(NOT EXISTS "${PYTHON_LIBRARY}")
+    get_filename_component(_PYTHON_ROOT ${PYTHON_INCLUDE_DIR} DIRECTORY)
+    set(PYTHON_LIBRARY "${_PYTHON_ROOT}/libs/python${PYTHON_LIBRARY_SUFFIX}.lib")
+  endif()
+
+  # if we are in MSYS & MINGW, and we didn't find windows python lib, look for system python lib
+  if(DEFINED ENV{MSYSTEM}
+     AND MINGW
+     AND NOT EXISTS "${PYTHON_LIBRARY}")
+    if(PYTHON_MULTIARCH)
+      set(_PYTHON_LIBS_SEARCH "${PYTHON_LIBDIR}/${PYTHON_MULTIARCH}" "${PYTHON_LIBDIR}")
+    else()
+      set(_PYTHON_LIBS_SEARCH "${PYTHON_LIBDIR}")
+    endif()
+    unset(PYTHON_LIBRARY)
+    find_library(
+      PYTHON_LIBRARY
+      NAMES "python${PYTHON_LIBRARY_SUFFIX}"
+      PATHS ${_PYTHON_LIBS_SEARCH}
+      NO_DEFAULT_PATH)
+  endif()
+
+  # raise an error if the python libs are still not found.
+  if(NOT EXISTS "${PYTHON_LIBRARY}")
+    message(FATAL_ERROR "Python libraries not found")
+  endif()
+
+else()
+  if(PYTHON_MULTIARCH)
+    set(_PYTHON_LIBS_SEARCH "${PYTHON_LIBDIR}/${PYTHON_MULTIARCH}" "${PYTHON_LIBDIR}")
+  else()
+    set(_PYTHON_LIBS_SEARCH "${PYTHON_LIBDIR}")
+  endif()
+  #message(STATUS "Searching for Python libs in ${_PYTHON_LIBS_SEARCH}")
+  # Probably this needs to be more involved. It would be nice if the config
+  # information the python interpreter itself gave us were more complete.
+  find_library(
+    PYTHON_LIBRARY
+    NAMES "python${PYTHON_LIBRARY_SUFFIX}"
+    PATHS ${_PYTHON_LIBS_SEARCH}
+    NO_DEFAULT_PATH)
+
+  # If all else fails, just set the name/version and let the linker figure out the path.
+  if(NOT PYTHON_LIBRARY)
+    set(PYTHON_LIBRARY python${PYTHON_LIBRARY_SUFFIX})
+  endif()
+endif()
+
+mark_as_advanced(PYTHON_LIBRARY PYTHON_INCLUDE_DIR)
+
+# We use PYTHON_INCLUDE_DIR, PYTHON_LIBRARY and PYTHON_DEBUG_LIBRARY for the
+# cache entries because they are meant to specify the location of a single
+# library. We now set the variables listed by the documentation for this
+# module.
+set(PYTHON_INCLUDE_DIRS "${PYTHON_INCLUDE_DIR}")
+set(PYTHON_LIBRARIES "${PYTHON_LIBRARY}")
+if(NOT PYTHON_DEBUG_LIBRARY)
+  set(PYTHON_DEBUG_LIBRARY "")
+endif()
+set(PYTHON_DEBUG_LIBRARIES "${PYTHON_DEBUG_LIBRARY}")
+
+find_package_message(PYTHON "Found PythonLibs: ${PYTHON_LIBRARIES}"
+                     "${PYTHON_EXECUTABLE}${PYTHON_VERSION_STRING}")
+
+set(PYTHONLIBS_FOUND TRUE)
+set(PythonLibsNew_FOUND TRUE)
+
+if(NOT PYTHON_MODULE_PREFIX)
+  set(PYTHON_MODULE_PREFIX "")
+endif()
diff --git a/local_pybind11/pybind11/share/cmake/pybind11/pybind11Common.cmake b/local_pybind11/pybind11/share/cmake/pybind11/pybind11Common.cmake
new file mode 100644
index 000000000..1c1d4f88a
--- /dev/null
+++ b/local_pybind11/pybind11/share/cmake/pybind11/pybind11Common.cmake
@@ -0,0 +1,447 @@
+#[======================================================[.rst
+
+Adds the following targets::
+
+    pybind11::pybind11 - link to Python headers and pybind11::headers
+    pybind11::module - Adds module links
+    pybind11::embed - Adds embed links
+    pybind11::lto - Link time optimizations (only if CMAKE_INTERPROCEDURAL_OPTIMIZATION is not set)
+    pybind11::thin_lto - Link time optimizations (only if CMAKE_INTERPROCEDURAL_OPTIMIZATION is not set)
+    pybind11::python_link_helper - Adds link to Python libraries
+    pybind11::windows_extras - MSVC bigobj and mp for building multithreaded
+    pybind11::opt_size - avoid optimizations that increase code size
+
+Adds the following functions::
+
+    pybind11_strip(target) - strip target after building on linux/macOS
+    pybind11_find_import(module) - See if a module is installed.
+
+#]======================================================]
+
+# If we are in subdirectory mode, all IMPORTED targets must be GLOBAL. If we
+# are in CONFIG mode, they should be "normal" targets instead.
+# In CMake 3.11+ you can promote a target to global after you create it,
+# which might be simpler than this check.
+get_property(
+  is_config
+  TARGET pybind11::headers
+  PROPERTY IMPORTED)
+
+if(NOT is_config)
+  include_guard(GLOBAL)
+  set(optional_global GLOBAL)
+else()
+  include_guard(DIRECTORY)
+  set(optional_global "")
+endif()
+
+# If not run in Python mode, we still would like this to at least
+# include pybind11's include directory:
+set(pybind11_INCLUDE_DIRS
+    "${pybind11_INCLUDE_DIR}"
+    CACHE INTERNAL "Include directory for pybind11 (Python not requested)")
+
+if(CMAKE_CROSSCOMPILING AND PYBIND11_USE_CROSSCOMPILING)
+  set(_PYBIND11_CROSSCOMPILING
+      ON
+      CACHE INTERNAL "")
+else()
+  set(_PYBIND11_CROSSCOMPILING
+      OFF
+      CACHE INTERNAL "")
+endif()
+
+# --------------------- Shared targets ----------------------------
+
+# Build an interface library target:
+add_library(pybind11::pybind11 IMPORTED INTERFACE ${optional_global})
+set_property(
+  TARGET pybind11::pybind11
+  APPEND
+  PROPERTY INTERFACE_LINK_LIBRARIES pybind11::headers)
+
+# Build a module target:
+add_library(pybind11::module IMPORTED INTERFACE ${optional_global})
+set_property(
+  TARGET pybind11::module
+  APPEND
+  PROPERTY INTERFACE_LINK_LIBRARIES pybind11::pybind11)
+
+# Build an embed library target:
+add_library(pybind11::embed IMPORTED INTERFACE ${optional_global})
+set_property(
+  TARGET pybind11::embed
+  APPEND
+  PROPERTY INTERFACE_LINK_LIBRARIES pybind11::pybind11)
+
+# -------------- emscripten requires exceptions enabled -------------
+# _pybind11_no_exceptions is a private mechanism to disable this addition.
+# Please open an issue if you need to use it; it will be removed if no one
+# needs it.
+if(CMAKE_SYSTEM_NAME MATCHES Emscripten AND NOT _pybind11_no_exceptions)
+  if(is_config)
+    set(_tmp_config_target pybind11::pybind11_headers)
+  else()
+    set(_tmp_config_target pybind11_headers)
+  endif()
+
+  set_property(
+    TARGET ${_tmp_config_target}
+    APPEND
+    PROPERTY INTERFACE_LINK_OPTIONS -fexceptions)
+  set_property(
+    TARGET ${_tmp_config_target}
+    APPEND
+    PROPERTY INTERFACE_COMPILE_OPTIONS -fexceptions)
+  unset(_tmp_config_target)
+endif()
+
+# --------------------------- link helper ---------------------------
+
+add_library(pybind11::python_link_helper IMPORTED INTERFACE ${optional_global})
+
+set_property(
+  TARGET pybind11::python_link_helper
+  APPEND
+  PROPERTY INTERFACE_LINK_OPTIONS "$<$<PLATFORM_ID:Darwin>:LINKER:-undefined,dynamic_lookup>")
+
+# ------------------------ Windows extras -------------------------
+
+add_library(pybind11::windows_extras IMPORTED INTERFACE ${optional_global})
+
+if(MSVC) # That's also clang-cl
+  # /bigobj is needed for bigger binding projects due to the limit to 64k
+  # addressable sections
+  set_property(
+    TARGET pybind11::windows_extras
+    APPEND
+    PROPERTY INTERFACE_COMPILE_OPTIONS $<$<COMPILE_LANGUAGE:CXX>:/bigobj>)
+
+  # /MP enables multithreaded builds (relevant when there are many files) for MSVC
+  if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") # no Clang no Intel
+    # Only set these options for C++ files.  This is important so that, for
+    # instance, projects that include other types of source files like CUDA
+    # .cu files don't get these options propagated to nvcc since that would
+    # cause the build to fail.
+    set_property(
+      TARGET pybind11::windows_extras
+      APPEND
+      PROPERTY INTERFACE_COMPILE_OPTIONS $<$<NOT:$<CONFIG:Debug>>:$<$<COMPILE_LANGUAGE:CXX>:/MP>>)
+  endif()
+endif()
+
+# ----------------------- Optimize binary size --------------------------
+
+add_library(pybind11::opt_size IMPORTED INTERFACE ${optional_global})
+
+if(MSVC)
+  set(PYBIND11_OPT_SIZE /Os)
+else()
+  set(PYBIND11_OPT_SIZE -Os)
+endif()
+
+set_property(
+  TARGET pybind11::opt_size
+  APPEND
+  PROPERTY INTERFACE_COMPILE_OPTIONS $<$<CONFIG:Release>:${PYBIND11_OPT_SIZE}>
+           $<$<CONFIG:MinSizeRel>:${PYBIND11_OPT_SIZE}>
+           $<$<CONFIG:RelWithDebInfo>:${PYBIND11_OPT_SIZE}>)
+
+# ----------------------- Legacy option --------------------------
+
+# Warn or error if old variable name used
+if(PYBIND11_CPP_STANDARD)
+  string(REGEX MATCH [[..$]] VAL "${PYBIND11_CPP_STANDARD}")
+  if(CMAKE_CXX_STANDARD)
+    if(NOT CMAKE_CXX_STANDARD STREQUAL VAL)
+      message(WARNING "CMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD} does not match "
+                      "PYBIND11_CPP_STANDARD=${PYBIND11_CPP_STANDARD}, "
+                      "please remove PYBIND11_CPP_STANDARD from your cache")
+    endif()
+  else()
+    set(supported_standards 11 14 17 20)
+    if("${VAL}" IN_LIST supported_standards)
+      message(WARNING "USE -DCMAKE_CXX_STANDARD=${VAL} instead of PYBIND11_CPP_STANDARD")
+      set(CMAKE_CXX_STANDARD
+          ${VAL}
+          CACHE STRING "From PYBIND11_CPP_STANDARD")
+    else()
+      message(FATAL_ERROR "PYBIND11_CPP_STANDARD should be replaced with CMAKE_CXX_STANDARD "
+                          "(last two chars: ${VAL} not understood as a valid CXX std)")
+    endif()
+  endif()
+endif()
+
+# --------------------- Python specifics -------------------------
+
+# CMake 3.27 removes the classic FindPythonInterp if CMP0148 is NEW
+if(CMAKE_VERSION VERSION_LESS "3.27")
+  set(_pybind11_missing_old_python "OLD")
+else()
+  cmake_policy(GET CMP0148 _pybind11_missing_old_python)
+endif()
+
+# Check to see which Python mode we are in, new, old, or no python
+if(PYBIND11_NOPYTHON)
+  set(_pybind11_nopython ON)
+  # We won't use new FindPython if PYBIND11_FINDPYTHON is defined and falselike
+  # Otherwise, we use if FindPythonLibs is missing or if FindPython was already used
+elseif(
+  (NOT DEFINED PYBIND11_FINDPYTHON
+   OR PYBIND11_FINDPYTHON STREQUAL "COMPAT"
+   OR PYBIND11_FINDPYTHON)
+  AND (_pybind11_missing_old_python STREQUAL "NEW"
+       OR PYBIND11_FINDPYTHON STREQUAL "COMPAT"
+       OR PYBIND11_FINDPYTHON
+       OR Python_FOUND
+       OR Python3_FOUND
+      ))
+
+  # New mode
+  if(Python_FOUND OR Python3_FOUND)
+    include("${CMAKE_CURRENT_LIST_DIR}/pybind11NewTools.cmake")
+  else()
+    include("${CMAKE_CURRENT_LIST_DIR}/pybind11NewTools.cmake")
+
+    if(PYBIND11_FINDPYTHON STREQUAL "COMPAT")
+      message(
+        "Using compatibility mode for Python, set PYBIND11_FINDPYTHON to NEW/OLD to silence this message"
+      )
+      set(PYTHON_EXECUTABLE "${Python_EXECUTABLE}")
+      set(PYTHON_INCLUDE_DIR "${Python_INCLUDE_DIR}")
+      set(Python_INCLUDE_DIRS "${Python_INCLUDE_DIRS}")
+      set(PYTHON_LIBRARY "${Python_LIBRARY}")
+      set(PYTHON_LIBRARIES "${Python_LIBRARIES}")
+      set(PYTHON_VERSION "${Python_VERSION}")
+      set(PYTHON_VERSION_STRING "${Python_VERSION_STRING}")
+      set(PYTHON_VERSION_MAJOR "${Python_VERSION_MAJOR}")
+      set(PYTHON_VERSION_MINOR "${Python_VERSION_MINOR}")
+      set(PYTHON_VERSION_PATCH "${Python_VERSION_PATCH}")
+    endif()
+  endif()
+
+else()
+
+  # Classic mode
+  include("${CMAKE_CURRENT_LIST_DIR}/pybind11Tools.cmake")
+
+endif()
+
+# --------------------- pybind11_find_import -------------------------------
+
+if(NOT _pybind11_nopython AND NOT _PYBIND11_CROSSCOMPILING)
+  # Check to see if modules are importable. Use REQUIRED to force an error if
+  # one of the modules is not found. <package_name>_FOUND will be set if the
+  # package was found (underscores replace dashes if present). QUIET will hide
+  # the found message, and VERSION will require a minimum version. A successful
+  # find will cache the result.
+  function(pybind11_find_import PYPI_NAME)
+    # CMake variables need underscores (PyPI doesn't care)
+    string(REPLACE "-" "_" NORM_PYPI_NAME "${PYPI_NAME}")
+
+    # Return if found previously
+    if(${NORM_PYPI_NAME}_FOUND)
+      return()
+    endif()
+
+    set(options "REQUIRED;QUIET")
+    set(oneValueArgs "VERSION")
+    cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "" ${ARGN})
+
+    if(ARG_REQUIRED)
+      set(status_level FATAL_ERROR)
+    else()
+      set(status_level WARNING)
+    endif()
+
+    execute_process(
+      COMMAND
+        ${${_Python}_EXECUTABLE} -c "
+try:
+    from importlib.metadata import version
+except ImportError:
+    from pkg_resources import get_distribution
+    def version(s):
+        return get_distribution(s).version
+print(version('${PYPI_NAME}'))
+        "
+      RESULT_VARIABLE RESULT_PRESENT
+      OUTPUT_VARIABLE PKG_VERSION
+      ERROR_QUIET)
+
+    string(STRIP "${PKG_VERSION}" PKG_VERSION)
+
+    # If a result is present, this failed
+    if(RESULT_PRESENT)
+      set(${NORM_PYPI_NAME}_FOUND
+          ${NORM_PYPI_NAME}-NOTFOUND
+          CACHE INTERNAL "")
+      # Always warn or error
+      message(
+        ${status_level}
+        "Missing: ${PYPI_NAME} ${ARG_VERSION}\nTry: ${${_Python}_EXECUTABLE} -m pip install ${PYPI_NAME}"
+      )
+    else()
+      if(ARG_VERSION AND PKG_VERSION VERSION_LESS ARG_VERSION)
+        message(
+          ${status_level}
+          "Version incorrect: ${PYPI_NAME} ${PKG_VERSION} found, ${ARG_VERSION} required - try upgrading"
+        )
+      else()
+        set(${NORM_PYPI_NAME}_FOUND
+            YES
+            CACHE INTERNAL "")
+        set(${NORM_PYPI_NAME}_VERSION
+            ${PKG_VERSION}
+            CACHE INTERNAL "")
+      endif()
+      if(NOT ARG_QUIET)
+        message(STATUS "Found ${PYPI_NAME} ${PKG_VERSION}")
+      endif()
+    endif()
+    if(NOT ARG_VERSION OR (NOT PKG_VERSION VERSION_LESS ARG_VERSION))
+      # We have successfully found a good version, cache to avoid calling again.
+    endif()
+  endfunction()
+endif()
+
+# --------------------- LTO -------------------------------
+
+include(CheckCXXCompilerFlag)
+
+# Checks whether the given CXX/linker flags can compile and link a cxx file.
+# cxxflags and linkerflags are lists of flags to use.  The result variable is a
+# unique variable name for each set of flags: the compilation result will be
+# cached base on the result variable.  If the flags work, sets them in
+# cxxflags_out/linkerflags_out internal cache variables (in addition to
+# ${result}).
+function(_pybind11_return_if_cxx_and_linker_flags_work result cxxflags linkerflags cxxflags_out
+         linkerflags_out)
+  set(CMAKE_REQUIRED_LIBRARIES ${linkerflags})
+  check_cxx_compiler_flag("${cxxflags}" ${result})
+  if(${result})
+    set(${cxxflags_out}
+        "${cxxflags}"
+        PARENT_SCOPE)
+    set(${linkerflags_out}
+        "${linkerflags}"
+        PARENT_SCOPE)
+  endif()
+endfunction()
+
+function(_pybind11_generate_lto target prefer_thin_lto)
+  if(MINGW)
+    message(STATUS "${target} disabled (problems with undefined symbols for MinGW for now)")
+    return()
+  endif()
+
+  if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+    set(cxx_append "")
+    set(linker_append "")
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT APPLE)
+      # Clang Gold plugin does not support -Os; append -O3 to MinSizeRel builds to override it
+      set(linker_append ";$<$<CONFIG:MinSizeRel>:-O3>")
+    elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND NOT MINGW)
+      set(cxx_append ";-fno-fat-lto-objects")
+    endif()
+
+    if(prefer_thin_lto)
+      set(thin "=thin")
+    else()
+      set(thin "")
+    endif()
+
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc64le" OR CMAKE_SYSTEM_PROCESSOR MATCHES "mips64")
+      # Do nothing
+    elseif(CMAKE_SYSTEM_NAME MATCHES Emscripten)
+      # This compile is very costly when cross-compiling, so set this without checking
+      set(PYBIND11_LTO_CXX_FLAGS "-flto${thin}${cxx_append}")
+      set(PYBIND11_LTO_LINKER_FLAGS "-flto${thin}${linker_append}")
+    elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+      _pybind11_return_if_cxx_and_linker_flags_work(
+        HAS_FLTO_THIN "-flto${thin}${cxx_append}" "-flto${thin}${linker_append}"
+        PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
+    endif()
+    if(NOT HAS_FLTO_THIN)
+      _pybind11_return_if_cxx_and_linker_flags_work(
+        HAS_FLTO_AUTO "-flto=auto${cxx_append}" "-flto=auto${linker_append}"
+        PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
+    endif()
+    if(NOT HAS_FLTO_AUTO)
+      _pybind11_return_if_cxx_and_linker_flags_work(
+        HAS_FLTO "-flto${cxx_append}" "-flto${linker_append}" PYBIND11_LTO_CXX_FLAGS
+        PYBIND11_LTO_LINKER_FLAGS)
+    endif()
+  elseif(CMAKE_CXX_COMPILER_ID MATCHES "IntelLLVM")
+    # IntelLLVM equivalent to LTO is called IPO; also IntelLLVM is WIN32/UNIX
+    # WARNING/HELP WANTED: This block of code is currently not covered by pybind11 GitHub Actions!
+    if(WIN32)
+      _pybind11_return_if_cxx_and_linker_flags_work(
+        HAS_INTEL_IPO "-Qipo" "-Qipo" PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
+    else()
+      _pybind11_return_if_cxx_and_linker_flags_work(
+        HAS_INTEL_IPO "-ipo" "-ipo" PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
+    endif()
+  elseif(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
+    # Intel equivalent to LTO is called IPO
+    _pybind11_return_if_cxx_and_linker_flags_work(HAS_INTEL_IPO "-ipo" "-ipo"
+                                                  PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
+  elseif(MSVC)
+    # cmake only interprets libraries as linker flags when they start with a - (otherwise it
+    # converts /LTCG to \LTCG as if it was a Windows path).  Luckily MSVC supports passing flags
+    # with - instead of /, even if it is a bit non-standard:
+    _pybind11_return_if_cxx_and_linker_flags_work(HAS_MSVC_GL_LTCG "/GL" "-LTCG"
+                                                  PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
+  endif()
+
+  # Enable LTO flags if found, except for Debug builds
+  if(PYBIND11_LTO_CXX_FLAGS)
+    # CONFIG takes multiple values in CMake 3.19+, until then we have to use OR
+    set(is_debug "$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>")
+    set(not_debug "$<NOT:${is_debug}>")
+    set(cxx_lang "$<COMPILE_LANGUAGE:CXX>")
+    set(genex "$<AND:${not_debug},${cxx_lang}>")
+    set_property(
+      TARGET ${target}
+      APPEND
+      PROPERTY INTERFACE_COMPILE_OPTIONS "$<${genex}:${PYBIND11_LTO_CXX_FLAGS}>")
+    if(CMAKE_PROJECT_NAME STREQUAL "pybind11")
+      message(STATUS "${target} enabled")
+    endif()
+  else()
+    if(CMAKE_PROJECT_NAME STREQUAL "pybind11")
+      message(STATUS "${target} disabled (not supported by the compiler and/or linker)")
+    endif()
+  endif()
+
+  if(PYBIND11_LTO_LINKER_FLAGS)
+    set_property(
+      TARGET ${target}
+      APPEND
+      PROPERTY INTERFACE_LINK_OPTIONS "$<${not_debug}:${PYBIND11_LTO_LINKER_FLAGS}>")
+  endif()
+endfunction()
+
+if(NOT DEFINED CMAKE_INTERPROCEDURAL_OPTIMIZATION)
+  add_library(pybind11::lto IMPORTED INTERFACE ${optional_global})
+  _pybind11_generate_lto(pybind11::lto FALSE)
+
+  add_library(pybind11::thin_lto IMPORTED INTERFACE ${optional_global})
+  _pybind11_generate_lto(pybind11::thin_lto TRUE)
+endif()
+
+# ---------------------- pybind11_strip -----------------------------
+
+function(pybind11_strip target_name)
+  # Strip unnecessary sections of the binary on Linux/macOS
+  if(CMAKE_STRIP)
+    if(APPLE)
+      set(x_opt -x)
+    endif()
+
+    add_custom_command(
+      TARGET ${target_name}
+      POST_BUILD
+      COMMAND ${CMAKE_STRIP} ${x_opt} $<TARGET_FILE:${target_name}>)
+  endif()
+endfunction()
diff --git a/local_pybind11/pybind11/share/cmake/pybind11/pybind11Config.cmake b/local_pybind11/pybind11/share/cmake/pybind11/pybind11Config.cmake
new file mode 100644
index 000000000..fceb003a6
--- /dev/null
+++ b/local_pybind11/pybind11/share/cmake/pybind11/pybind11Config.cmake
@@ -0,0 +1,264 @@
+#[=============================================================================[.rst:
+
+pybind11Config.cmake
+####################
+
+Exported variables
+==================
+
+This module sets the following variables in your project:
+
+``pybind11_FOUND``
+  true if pybind11 and all required components found on the system
+``pybind11_VERSION``
+  pybind11 version in format Major.Minor.Release
+``pybind11_VERSION_TYPE``
+  pybind11 version type (``dev*`` or empty for a release)
+``pybind11_INCLUDE_DIRS``
+  Directories where pybind11 and python headers are located.
+``pybind11_INCLUDE_DIR``
+  Directory where pybind11 headers are located.
+``pybind11_DEFINITIONS``
+  Definitions necessary to use pybind11, namely USING_pybind11.
+``pybind11_LIBRARIES``
+  Compile flags and python libraries (as needed) to link against.
+``pybind11_LIBRARY``
+  Empty.
+
+Available components: None
+
+
+Exported targets
+================
+
+If pybind11 is found, this module defines the following ``IMPORTED``
+interface library targets:
+
+``pybind11::module``
+  for extension modules.
+``pybind11::embed``
+  for embedding the Python interpreter.
+
+Python headers, libraries (as needed by platform), and the C++ standard
+are attached to the target.
+
+Advanced targets are also supplied - these are primary for users building
+complex applications, and they are available in all modes:
+
+``pybind11::headers``
+  Just the pybind11 headers and minimum compile requirements.
+``pybind11::pybind11``
+  Python headers too.
+``pybind11::python_link_helper``
+  Just the "linking" part of ``pybind11:module``, for CMake < 3.15.
+``pybind11::thin_lto``
+  An alternative to ``INTERPROCEDURAL_OPTIMIZATION``.
+``pybind11::lto``
+  An alternative to ``INTERPROCEDURAL_OPTIMIZATION`` (also avoids thin LTO on clang).
+``pybind11::windows_extras``
+  Adds bigobj and mp for MSVC.
+
+Modes
+=====
+
+There are two modes provided; classic, which is built on the old Python
+discovery packages in CMake, or the new FindPython mode, which uses FindPython
+from 3.12+ forward (3.15+ _highly_ recommended). If you set the minimum or
+maximum version of CMake to 3.27+, then FindPython is the default (since
+FindPythonInterp/FindPythonLibs has been removed via policy `CMP0148`).
+
+Starting in pybind11 3.0, the new mode is the default, but we provide backward
+compatible names (``PYTHON_*`` vs. the new ``Python_*`` names). Set the mode
+explicitly to avoid the compatibility defines. You can specify this mode
+explicitly by setting ``PYBIND11_FINDPYTHON`` to ``COMPAT``, but if you are changing
+your CMakeLists anyway, please just use the ``ON`` mode. A future release may
+default to ``ON``.
+
+New FindPython mode
+^^^^^^^^^^^^^^^^^^^
+
+To activate this mode, either call ``find_package(Python COMPONENTS Interpreter Development)``
+before finding this package, or set the ``PYBIND11_FINDPYTHON`` variable to ON. In this mode,
+you can either use the basic targets, or use the FindPython tools:
+
+.. code-block:: cmake
+
+  find_package(Python COMPONENTS Interpreter Development)
+  find_package(pybind11 CONFIG)
+
+  # pybind11 method:
+  pybind11_add_module(MyModule1 src1.cpp)
+
+  # Python method:
+  Python_add_library(MyModule2 src2.cpp)
+  target_link_libraries(MyModule2 PUBLIC pybind11::headers)
+  set_target_properties(MyModule2 PROPERTIES
+                                  INTERPROCEDURAL_OPTIMIZATION ON
+                                  CXX_VISIBILITY_PRESET hidden
+                                  VISIBILITY_INLINES_HIDDEN ON)
+
+If you build targets yourself, you may be interested in stripping the output
+for reduced size; this is the one other feature that the helper function gives you.
+
+Classic mode
+^^^^^^^^^^^^
+
+Set PythonLibsNew variables to influence python detection and
+CMAKE_CXX_STANDARD to influence standard setting.
+
+.. code-block:: cmake
+
+  find_package(pybind11 CONFIG REQUIRED)
+
+  # Create an extension module
+  add_library(mylib MODULE main.cpp)
+  target_link_libraries(mylib PUBLIC pybind11::module)
+
+  # Or embed the Python interpreter into an executable
+  add_executable(myexe main.cpp)
+  target_link_libraries(myexe PUBLIC pybind11::embed)
+
+
+Hints
+=====
+
+The following variables can be set to guide the search for this package:
+
+``pybind11_DIR``
+  CMake variable, set to directory containing this Config file.
+``CMAKE_PREFIX_PATH``
+  CMake variable, set to root directory of this package.
+``PATH``
+  Environment variable, set to bin directory of this package.
+``CMAKE_DISABLE_FIND_PACKAGE_pybind11``
+  CMake variable, disables ``find_package(pybind11)`` when not ``REQUIRED``,
+  perhaps to force internal build.
+
+Commands
+========
+
+pybind11_add_module
+^^^^^^^^^^^^^^^^^^^
+
+This module defines the following commands to assist with creating Python modules:
+
+.. code-block:: cmake
+
+  pybind11_add_module(<target>
+    [STATIC|SHARED|MODULE]
+    [THIN_LTO] [OPT_SIZE] [NO_EXTRAS] [WITHOUT_SOABI]
+    <files>...
+    )
+
+Add a module and setup all helpers. You can select the type of the library; the
+default is ``MODULE``. There are several options:
+
+``OPT_SIZE``
+  Optimize for size, even if the ``CMAKE_BUILD_TYPE`` is not ``MinSizeRel``.
+``THIN_LTO``
+  Use thin LTO instead of regular if there's a choice (pybind11's selection
+  is disabled if ``CMAKE_INTERPROCEDURAL_OPTIMIZATIONS`` is set).
+``WITHOUT_SOABI``
+  Disable the SOABI component (``PYBIND11_FINDPYTHON`` mode only).
+``NO_EXTRAS``
+  Disable all extras, exit immediately after making the module.
+
+pybind11_strip
+^^^^^^^^^^^^^^
+
+.. code-block:: cmake
+
+  pybind11_strip(<target>)
+
+Strip a target after building it (linux/macOS), called by ``pybind11_add_module``.
+
+pybind11_extension
+^^^^^^^^^^^^^^^^^^
+
+.. code-block:: cmake
+
+    pybind11_extension(<target>)
+
+Sets the Python extension name correctly for Python on your platform, called by
+``pybind11_add_module``.
+
+pybind11_find_import(module)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: cmake
+
+    pybind11_find_import(<module> [VERSION <number>] [REQUIRED] [QUIET])
+
+See if a module is installed. Use the registered name (the one on PyPI). You
+can specify a ``VERSION``, and you can specify ``REQUIRED`` or ``QUIET``. Only available if
+``NOPYTHON`` mode is not active.  Sets ``module_VERSION`` and ``module_FOUND``. Caches the
+result once a valid install is found.
+
+Suggested usage
+===============
+
+Using ``find_package`` with version info is not recommended except for release versions.
+
+.. code-block:: cmake
+
+  find_package(pybind11 CONFIG)
+  find_package(pybind11 2.9 EXACT CONFIG REQUIRED)
+
+#]=============================================================================]
+
+####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() #######
+####### Any changes to this file will be overwritten by the next CMake run ####
+####### The input file was pybind11Config.cmake.in                            ########
+
+get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)
+
+macro(set_and_check _var _file)
+  set(${_var} "${_file}")
+  if(NOT EXISTS "${_file}")
+    message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !")
+  endif()
+endmacro()
+
+macro(check_required_components _NAME)
+  foreach(comp ${${_NAME}_FIND_COMPONENTS})
+    if(NOT ${_NAME}_${comp}_FOUND)
+      if(${_NAME}_FIND_REQUIRED_${comp})
+        set(${_NAME}_FOUND FALSE)
+      endif()
+    endif()
+  endforeach()
+endmacro()
+
+####################################################################################
+
+# Location of pybind11/pybind11.h
+# This will be relative unless explicitly set as absolute
+set(pybind11_INCLUDE_DIR "${PACKAGE_PREFIX_DIR}/include")
+
+set(pybind11_LIBRARY "")
+set(pybind11_DEFINITIONS USING_pybind11)
+set(pybind11_VERSION_TYPE "")
+
+check_required_components(pybind11)
+
+if(TARGET pybind11::python_link_helper)
+  # This has already been setup elsewhere, such as with a previous call or
+  # add_subdirectory
+  return()
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/pybind11Targets.cmake")
+
+# Easier to use / remember
+add_library(pybind11::headers IMPORTED INTERFACE)
+set_target_properties(pybind11::headers PROPERTIES INTERFACE_LINK_LIBRARIES
+                                                   pybind11::pybind11_headers)
+
+include("${CMAKE_CURRENT_LIST_DIR}/pybind11Common.cmake")
+
+if(NOT pybind11_FIND_QUIETLY)
+  message(
+    STATUS
+      "Found pybind11: ${pybind11_INCLUDE_DIR} (found version \"${pybind11_VERSION}${pybind11_VERSION_TYPE}\")"
+  )
+endif()
diff --git a/local_pybind11/pybind11/share/cmake/pybind11/pybind11ConfigVersion.cmake b/local_pybind11/pybind11/share/cmake/pybind11/pybind11ConfigVersion.cmake
new file mode 100644
index 000000000..b5c107fe7
--- /dev/null
+++ b/local_pybind11/pybind11/share/cmake/pybind11/pybind11ConfigVersion.cmake
@@ -0,0 +1,32 @@
+# This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+set(PACKAGE_VERSION "3.0.1")
+
+if (PACKAGE_FIND_VERSION_RANGE)
+  # Package version must be in the requested version range
+  if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN)
+      OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX)
+        OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX)))
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  endif()
+else()
+  if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+  endif()
+endif()
+
+
diff --git a/local_pybind11/pybind11/share/cmake/pybind11/pybind11GuessPythonExtSuffix.cmake b/local_pybind11/pybind11/share/cmake/pybind11/pybind11GuessPythonExtSuffix.cmake
new file mode 100644
index 000000000..b8c351ef0
--- /dev/null
+++ b/local_pybind11/pybind11/share/cmake/pybind11/pybind11GuessPythonExtSuffix.cmake
@@ -0,0 +1,86 @@
+cmake_minimum_required(VERSION 3.15...4.0)
+
+function(pybind11_guess_python_module_extension python)
+
+  # The SETUPTOOLS_EXT_SUFFIX environment variable takes precedence:
+  if(NOT DEFINED PYTHON_MODULE_EXT_SUFFIX AND DEFINED ENV{SETUPTOOLS_EXT_SUFFIX})
+    message(
+      STATUS
+        "Getting Python extension suffix from ENV{SETUPTOOLS_EXT_SUFFIX}: $ENV{SETUPTOOLS_EXT_SUFFIX}"
+    )
+    set(PYTHON_MODULE_EXT_SUFFIX
+        "$ENV{SETUPTOOLS_EXT_SUFFIX}"
+        CACHE
+          STRING
+          "Extension suffix for Python extension modules (Initialized from SETUPTOOLS_EXT_SUFFIX)")
+  endif()
+  # If that didn't work, use the Python_SOABI variable:
+  if(NOT DEFINED PYTHON_MODULE_EXT_SUFFIX AND DEFINED ${python}_SOABI)
+    message(
+      STATUS "Determining Python extension suffix based on ${python}_SOABI: ${${python}_SOABI}")
+    # The final extension depends on the system
+    set(_PY_BUILD_EXTENSION "${CMAKE_SHARED_MODULE_SUFFIX}")
+    if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
+      set(_PY_BUILD_EXTENSION ".pyd")
+    endif()
+    # If the SOABI already has an extension, use it as the full suffix
+    # (used for debug versions of Python on Windows)
+    if(${python}_SOABI MATCHES "\\.")
+      set(PYTHON_MODULE_EXT_SUFFIX "${${python}_SOABI}")
+      # If the SOABI is empty, this is usually a bug, but we generate a
+      # correct extension anyway, which is the best we can do
+    elseif("${${python}_SOABI}" STREQUAL "")
+      message(
+        WARNING
+          "${python}_SOABI is defined but empty. You may want to set PYTHON_MODULE_EXT_SUFFIX explicitly."
+      )
+      set(PYTHON_MODULE_EXT_SUFFIX "${_PY_BUILD_EXTENSION}")
+      # Otherwise, add the system-dependent extension to it
+    else()
+      set(PYTHON_MODULE_EXT_SUFFIX ".${${python}_SOABI}${_PY_BUILD_EXTENSION}")
+    endif()
+  endif()
+
+  # If we could not deduce the extension suffix, unset the results:
+  if(NOT DEFINED PYTHON_MODULE_EXT_SUFFIX)
+    unset(PYTHON_MODULE_DEBUG_POSTFIX PARENT_SCOPE)
+    unset(PYTHON_MODULE_EXTENSION PARENT_SCOPE)
+    unset(PYTHON_IS_DEBUG PARENT_SCOPE)
+    return()
+  endif()
+
+  # Sanity checks:
+  if(${python}_SOABI AND NOT (PYTHON_MODULE_EXT_SUFFIX STREQUAL ${python}_SOABI
+                              OR PYTHON_MODULE_EXT_SUFFIX MATCHES "\\.${${python}_SOABI}\\."))
+    message(
+      WARNING
+        "Python extension suffix (${PYTHON_MODULE_EXT_SUFFIX}) does not match ${python}_SOABI (${${python}_SOABI})."
+    )
+  endif()
+
+  # Separate file name postfix from extension: (https://github.com/pybind/pybind11/issues/4699)
+  get_filename_component(_PYTHON_MODULE_DEBUG_POSTFIX "${PYTHON_MODULE_EXT_SUFFIX}" NAME_WE)
+  get_filename_component(_PYTHON_MODULE_EXTENSION "${PYTHON_MODULE_EXT_SUFFIX}" EXT)
+
+  # Try to deduce the debug ABI from the extension suffix:
+  if(NOT DEFINED _PYTHON_IS_DEBUG)
+    if(_PYTHON_MODULE_EXTENSION MATCHES "^\\.(cpython-|cp|pypy)[0-9]+dm?-"
+       OR _PYTHON_MODULE_DEBUG_POSTFIX MATCHES "^_d")
+      set(_PYTHON_IS_DEBUG On)
+    else()
+      set(_PYTHON_IS_DEBUG Off)
+    endif()
+  endif()
+
+  # Return results
+  set(PYTHON_MODULE_DEBUG_POSTFIX
+      "${_PYTHON_MODULE_DEBUG_POSTFIX}"
+      PARENT_SCOPE)
+  set(PYTHON_MODULE_EXTENSION
+      "${_PYTHON_MODULE_EXTENSION}"
+      PARENT_SCOPE)
+  set(PYTHON_IS_DEBUG
+      "${_PYTHON_IS_DEBUG}"
+      PARENT_SCOPE)
+
+endfunction()
diff --git a/local_pybind11/pybind11/share/cmake/pybind11/pybind11NewTools.cmake b/local_pybind11/pybind11/share/cmake/pybind11/pybind11NewTools.cmake
new file mode 100644
index 000000000..e881ca7ca
--- /dev/null
+++ b/local_pybind11/pybind11/share/cmake/pybind11/pybind11NewTools.cmake
@@ -0,0 +1,353 @@
+# tools/pybind11NewTools.cmake -- Build system for the pybind11 modules
+#
+# Copyright (c) 2020 Wenzel Jakob <wenzel@inf.ethz.ch> and Henry Schreiner
+#
+# All rights reserved. Use of this source code is governed by a
+# BSD-style license that can be found in the LICENSE file.
+
+include_guard(DIRECTORY)
+
+get_property(
+  is_config
+  TARGET pybind11::headers
+  PROPERTY IMPORTED)
+
+if(pybind11_FIND_QUIETLY)
+  set(_pybind11_quiet QUIET)
+else()
+  set(_pybind11_quiet "")
+endif()
+
+if(NOT Python_FOUND AND NOT Python3_FOUND)
+  if(NOT DEFINED Python_FIND_IMPLEMENTATIONS)
+    set(Python_FIND_IMPLEMENTATIONS CPython PyPy)
+  endif()
+
+  # GitHub Actions like activation
+  if(NOT DEFINED Python_ROOT_DIR AND DEFINED ENV{pythonLocation})
+    set(Python_ROOT_DIR "$ENV{pythonLocation}")
+  endif()
+
+  # Interpreter should not be found when cross-compiling
+  if(_PYBIND11_CROSSCOMPILING)
+    set(_pybind11_interp_component "")
+  else()
+    set(_pybind11_interp_component Interpreter)
+  endif()
+
+  # Development.Module support (required for manylinux) started in 3.18
+  if(CMAKE_VERSION VERSION_LESS 3.18)
+    set(_pybind11_dev_component Development)
+  else()
+    set(_pybind11_dev_component Development.Module OPTIONAL_COMPONENTS Development.Embed)
+  endif()
+
+  # Callers need to be able to access Python_EXECUTABLE
+  set(_pybind11_global_keyword "")
+  if(NOT is_config AND NOT DEFINED Python_ARTIFACTS_INTERACTIVE)
+    set(Python_ARTIFACTS_INTERACTIVE TRUE)
+    if(NOT CMAKE_VERSION VERSION_LESS 3.24)
+      set(_pybind11_global_keyword "GLOBAL")
+    endif()
+  endif()
+
+  find_package(
+    Python 3.8 REQUIRED COMPONENTS ${_pybind11_interp_component} ${_pybind11_dev_component}
+                                   ${_pybind11_quiet} ${_pybind11_global_keyword})
+
+  # If we are in submodule mode, export the Python targets to global targets.
+  # If this behavior is not desired, FindPython _before_ pybind11.
+  if(NOT is_config
+     AND Python_ARTIFACTS_INTERACTIVE
+     AND _pybind11_global_keyword STREQUAL "")
+    if(TARGET Python::Python)
+      set_property(TARGET Python::Python PROPERTY IMPORTED_GLOBAL TRUE)
+    endif()
+    if(TARGET Python::Interpreter)
+      set_property(TARGET Python::Interpreter PROPERTY IMPORTED_GLOBAL TRUE)
+    endif()
+    if(TARGET Python::Module)
+      set_property(TARGET Python::Module PROPERTY IMPORTED_GLOBAL TRUE)
+    endif()
+  endif()
+
+  # Explicitly export version for callers (including our own functions)
+  if(NOT is_config AND Python_ARTIFACTS_INTERACTIVE)
+    set(Python_VERSION
+        "${Python_VERSION}"
+        CACHE INTERNAL "")
+    set(Python_VERSION_MAJOR
+        "${Python_VERSION_MAJOR}"
+        CACHE INTERNAL "")
+    set(Python_VERSION_MINOR
+        "${Python_VERSION_MINOR}"
+        CACHE INTERNAL "")
+    set(Python_VERSION_PATCH
+        "${Python_VERSION_PATCH}"
+        CACHE INTERNAL "")
+  endif()
+endif()
+
+if(Python_FOUND)
+  set(_Python
+      Python
+      CACHE INTERNAL "" FORCE)
+elseif(Python3_FOUND)
+  set(_Python
+      Python3
+      CACHE INTERNAL "" FORCE)
+endif()
+
+if(PYBIND11_MASTER_PROJECT)
+  if(${_Python}_INTERPRETER_ID MATCHES "PyPy")
+    message(STATUS "PyPy ${${_Python}_PyPy_VERSION} (Py ${${_Python}_VERSION})")
+  else()
+    message(STATUS "${_Python} ${${_Python}_VERSION}")
+  endif()
+endif()
+
+if(NOT _PYBIND11_CROSSCOMPILING)
+  # If a user finds Python, they may forget to include the Interpreter component
+  # and the following two steps require it. It is highly recommended by CMake
+  # when finding development libraries anyway, so we will require it.
+  if(NOT DEFINED ${_Python}_EXECUTABLE)
+    message(
+      FATAL_ERROR
+        "${_Python} was found without the Interpreter component. Pybind11 requires this component."
+    )
+
+  endif()
+
+  if(DEFINED PYBIND11_PYTHON_EXECUTABLE_LAST AND NOT ${_Python}_EXECUTABLE STREQUAL
+                                                 PYBIND11_PYTHON_EXECUTABLE_LAST)
+    # Detect changes to the Python version/binary in subsequent CMake runs, and refresh config if needed
+    unset(PYTHON_IS_DEBUG CACHE)
+    unset(PYTHON_MODULE_EXTENSION CACHE)
+  endif()
+
+  set(PYBIND11_PYTHON_EXECUTABLE_LAST
+      "${${_Python}_EXECUTABLE}"
+      CACHE INTERNAL "Python executable during the last CMake run")
+
+  if(NOT DEFINED PYTHON_IS_DEBUG)
+    # Debug check - see https://stackoverflow.com/questions/646518/python-how-to-detect-debug-Interpreter
+    execute_process(
+      COMMAND "${${_Python}_EXECUTABLE}" "-c"
+              "import sys; sys.exit(hasattr(sys, 'gettotalrefcount'))"
+      RESULT_VARIABLE _PYTHON_IS_DEBUG)
+    set(PYTHON_IS_DEBUG
+        "${_PYTHON_IS_DEBUG}"
+        CACHE INTERNAL "Python debug status")
+  endif()
+
+  # Get the suffix - SO is deprecated, should use EXT_SUFFIX, but this is
+  # required for PyPy3 (as of 7.3.1)
+  if(NOT DEFINED PYTHON_MODULE_EXTENSION OR NOT DEFINED PYTHON_MODULE_DEBUG_POSTFIX)
+    execute_process(
+      COMMAND
+        "${${_Python}_EXECUTABLE}" "-c"
+        "import sys, importlib; s = importlib.import_module('distutils.sysconfig' if sys.version_info < (3, 10) else 'sysconfig'); print(s.get_config_var('EXT_SUFFIX') or s.get_config_var('SO'))"
+      OUTPUT_VARIABLE _PYTHON_MODULE_EXT_SUFFIX
+      ERROR_VARIABLE _PYTHON_MODULE_EXT_SUFFIX_ERR
+      OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+    if(_PYTHON_MODULE_EXT_SUFFIX STREQUAL "")
+      message(
+        FATAL_ERROR
+          "pybind11 could not query the module file extension, likely the 'distutils'"
+          "package is not installed. Full error message:\n${_PYTHON_MODULE_EXT_SUFFIX_ERR}")
+    endif()
+
+    # This needs to be available for the pybind11_extension function
+    if(NOT DEFINED PYTHON_MODULE_DEBUG_POSTFIX)
+      get_filename_component(_PYTHON_MODULE_DEBUG_POSTFIX "${_PYTHON_MODULE_EXT_SUFFIX}" NAME_WE)
+      set(PYTHON_MODULE_DEBUG_POSTFIX
+          "${_PYTHON_MODULE_DEBUG_POSTFIX}"
+          CACHE INTERNAL "")
+    endif()
+
+    if(NOT DEFINED PYTHON_MODULE_EXTENSION)
+      get_filename_component(_PYTHON_MODULE_EXTENSION "${_PYTHON_MODULE_EXT_SUFFIX}" EXT)
+      set(PYTHON_MODULE_EXTENSION
+          "${_PYTHON_MODULE_EXTENSION}"
+          CACHE INTERNAL "")
+      if((NOT "$ENV{SETUPTOOLS_EXT_SUFFIX}" STREQUAL "")
+         AND (NOT "$ENV{SETUPTOOLS_EXT_SUFFIX}" STREQUAL "${PYTHON_MODULE_EXTENSION}"))
+        message(
+          AUTHOR_WARNING,
+          "SETUPTOOLS_EXT_SUFFIX is set to \"$ENV{SETUPTOOLS_EXT_SUFFIX}\", "
+          "but the auto-calculated Python extension suffix is \"${PYTHON_MODULE_EXTENSION}\". "
+          "This may cause problems when importing the Python extensions. "
+          "If you are using cross-compiling Python, you may need to "
+          "set PYTHON_MODULE_EXTENSION manually.")
+      endif()
+    endif()
+  endif()
+else()
+  if(NOT DEFINED PYTHON_IS_DEBUG
+     OR NOT DEFINED PYTHON_MODULE_EXTENSION
+     OR NOT DEFINED PYTHON_MODULE_DEBUG_POSTFIX)
+    include("${CMAKE_CURRENT_LIST_DIR}/pybind11GuessPythonExtSuffix.cmake")
+    pybind11_guess_python_module_extension("${_Python}")
+  endif()
+  # When cross-compiling, we cannot query the Python interpreter, so we require
+  # the user to set these variables explicitly.
+  if(NOT DEFINED PYTHON_IS_DEBUG
+     OR NOT DEFINED PYTHON_MODULE_EXTENSION
+     OR NOT DEFINED PYTHON_MODULE_DEBUG_POSTFIX)
+    message(
+      FATAL_ERROR
+        "When cross-compiling, you should set the PYTHON_IS_DEBUG, PYTHON_MODULE_EXTENSION and PYTHON_MODULE_DEBUG_POSTFIX \
+        variables appropriately before loading pybind11 (e.g. in your CMake toolchain file)")
+  endif()
+endif()
+
+# Python debug libraries expose slightly different objects before 3.8
+# https://docs.python.org/3.6/c-api/intro.html#debugging-builds
+# https://stackoverflow.com/questions/39161202/how-to-work-around-missing-pymodule-create2-in-amd64-win-python35-d-lib
+if(PYTHON_IS_DEBUG)
+  set_property(
+    TARGET pybind11::pybind11
+    APPEND
+    PROPERTY INTERFACE_COMPILE_DEFINITIONS Py_DEBUG)
+endif()
+
+# Check on every access - since Python can change - do nothing in that case.
+
+if(DEFINED ${_Python}_INCLUDE_DIRS)
+  # Only add Python for build - must be added during the import for config
+  # since it has to be re-discovered.
+  #
+  # This needs to be a target to be included after the local pybind11
+  # directory, just in case there there is an installed pybind11 sitting
+  # next to Python's includes. It also ensures Python is a SYSTEM library.
+  add_library(pybind11::python_headers INTERFACE IMPORTED)
+  set_property(
+    TARGET pybind11::python_headers PROPERTY INTERFACE_INCLUDE_DIRECTORIES
+                                             "$<BUILD_INTERFACE:${${_Python}_INCLUDE_DIRS}>")
+  set_property(
+    TARGET pybind11::pybind11
+    APPEND
+    PROPERTY INTERFACE_LINK_LIBRARIES pybind11::python_headers)
+  set(pybind11_INCLUDE_DIRS
+      "${pybind11_INCLUDE_DIR}" "${${_Python}_INCLUDE_DIRS}"
+      CACHE INTERNAL "Directories where pybind11 and possibly Python headers are located")
+endif()
+
+# In CMake 3.18+, you can find these separately, so include an if
+if(TARGET ${_Python}::Python)
+  set_property(
+    TARGET pybind11::embed
+    APPEND
+    PROPERTY INTERFACE_LINK_LIBRARIES ${_Python}::Python)
+endif()
+
+if(TARGET ${_Python}::Module)
+  # On Android, older versions of CMake don't know that modules need to link against
+  # libpython, so Python::Module will be an INTERFACE target with no associated library
+  # files.
+  get_target_property(module_target_type ${_Python}::Module TYPE)
+  if(ANDROID AND module_target_type STREQUAL INTERFACE_LIBRARY)
+    set_property(
+      TARGET ${_Python}::Module
+      APPEND
+      PROPERTY INTERFACE_LINK_LIBRARIES "${${_Python}_LIBRARIES}")
+  endif()
+
+  set_property(
+    TARGET pybind11::module
+    APPEND
+    PROPERTY INTERFACE_LINK_LIBRARIES ${_Python}::Module)
+else()
+  set_property(
+    TARGET pybind11::module
+    APPEND
+    PROPERTY INTERFACE_LINK_LIBRARIES pybind11::python_link_helper)
+endif()
+
+# WITHOUT_SOABI and WITH_SOABI will disable the custom extension handling used by pybind11.
+# WITH_SOABI is passed on to python_add_library.
+function(pybind11_add_module target_name)
+  cmake_parse_arguments(PARSE_ARGV 1 ARG
+                        "STATIC;SHARED;MODULE;THIN_LTO;OPT_SIZE;NO_EXTRAS;WITHOUT_SOABI" "" "")
+
+  if(ARG_STATIC)
+    set(lib_type STATIC)
+  elseif(ARG_SHARED)
+    set(lib_type SHARED)
+  else()
+    set(lib_type MODULE)
+  endif()
+
+  if("${_Python}" STREQUAL "Python")
+    python_add_library(${target_name} ${lib_type} ${ARG_UNPARSED_ARGUMENTS})
+  elseif("${_Python}" STREQUAL "Python3")
+    python3_add_library(${target_name} ${lib_type} ${ARG_UNPARSED_ARGUMENTS})
+  else()
+    message(FATAL_ERROR "Cannot detect FindPython version: ${_Python}")
+  endif()
+
+  target_link_libraries(${target_name} PRIVATE pybind11::headers)
+
+  if(lib_type STREQUAL "MODULE")
+    target_link_libraries(${target_name} PRIVATE pybind11::module)
+  else()
+    target_link_libraries(${target_name} PRIVATE pybind11::embed)
+  endif()
+
+  # -fvisibility=hidden is required to allow multiple modules compiled against
+  # different pybind versions to work properly, and for some features (e.g.
+  # py::module_local).  We force it on everything inside the `pybind11`
+  # namespace; also turning it on for a pybind module compilation here avoids
+  # potential warnings or issues from having mixed hidden/non-hidden types.
+  if(NOT DEFINED CMAKE_CXX_VISIBILITY_PRESET)
+    set_target_properties(${target_name} PROPERTIES CXX_VISIBILITY_PRESET "hidden")
+  endif()
+
+  if(NOT DEFINED CMAKE_CUDA_VISIBILITY_PRESET)
+    set_target_properties(${target_name} PROPERTIES CUDA_VISIBILITY_PRESET "hidden")
+  endif()
+
+  # If we don't pass a WITH_SOABI or WITHOUT_SOABI, use our own default handling of extensions
+  if(NOT ARG_WITHOUT_SOABI AND NOT "WITH_SOABI" IN_LIST ARG_UNPARSED_ARGUMENTS)
+    pybind11_extension(${target_name})
+  endif()
+
+  if(ARG_NO_EXTRAS)
+    return()
+  endif()
+
+  if(NOT DEFINED CMAKE_INTERPROCEDURAL_OPTIMIZATION)
+    if(ARG_THIN_LTO)
+      target_link_libraries(${target_name} PRIVATE pybind11::thin_lto)
+    else()
+      target_link_libraries(${target_name} PRIVATE pybind11::lto)
+    endif()
+  endif()
+
+  if(DEFINED CMAKE_BUILD_TYPE) # see https://github.com/pybind/pybind11/issues/4454
+    # Use case-insensitive comparison to match the result of $<CONFIG:cfgs>
+    string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
+    if(NOT MSVC AND NOT "${uppercase_CMAKE_BUILD_TYPE}" MATCHES DEBUG|RELWITHDEBINFO|NONE)
+      # Strip unnecessary sections of the binary on Linux/macOS
+      pybind11_strip(${target_name})
+    endif()
+  endif()
+
+  if(MSVC)
+    target_link_libraries(${target_name} PRIVATE pybind11::windows_extras)
+  endif()
+
+  if(ARG_OPT_SIZE)
+    target_link_libraries(${target_name} PRIVATE pybind11::opt_size)
+  endif()
+endfunction()
+
+function(pybind11_extension name)
+  # The extension is precomputed
+  set_target_properties(
+    ${name}
+    PROPERTIES PREFIX ""
+               DEBUG_POSTFIX "${PYTHON_MODULE_DEBUG_POSTFIX}"
+               SUFFIX "${PYTHON_MODULE_EXTENSION}")
+endfunction()
diff --git a/local_pybind11/pybind11/share/cmake/pybind11/pybind11Targets.cmake b/local_pybind11/pybind11/share/cmake/pybind11/pybind11Targets.cmake
new file mode 100644
index 000000000..b371a1fa4
--- /dev/null
+++ b/local_pybind11/pybind11/share/cmake/pybind11/pybind11Targets.cmake
@@ -0,0 +1,107 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
+   message(FATAL_ERROR "CMake >= 3.0.0 required")
+endif()
+if(CMAKE_VERSION VERSION_LESS "3.0.0")
+   message(FATAL_ERROR "CMake >= 3.0.0 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 3.0.0...3.29)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_cmake_targets_defined "")
+set(_cmake_targets_not_defined "")
+set(_cmake_expected_targets "")
+foreach(_cmake_expected_target IN ITEMS pybind11::pybind11_headers)
+  list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
+  if(TARGET "${_cmake_expected_target}")
+    list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
+  else()
+    list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}")
+  endif()
+endforeach()
+unset(_cmake_expected_target)
+if(_cmake_targets_defined STREQUAL _cmake_expected_targets)
+  unset(_cmake_targets_defined)
+  unset(_cmake_targets_not_defined)
+  unset(_cmake_expected_targets)
+  unset(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT _cmake_targets_defined STREQUAL "")
+  string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}")
+  string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n")
+endif()
+unset(_cmake_targets_defined)
+unset(_cmake_targets_not_defined)
+unset(_cmake_expected_targets)
+
+
+# Compute the installation prefix relative to this file.
+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)
+if(_IMPORT_PREFIX STREQUAL "/")
+  set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target pybind11::pybind11_headers
+add_library(pybind11::pybind11_headers INTERFACE IMPORTED)
+
+set_target_properties(pybind11::pybind11_headers PROPERTIES
+  INTERFACE_COMPILE_FEATURES "cxx_inheriting_constructors;cxx_user_literals;cxx_right_angle_brackets"
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
+)
+
+# Load information for each installed configuration.
+file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/pybind11Targets-*.cmake")
+foreach(_cmake_config_file IN LISTS _cmake_config_files)
+  include("${_cmake_config_file}")
+endforeach()
+unset(_cmake_config_file)
+unset(_cmake_config_files)
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(_cmake_target IN LISTS _cmake_import_check_targets)
+  if(CMAKE_VERSION VERSION_LESS "3.28"
+      OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target}
+      OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}")
+    foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
+      if(NOT EXISTS "${_cmake_file}")
+        message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
+   \"${_cmake_file}\"
+but this file does not exist.  Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+   \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+      endif()
+    endforeach()
+  endif()
+  unset(_cmake_file)
+  unset("_cmake_import_check_files_for_${_cmake_target}")
+endforeach()
+unset(_cmake_target)
+unset(_cmake_import_check_targets)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)
diff --git a/local_pybind11/pybind11/share/cmake/pybind11/pybind11Tools.cmake b/local_pybind11/pybind11/share/cmake/pybind11/pybind11Tools.cmake
new file mode 100644
index 000000000..a51efb39f
--- /dev/null
+++ b/local_pybind11/pybind11/share/cmake/pybind11/pybind11Tools.cmake
@@ -0,0 +1,217 @@
+# tools/pybind11Tools.cmake -- Build system for the pybind11 modules
+#
+# Copyright (c) 2020 Wenzel Jakob <wenzel.jakob@epfl.ch>
+#
+# All rights reserved. Use of this source code is governed by a
+# BSD-style license that can be found in the LICENSE file.
+
+include_guard(DIRECTORY)
+
+if(pybind11_FIND_QUIETLY)
+  set(_pybind11_quiet QUIET)
+else()
+  set(_pybind11_quiet "")
+endif()
+
+# If this is the first run, PYTHON_VERSION can stand in for PYBIND11_PYTHON_VERSION
+if(NOT DEFINED PYBIND11_PYTHON_VERSION AND DEFINED PYTHON_VERSION)
+  message(WARNING "Set PYBIND11_PYTHON_VERSION to search for a specific version, not "
+                  "PYTHON_VERSION (which is an output). Assuming that is what you "
+                  "meant to do and continuing anyway.")
+  set(PYBIND11_PYTHON_VERSION
+      "${PYTHON_VERSION}"
+      CACHE STRING "Python version to use for compiling modules")
+  unset(PYTHON_VERSION)
+  unset(PYTHON_VERSION CACHE)
+elseif(DEFINED PYBIND11_PYTHON_VERSION)
+  # If this is set as a normal variable, promote it
+  set(PYBIND11_PYTHON_VERSION
+      "${PYBIND11_PYTHON_VERSION}"
+      CACHE STRING "Python version to use for compiling modules")
+else()
+  # Make an empty cache variable.
+  set(PYBIND11_PYTHON_VERSION
+      ""
+      CACHE STRING "Python version to use for compiling modules")
+endif()
+
+# A user can set versions manually too
+set(Python_ADDITIONAL_VERSIONS
+    "3.12;3.11;3.10;3.9;3.8"
+    CACHE INTERNAL "")
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
+find_package(PythonLibsNew ${PYBIND11_PYTHON_VERSION} MODULE REQUIRED ${_pybind11_quiet})
+list(REMOVE_AT CMAKE_MODULE_PATH -1)
+
+# Makes a normal variable a cached variable
+macro(_PYBIND11_PROMOTE_TO_CACHE NAME)
+  set(_tmp_ptc "${${NAME}}")
+  # CMake 3.21 complains if a cached variable is shadowed by a normal one
+  unset(${NAME})
+  set(${NAME}
+      "${_tmp_ptc}"
+      CACHE INTERNAL "")
+endmacro()
+
+# Cache variables so pybind11_add_module can be used in parent projects
+_pybind11_promote_to_cache(PYTHON_INCLUDE_DIRS)
+_pybind11_promote_to_cache(PYTHON_LIBRARIES)
+_pybind11_promote_to_cache(PYTHON_MODULE_PREFIX)
+_pybind11_promote_to_cache(PYTHON_MODULE_EXTENSION)
+_pybind11_promote_to_cache(PYTHON_MODULE_DEBUG_POSTFIX)
+_pybind11_promote_to_cache(PYTHON_VERSION_MAJOR)
+_pybind11_promote_to_cache(PYTHON_VERSION_MINOR)
+_pybind11_promote_to_cache(PYTHON_VERSION)
+_pybind11_promote_to_cache(PYTHON_IS_DEBUG)
+
+if(PYBIND11_MASTER_PROJECT)
+  if(PYTHON_MODULE_EXTENSION MATCHES "pypy")
+    if(NOT DEFINED PYPY_VERSION)
+      execute_process(
+        COMMAND ${PYTHON_EXECUTABLE} -c
+                [=[import sys; sys.stdout.write(".".join(map(str, sys.pypy_version_info[:3])))]=]
+        OUTPUT_VARIABLE pypy_version)
+      set(PYPY_VERSION
+          ${pypy_version}
+          CACHE INTERNAL "")
+    endif()
+    message(STATUS "PYPY ${PYPY_VERSION} (Py ${PYTHON_VERSION})")
+  else()
+    message(STATUS "PYTHON ${PYTHON_VERSION}")
+  endif()
+endif()
+
+# Only add Python for build - must be added during the import for config since
+# it has to be re-discovered.
+#
+# This needs to be an target to it is included after the local pybind11
+# directory, just in case there are multiple versions of pybind11, we want the
+# one we expect.
+add_library(pybind11::python_headers INTERFACE IMPORTED)
+set_property(TARGET pybind11::python_headers PROPERTY INTERFACE_INCLUDE_DIRECTORIES
+                                                      "$<BUILD_INTERFACE:${PYTHON_INCLUDE_DIRS}>")
+set_property(
+  TARGET pybind11::pybind11
+  APPEND
+  PROPERTY INTERFACE_LINK_LIBRARIES pybind11::python_headers)
+
+set(pybind11_INCLUDE_DIRS
+    "${pybind11_INCLUDE_DIR}" "${PYTHON_INCLUDE_DIRS}"
+    CACHE INTERNAL "Directories where pybind11 and possibly Python headers are located")
+
+# Python debug libraries expose slightly different objects before 3.8
+# https://docs.python.org/3.6/c-api/intro.html#debugging-builds
+# https://stackoverflow.com/questions/39161202/how-to-work-around-missing-pymodule-create2-in-amd64-win-python35-d-lib
+if(PYTHON_IS_DEBUG)
+  set_property(
+    TARGET pybind11::pybind11
+    APPEND
+    PROPERTY INTERFACE_COMPILE_DEFINITIONS Py_DEBUG)
+endif()
+
+# The IMPORTED INTERFACE library here is to ensure that "debug" and "release" get processed outside
+# of a generator expression - https://gitlab.kitware.com/cmake/cmake/-/issues/18424, as they are
+# target_link_library keywords rather than real libraries.
+add_library(pybind11::_ClassicPythonLibraries IMPORTED INTERFACE)
+target_link_libraries(pybind11::_ClassicPythonLibraries INTERFACE ${PYTHON_LIBRARIES})
+target_link_libraries(
+  pybind11::module
+  INTERFACE
+    pybind11::python_link_helper
+    "$<$<OR:$<PLATFORM_ID:Windows>,$<PLATFORM_ID:Cygwin>,$<PLATFORM_ID:Android>>:pybind11::_ClassicPythonLibraries>"
+)
+
+target_link_libraries(pybind11::embed INTERFACE pybind11::pybind11
+                                                pybind11::_ClassicPythonLibraries)
+
+function(pybind11_extension name)
+  # The prefix and extension are provided by FindPythonLibsNew.cmake
+  set_target_properties(
+    ${name}
+    PROPERTIES PREFIX "${PYTHON_MODULE_PREFIX}"
+               DEBUG_POSTFIX "${PYTHON_MODULE_DEBUG_POSTFIX}"
+               SUFFIX "${PYTHON_MODULE_EXTENSION}")
+endfunction()
+
+# Build a Python extension module:
+# pybind11_add_module(<name> [MODULE | SHARED] [EXCLUDE_FROM_ALL]
+#                     [NO_EXTRAS] [THIN_LTO] [OPT_SIZE] source1 [source2 ...])
+#
+function(pybind11_add_module target_name)
+  set(options "MODULE;SHARED;EXCLUDE_FROM_ALL;NO_EXTRAS;SYSTEM;THIN_LTO;OPT_SIZE")
+  cmake_parse_arguments(ARG "${options}" "" "" ${ARGN})
+
+  if(ARG_MODULE AND ARG_SHARED)
+    message(FATAL_ERROR "Can't be both MODULE and SHARED")
+  elseif(ARG_SHARED)
+    set(lib_type SHARED)
+  else()
+    set(lib_type MODULE)
+  endif()
+
+  if(ARG_EXCLUDE_FROM_ALL)
+    set(exclude_from_all EXCLUDE_FROM_ALL)
+  else()
+    set(exclude_from_all "")
+  endif()
+
+  add_library(${target_name} ${lib_type} ${exclude_from_all} ${ARG_UNPARSED_ARGUMENTS})
+
+  target_link_libraries(${target_name} PRIVATE pybind11::module)
+
+  if(ARG_SYSTEM)
+    message(
+      STATUS
+        "Warning: this does not have an effect - use NO_SYSTEM_FROM_IMPORTED if using imported targets"
+    )
+  endif()
+
+  pybind11_extension(${target_name})
+
+  # -fvisibility=hidden is required to allow multiple modules compiled against
+  # different pybind versions to work properly, and for some features (e.g.
+  # py::module_local).  We force it on everything inside the `pybind11`
+  # namespace; also turning it on for a pybind module compilation here avoids
+  # potential warnings or issues from having mixed hidden/non-hidden types.
+  if(NOT DEFINED CMAKE_CXX_VISIBILITY_PRESET)
+    set_target_properties(${target_name} PROPERTIES CXX_VISIBILITY_PRESET "hidden")
+  endif()
+
+  if(NOT DEFINED CMAKE_CUDA_VISIBILITY_PRESET)
+    set_target_properties(${target_name} PROPERTIES CUDA_VISIBILITY_PRESET "hidden")
+  endif()
+
+  if(ARG_NO_EXTRAS)
+    return()
+  endif()
+
+  if(NOT DEFINED CMAKE_INTERPROCEDURAL_OPTIMIZATION)
+    if(ARG_THIN_LTO)
+      target_link_libraries(${target_name} PRIVATE pybind11::thin_lto)
+    else()
+      target_link_libraries(${target_name} PRIVATE pybind11::lto)
+    endif()
+  endif()
+
+  if(DEFINED CMAKE_BUILD_TYPE) # see https://github.com/pybind/pybind11/issues/4454
+    # Use case-insensitive comparison to match the result of $<CONFIG:cfgs>
+    string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
+    if(NOT MSVC AND NOT "${uppercase_CMAKE_BUILD_TYPE}" MATCHES DEBUG|RELWITHDEBINFO|NONE)
+      pybind11_strip(${target_name})
+    endif()
+  endif()
+
+  if(MSVC)
+    target_link_libraries(${target_name} PRIVATE pybind11::windows_extras)
+  endif()
+
+  if(ARG_OPT_SIZE)
+    target_link_libraries(${target_name} PRIVATE pybind11::opt_size)
+  endif()
+endfunction()
+
+# Provide general way to call common Python commands in "common" file.
+set(_Python
+    PYTHON
+    CACHE INTERNAL "" FORCE)
diff --git a/local_pybind11/pybind11/share/pkgconfig/__init__.py b/local_pybind11/pybind11/share/pkgconfig/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/local_pybind11/pybind11/share/pkgconfig/__pycache__/__init__.cpython-313.pyc b/local_pybind11/pybind11/share/pkgconfig/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f8d6f7f894f338d6c245999434b48646ec5dfbd7
GIT binary patch
literal 169
zcmey&%ge<81iZ{jnIQTxh=2h`DC08=kTI1Zok5e)ZzV$!6Oi{ABz4O}za+OnzaX<f
zw<NJBJ+(yF&@#QGG%4OxKPNLuzo4=tBR>yFC1vKN7#ivqXCxM->KA0EC+Fv-Wv1)L
r$7kkcmc+;F6;$5hu*uC&Da}c>D`Ev246?Ww#Q4a}$jDg43}gWS4WlUN

literal 0
HcmV?d00001

diff --git a/local_pybind11/pybind11/share/pkgconfig/pybind11.pc b/local_pybind11/pybind11/share/pkgconfig/pybind11.pc
new file mode 100644
index 000000000..ac6376737
--- /dev/null
+++ b/local_pybind11/pybind11/share/pkgconfig/pybind11.pc
@@ -0,0 +1,7 @@
+prefix=${pcfiledir}/../../
+includedir=${prefix}/include
+
+Name: pybind11
+Description: Seamless operability between C++11 and Python
+Version: 3.0.1
+Cflags: -I${includedir}
diff --git a/pendulum_alpha_compare.png b/pendulum_alpha_compare.png
new file mode 100644
index 0000000000000000000000000000000000000000..f1a9789296622147a79009acf616f3ad6261c31d
GIT binary patch
literal 71004
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%0An{(9SX)AN5|IW=jWd;eIXs0
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
SY!KWE@?1_uw&2N|&;JW=9Ak|D

literal 0
HcmV?d00001

diff --git a/pendulum_euler.csv b/pendulum_euler.csv
new file mode 100644
index 000000000..436554ec1
--- /dev/null
+++ b/pendulum_euler.csv
@@ -0,0 +1,2002 @@
+t,alpha,alpha_dot
+0,0.5,0
+0.005,0.5,-0.0235158
+0.01,0.499882,-0.0470316
+0.015,0.499647,-0.0705424
+0.02,0.499295,-0.094043
+0.025,0.498824,-0.117528
+0.03,0.498237,-0.140994
+0.035,0.497532,-0.164434
+0.04,0.49671,-0.187843
+0.045,0.49577,-0.211217
+0.05,0.494714,-0.234551
+0.055,0.493542,-0.257839
+0.06,0.492252,-0.281076
+0.065,0.490847,-0.304258
+0.07,0.489326,-0.327378
+0.075,0.487689,-0.350433
+0.08,0.485937,-0.373418
+0.085,0.484069,-0.396326
+0.09,0.482088,-0.419153
+0.095,0.479992,-0.441894
+0.1,0.477783,-0.464544
+0.105,0.47546,-0.487098
+0.11,0.473024,-0.50955
+0.115,0.470477,-0.531896
+0.12,0.467817,-0.554131
+0.125,0.465047,-0.57625
+0.13,0.462165,-0.598247
+0.135,0.459174,-0.620118
+0.14,0.456073,-0.641857
+0.145,0.452864,-0.66346
+0.15,0.449547,-0.684921
+0.155,0.446122,-0.706237
+0.16,0.442591,-0.7274
+0.165,0.438954,-0.748407
+0.17,0.435212,-0.769253
+0.175,0.431366,-0.789933
+0.18,0.427416,-0.810441
+0.185,0.423364,-0.830774
+0.19,0.41921,-0.850925
+0.195,0.414955,-0.87089
+0.2,0.410601,-0.890664
+0.205,0.406148,-0.910243
+0.21,0.401596,-0.929622
+0.215,0.396948,-0.948795
+0.22,0.392204,-0.967758
+0.225,0.387366,-0.986506
+0.23,0.382433,-1.00503
+0.235,0.377408,-1.02334
+0.24,0.372291,-1.04141
+0.245,0.367084,-1.05926
+0.25,0.361788,-1.07686
+0.255,0.356404,-1.09422
+0.26,0.350932,-1.11134
+0.265,0.345376,-1.1282
+0.27,0.339735,-1.1448
+0.275,0.334011,-1.16115
+0.28,0.328205,-1.17723
+0.285,0.322319,-1.19304
+0.29,0.316354,-1.20858
+0.295,0.310311,-1.22384
+0.3,0.304192,-1.23881
+0.305,0.297997,-1.25351
+0.31,0.29173,-1.26791
+0.315,0.28539,-1.28201
+0.32,0.27898,-1.29582
+0.325,0.272501,-1.30933
+0.33,0.265955,-1.32253
+0.335,0.259342,-1.33542
+0.34,0.252665,-1.348
+0.345,0.245925,-1.36026
+0.35,0.239123,-1.37221
+0.355,0.232262,-1.38382
+0.36,0.225343,-1.39511
+0.365,0.218368,-1.40607
+0.37,0.211337,-1.4167
+0.375,0.204254,-1.42699
+0.38,0.197119,-1.43694
+0.385,0.189934,-1.44654
+0.39,0.182702,-1.4558
+0.395,0.175423,-1.46472
+0.4,0.168099,-1.47328
+0.405,0.160733,-1.48148
+0.41,0.153325,-1.48933
+0.415,0.145878,-1.49682
+0.42,0.138394,-1.50395
+0.425,0.130875,-1.51072
+0.43,0.123321,-1.51712
+0.435,0.115735,-1.52316
+0.44,0.10812,-1.52882
+0.445,0.100475,-1.53411
+0.45,0.0928049,-1.53903
+0.455,0.0851098,-1.54358
+0.46,0.0773919,-1.54775
+0.465,0.0696531,-1.55154
+0.47,0.0618954,-1.55495
+0.475,0.0541207,-1.55799
+0.48,0.0463307,-1.56064
+0.485,0.0385275,-1.56291
+0.49,0.030713,-1.5648
+0.495,0.0228889,-1.56631
+0.5,0.0150574,-1.56743
+0.505,0.00722025,-1.56817
+0.51,-0.000620601,-1.56852
+0.515,-0.00846322,-1.56849
+0.52,-0.0163057,-1.56808
+0.525,-0.0241461,-1.56728
+0.53,-0.0319825,-1.56609
+0.535,-0.0398129,-1.56453
+0.54,-0.0476356,-1.56257
+0.545,-0.0554484,-1.56024
+0.55,-0.0632496,-1.55752
+0.555,-0.0710372,-1.55442
+0.56,-0.0788093,-1.55094
+0.565,-0.086564,-1.54708
+0.57,-0.0942994,-1.54284
+0.575,-0.102014,-1.53822
+0.58,-0.109705,-1.53322
+0.585,-0.117371,-1.52785
+0.59,-0.12501,-1.52211
+0.595,-0.132621,-1.51599
+0.6,-0.1402,-1.50951
+0.605,-0.147748,-1.50265
+0.61,-0.155261,-1.49543
+0.615,-0.162738,-1.48785
+0.62,-0.170178,-1.4799
+0.625,-0.177577,-1.47159
+0.63,-0.184935,-1.46293
+0.635,-0.19225,-1.45391
+0.64,-0.199519,-1.44454
+0.645,-0.206742,-1.43481
+0.65,-0.213916,-1.42475
+0.655,-0.22104,-1.41433
+0.66,-0.228111,-1.40358
+0.665,-0.235129,-1.39249
+0.67,-0.242092,-1.38106
+0.675,-0.248997,-1.3693
+0.68,-0.255844,-1.35721
+0.685,-0.26263,-1.3448
+0.69,-0.269354,-1.33207
+0.695,-0.276014,-1.31901
+0.7,-0.282609,-1.30565
+0.705,-0.289137,-1.29197
+0.71,-0.295597,-1.27798
+0.715,-0.301987,-1.26369
+0.72,-0.308305,-1.24911
+0.725,-0.314551,-1.23422
+0.73,-0.320722,-1.21905
+0.735,-0.326817,-1.20358
+0.74,-0.332835,-1.18784
+0.745,-0.338774,-1.17181
+0.75,-0.344634,-1.15551
+0.755,-0.350411,-1.13894
+0.76,-0.356106,-1.1221
+0.765,-0.361716,-1.105
+0.77,-0.367241,-1.08764
+0.775,-0.372679,-1.07003
+0.78,-0.37803,-1.05217
+0.785,-0.38329,-1.03407
+0.79,-0.388461,-1.01572
+0.795,-0.393539,-0.997146
+0.8,-0.398525,-0.978337
+0.805,-0.403417,-0.959303
+0.81,-0.408213,-0.940048
+0.815,-0.412914,-0.920576
+0.82,-0.417516,-0.900893
+0.825,-0.422021,-0.881004
+0.83,-0.426426,-0.860913
+0.835,-0.430731,-0.840625
+0.84,-0.434934,-0.820145
+0.845,-0.439034,-0.799478
+0.85,-0.443032,-0.778628
+0.855,-0.446925,-0.757601
+0.86,-0.450713,-0.736402
+0.865,-0.454395,-0.715036
+0.87,-0.45797,-0.693507
+0.875,-0.461438,-0.67182
+0.88,-0.464797,-0.649981
+0.885,-0.468047,-0.627995
+0.89,-0.471187,-0.605867
+0.895,-0.474216,-0.583601
+0.9,-0.477134,-0.561202
+0.905,-0.47994,-0.538677
+0.91,-0.482633,-0.516029
+0.915,-0.485214,-0.493264
+0.92,-0.48768,-0.470388
+0.925,-0.490032,-0.447404
+0.93,-0.492269,-0.424318
+0.935,-0.49439,-0.401136
+0.94,-0.496396,-0.377862
+0.945,-0.498285,-0.354502
+0.95,-0.500058,-0.33106
+0.955,-0.501713,-0.307541
+0.96,-0.503251,-0.283952
+0.965,-0.504671,-0.260296
+0.97,-0.505972,-0.236579
+0.975,-0.507155,-0.212807
+0.98,-0.508219,-0.188984
+0.985,-0.509164,-0.165115
+0.99,-0.50999,-0.141206
+0.995,-0.510696,-0.117261
+1,-0.511282,-0.0932862
+1.005,-0.511748,-0.0692862
+1.01,-0.512095,-0.0452663
+1.015,-0.512321,-0.0212316
+1.02,-0.512427,0.00281278
+1.025,-0.512413,0.0268617
+1.03,-0.512279,0.05091
+1.035,-0.512024,0.0749526
+1.04,-0.51165,0.0989843
+1.045,-0.511155,0.123
+1.05,-0.51054,0.146995
+1.055,-0.509805,0.170963
+1.06,-0.50895,0.194899
+1.065,-0.507975,0.2188
+1.07,-0.506881,0.242658
+1.075,-0.505668,0.266469
+1.08,-0.504336,0.290229
+1.085,-0.502885,0.313931
+1.09,-0.501315,0.337571
+1.095,-0.499627,0.361143
+1.1,-0.497821,0.384643
+1.105,-0.495898,0.408065
+1.11,-0.493858,0.431404
+1.115,-0.491701,0.454655
+1.12,-0.489427,0.477813
+1.125,-0.487038,0.500872
+1.13,-0.484534,0.523828
+1.135,-0.481915,0.546676
+1.14,-0.479182,0.569409
+1.145,-0.476335,0.592024
+1.15,-0.473374,0.614514
+1.155,-0.470302,0.636876
+1.16,-0.467117,0.659103
+1.165,-0.463822,0.681191
+1.17,-0.460416,0.703135
+1.175,-0.4569,0.724929
+1.18,-0.453276,0.746568
+1.185,-0.449543,0.768047
+1.19,-0.445703,0.789362
+1.195,-0.441756,0.810507
+1.2,-0.437703,0.831478
+1.205,-0.433546,0.852268
+1.21,-0.429284,0.872873
+1.215,-0.42492,0.893289
+1.22,-0.420454,0.91351
+1.225,-0.415886,0.933531
+1.23,-0.411218,0.953347
+1.235,-0.406452,0.972954
+1.24,-0.401587,0.992346
+1.245,-0.396625,1.01152
+1.25,-0.391568,1.03047
+1.255,-0.386415,1.04919
+1.26,-0.381169,1.06767
+1.265,-0.375831,1.08592
+1.27,-0.370401,1.10392
+1.275,-0.364882,1.12168
+1.28,-0.359273,1.13918
+1.285,-0.353578,1.15643
+1.29,-0.347795,1.17341
+1.295,-0.341928,1.19013
+1.3,-0.335978,1.20657
+1.305,-0.329945,1.22275
+1.31,-0.323831,1.23864
+1.315,-0.317638,1.25425
+1.32,-0.311367,1.26956
+1.325,-0.305019,1.28459
+1.33,-0.298596,1.29932
+1.335,-0.292099,1.31375
+1.34,-0.285531,1.32788
+1.345,-0.278891,1.34169
+1.35,-0.272183,1.35519
+1.355,-0.265407,1.36838
+1.36,-0.258565,1.38125
+1.365,-0.251659,1.39379
+1.37,-0.24469,1.406
+1.375,-0.23766,1.41789
+1.38,-0.23057,1.42943
+1.385,-0.223423,1.44064
+1.39,-0.21622,1.45151
+1.395,-0.208962,1.46203
+1.4,-0.201652,1.47221
+1.405,-0.194291,1.48203
+1.41,-0.186881,1.4915
+1.415,-0.179423,1.50062
+1.42,-0.17192,1.50937
+1.425,-0.164373,1.51776
+1.43,-0.156785,1.52579
+1.435,-0.149156,1.53345
+1.44,-0.141489,1.54074
+1.445,-0.133785,1.54765
+1.45,-0.126047,1.55419
+1.455,-0.118276,1.56036
+1.46,-0.110474,1.56615
+1.465,-0.102643,1.57156
+1.47,-0.0947853,1.57658
+1.475,-0.0869024,1.58122
+1.48,-0.0789962,1.58548
+1.485,-0.0710688,1.58935
+1.49,-0.0631221,1.59284
+1.495,-0.0551579,1.59593
+1.5,-0.0471782,1.59863
+1.505,-0.0391851,1.60095
+1.51,-0.0311803,1.60287
+1.515,-0.023166,1.6044
+1.52,-0.015144,1.60553
+1.525,-0.00711633,1.60628
+1.53,0.000915055,1.60663
+1.535,0.00894818,1.60658
+1.54,0.0169811,1.60614
+1.545,0.0250118,1.60531
+1.55,0.0330383,1.60408
+1.555,0.0410588,1.60246
+1.56,0.0490711,1.60045
+1.565,0.0570733,1.59804
+1.57,0.0650635,1.59524
+1.575,0.0730397,1.59206
+1.58,0.081,1.58848
+1.585,0.0889424,1.58451
+1.59,0.0968649,1.58015
+1.595,0.104766,1.57541
+1.6,0.112643,1.57028
+1.605,0.120494,1.56476
+1.61,0.128318,1.55887
+1.615,0.136112,1.55259
+1.62,0.143875,1.54594
+1.625,0.151605,1.5389
+1.63,0.159299,1.5315
+1.635,0.166957,1.52371
+1.64,0.174575,1.51556
+1.645,0.182153,1.50704
+1.65,0.189689,1.49816
+1.655,0.197179,1.48891
+1.66,0.204624,1.4793
+1.665,0.21202,1.46933
+1.67,0.219367,1.45901
+1.675,0.226662,1.44834
+1.68,0.233904,1.43732
+1.685,0.24109,1.42595
+1.69,0.24822,1.41424
+1.695,0.255291,1.40218
+1.7,0.262302,1.3898
+1.705,0.269251,1.37708
+1.71,0.276137,1.36403
+1.715,0.282957,1.35066
+1.72,0.28971,1.33696
+1.725,0.296395,1.32295
+1.73,0.30301,1.30863
+1.735,0.309553,1.29399
+1.74,0.316023,1.27905
+1.745,0.322418,1.2638
+1.75,0.328737,1.24826
+1.755,0.334978,1.23243
+1.76,0.34114,1.2163
+1.765,0.347222,1.19989
+1.77,0.353221,1.1832
+1.775,0.359137,1.16623
+1.78,0.364968,1.14899
+1.785,0.370713,1.13149
+1.79,0.376371,1.11372
+1.795,0.381939,1.09569
+1.8,0.387418,1.0774
+1.805,0.392805,1.05887
+1.81,0.398099,1.0401
+1.815,0.4033,1.02108
+1.82,0.408405,1.00183
+1.825,0.413414,0.982354
+1.83,0.418326,0.962648
+1.835,0.423139,0.942723
+1.84,0.427853,0.922581
+1.845,0.432466,0.90223
+1.85,0.436977,0.881672
+1.855,0.441385,0.860914
+1.86,0.44569,0.83996
+1.865,0.44989,0.818816
+1.87,0.453984,0.797486
+1.875,0.457971,0.775975
+1.88,0.461851,0.754288
+1.885,0.465623,0.732431
+1.89,0.469285,0.710409
+1.895,0.472837,0.688226
+1.9,0.476278,0.665888
+1.905,0.479607,0.6434
+1.91,0.482824,0.620767
+1.915,0.485928,0.597994
+1.92,0.488918,0.575086
+1.925,0.491794,0.552049
+1.93,0.494554,0.528887
+1.935,0.497198,0.505606
+1.94,0.499726,0.482211
+1.945,0.502137,0.458707
+1.95,0.504431,0.435099
+1.955,0.506606,0.411393
+1.96,0.508663,0.387593
+1.965,0.510601,0.363705
+1.97,0.51242,0.339734
+1.975,0.514119,0.315686
+1.98,0.515697,0.291564
+1.985,0.517155,0.267376
+1.99,0.518492,0.243125
+1.995,0.519707,0.218817
+2,0.520801,0.194458
+2.005,0.521774,0.170052
+2.01,0.522624,0.145604
+2.015,0.523352,0.121121
+2.02,0.523958,0.0966062
+2.025,0.524441,0.072066
+2.03,0.524801,0.0475052
+2.035,0.525038,0.0229292
+2.04,0.525153,-0.00165695
+2.045,0.525145,-0.0262479
+2.05,0.525014,-0.0508386
+2.055,0.524759,-0.0754237
+2.06,0.524382,-0.0999979
+2.065,0.523882,-0.124556
+2.07,0.523259,-0.149093
+2.075,0.522514,-0.173604
+2.08,0.521646,-0.198083
+2.085,0.520656,-0.222525
+2.09,0.519543,-0.246925
+2.095,0.518308,-0.271277
+2.1,0.516952,-0.295577
+2.105,0.515474,-0.319819
+2.11,0.513875,-0.343998
+2.115,0.512155,-0.368109
+2.12,0.510314,-0.392146
+2.125,0.508354,-0.416105
+2.13,0.506273,-0.439979
+2.135,0.504073,-0.463765
+2.14,0.501754,-0.487456
+2.145,0.499317,-0.511047
+2.15,0.496762,-0.534534
+2.155,0.494089,-0.55791
+2.16,0.4913,-0.581171
+2.165,0.488394,-0.604311
+2.17,0.485372,-0.627326
+2.175,0.482236,-0.65021
+2.18,0.478985,-0.672957
+2.185,0.47562,-0.695563
+2.19,0.472142,-0.718023
+2.195,0.468552,-0.74033
+2.2,0.46485,-0.762481
+2.205,0.461038,-0.78447
+2.21,0.457115,-0.806291
+2.215,0.453084,-0.82794
+2.22,0.448944,-0.849411
+2.225,0.444697,-0.870699
+2.23,0.440344,-0.8918
+2.235,0.435885,-0.912707
+2.24,0.431321,-0.933417
+2.245,0.426654,-0.953923
+2.25,0.421885,-0.974222
+2.255,0.417013,-0.994307
+2.26,0.412042,-1.01417
+2.265,0.406971,-1.03382
+2.27,0.401802,-1.05323
+2.275,0.396536,-1.07241
+2.28,0.391174,-1.09136
+2.285,0.385717,-1.11006
+2.29,0.380167,-1.12851
+2.295,0.374524,-1.14672
+2.3,0.36879,-1.16466
+2.305,0.362967,-1.18234
+2.31,0.357055,-1.19976
+2.315,0.351057,-1.2169
+2.32,0.344972,-1.23377
+2.325,0.338803,-1.25036
+2.33,0.332552,-1.26666
+2.335,0.326218,-1.28267
+2.34,0.319805,-1.29839
+2.345,0.313313,-1.31381
+2.35,0.306744,-1.32893
+2.355,0.300099,-1.34374
+2.36,0.293381,-1.35824
+2.365,0.286589,-1.37242
+2.37,0.279727,-1.38629
+2.375,0.272796,-1.39983
+2.38,0.265797,-1.41305
+2.385,0.258731,-1.42593
+2.39,0.251602,-1.43848
+2.395,0.244409,-1.45069
+2.4,0.237156,-1.46256
+2.405,0.229843,-1.47408
+2.41,0.222473,-1.48526
+2.415,0.215046,-1.49608
+2.42,0.207566,-1.50655
+2.425,0.200033,-1.51666
+2.43,0.19245,-1.5264
+2.435,0.184818,-1.53578
+2.44,0.177139,-1.5448
+2.445,0.169415,-1.55344
+2.45,0.161648,-1.56171
+2.455,0.153839,-1.56961
+2.46,0.145991,-1.57712
+2.465,0.138106,-1.58426
+2.47,0.130184,-1.59101
+2.475,0.122229,-1.59738
+2.48,0.114242,-1.60336
+2.485,0.106226,-1.60895
+2.49,0.0981809,-1.61415
+2.495,0.0901101,-1.61896
+2.5,0.0820153,-1.62337
+2.505,0.0738985,-1.62739
+2.51,0.0657615,-1.63101
+2.515,0.0576065,-1.63424
+2.52,0.0494353,-1.63706
+2.525,0.04125,-1.63948
+2.53,0.0330526,-1.64151
+2.535,0.024845,-1.64313
+2.54,0.0166294,-1.64435
+2.545,0.00840768,-1.64516
+2.55,0.000181873,-1.64557
+2.555,-0.00804599,-1.64558
+2.56,-0.0162739,-1.64519
+2.565,-0.0244998,-1.64439
+2.57,-0.0327218,-1.64319
+2.575,-0.0409377,-1.64158
+2.58,-0.0491456,-1.63958
+2.585,-0.0573435,-1.63717
+2.59,-0.0655294,-1.63435
+2.595,-0.0737011,-1.63114
+2.6,-0.0818568,-1.62753
+2.605,-0.0899945,-1.62352
+2.61,-0.0981121,-1.61911
+2.615,-0.106208,-1.61431
+2.62,-0.114279,-1.60911
+2.625,-0.122325,-1.60351
+2.63,-0.130342,-1.59753
+2.635,-0.13833,-1.59115
+2.64,-0.146286,-1.58439
+2.645,-0.154208,-1.57724
+2.65,-0.162094,-1.56971
+2.655,-0.169942,-1.56179
+2.66,-0.177751,-1.5535
+2.665,-0.185519,-1.54482
+2.67,-0.193243,-1.53578
+2.675,-0.200922,-1.52636
+2.68,-0.208554,-1.51657
+2.685,-0.216136,-1.50641
+2.69,-0.223669,-1.49589
+2.695,-0.231148,-1.48501
+2.7,-0.238573,-1.47378
+2.705,-0.245942,-1.46218
+2.71,-0.253253,-1.45024
+2.715,-0.260504,-1.43795
+2.72,-0.267694,-1.42532
+2.725,-0.27482,-1.41234
+2.73,-0.281882,-1.39903
+2.735,-0.288877,-1.38539
+2.74,-0.295804,-1.37142
+2.745,-0.302661,-1.35712
+2.75,-0.309447,-1.3425
+2.755,-0.316159,-1.32756
+2.76,-0.322797,-1.31231
+2.765,-0.329359,-1.29675
+2.77,-0.335842,-1.28089
+2.775,-0.342247,-1.26472
+2.78,-0.348571,-1.24826
+2.785,-0.354812,-1.23151
+2.79,-0.360969,-1.21447
+2.795,-0.367042,-1.19714
+2.8,-0.373027,-1.17954
+2.805,-0.378925,-1.16166
+2.81,-0.384733,-1.14352
+2.815,-0.390451,-1.12511
+2.82,-0.396077,-1.10644
+2.825,-0.401609,-1.08752
+2.83,-0.407046,-1.06834
+2.835,-0.412388,-1.04893
+2.84,-0.417633,-1.02927
+2.845,-0.422779,-1.00937
+2.85,-0.427826,-0.989247
+2.855,-0.432772,-0.968896
+2.86,-0.437617,-0.948325
+2.865,-0.442358,-0.927539
+2.87,-0.446996,-0.906542
+2.875,-0.451529,-0.88534
+2.88,-0.455955,-0.863937
+2.885,-0.460275,-0.842339
+2.89,-0.464487,-0.820552
+2.895,-0.468589,-0.798579
+2.9,-0.472582,-0.776427
+2.905,-0.476464,-0.7541
+2.91,-0.480235,-0.731603
+2.915,-0.483893,-0.708943
+2.92,-0.487438,-0.686123
+2.925,-0.490868,-0.66315
+2.93,-0.494184,-0.640028
+2.935,-0.497384,-0.616763
+2.94,-0.500468,-0.59336
+2.945,-0.503435,-0.569824
+2.95,-0.506284,-0.546161
+2.955,-0.509015,-0.522375
+2.96,-0.511627,-0.498472
+2.965,-0.514119,-0.474457
+2.97,-0.516491,-0.450336
+2.975,-0.518743,-0.426113
+2.98,-0.520874,-0.401795
+2.985,-0.522883,-0.377386
+2.99,-0.524769,-0.352891
+2.995,-0.526534,-0.328317
+3,-0.528175,-0.303667
+3.005,-0.529694,-0.278948
+3.01,-0.531089,-0.254164
+3.015,-0.532359,-0.229322
+3.02,-0.533506,-0.204426
+3.025,-0.534528,-0.179481
+3.03,-0.535426,-0.154493
+3.035,-0.536198,-0.129468
+3.04,-0.536845,-0.104409
+3.045,-0.537367,-0.0793239
+3.05,-0.537764,-0.0542164
+3.055,-0.538035,-0.0290922
+3.06,-0.538181,-0.00395653
+3.065,-0.5382,0.0211853
+3.07,-0.538094,0.0463279
+3.075,-0.537863,0.071466
+3.08,-0.537505,0.0965944
+3.085,-0.537022,0.121708
+3.09,-0.536414,0.146801
+3.095,-0.53568,0.171868
+3.1,-0.534821,0.196904
+3.105,-0.533836,0.221905
+3.11,-0.532727,0.246863
+3.115,-0.531492,0.271775
+3.12,-0.530133,0.296634
+3.125,-0.52865,0.321436
+3.13,-0.527043,0.346176
+3.135,-0.525312,0.370847
+3.14,-0.523458,0.395445
+3.145,-0.521481,0.419964
+3.15,-0.519381,0.444399
+3.155,-0.517159,0.468744
+3.16,-0.514815,0.492995
+3.165,-0.51235,0.517146
+3.17,-0.509764,0.541192
+3.175,-0.507058,0.565127
+3.18,-0.504233,0.588946
+3.185,-0.501288,0.612644
+3.19,-0.498225,0.636215
+3.195,-0.495044,0.659654
+3.2,-0.491746,0.682956
+3.205,-0.488331,0.706116
+3.21,-0.4848,0.729128
+3.215,-0.481155,0.751987
+3.22,-0.477395,0.774687
+3.225,-0.473521,0.797224
+3.23,-0.469535,0.819592
+3.235,-0.465437,0.841786
+3.24,-0.461228,0.8638
+3.245,-0.456909,0.88563
+3.25,-0.452481,0.90727
+3.255,-0.447945,0.928714
+3.26,-0.443301,0.949958
+3.265,-0.438551,0.970997
+3.27,-0.433696,0.991825
+3.275,-0.428737,1.01244
+3.28,-0.423675,1.03283
+3.285,-0.418511,1.05299
+3.29,-0.413246,1.07293
+3.295,-0.407881,1.09263
+3.3,-0.402418,1.11208
+3.305,-0.396858,1.13129
+3.31,-0.391201,1.15025
+3.315,-0.38545,1.16895
+3.32,-0.379605,1.1874
+3.325,-0.373668,1.20557
+3.33,-0.36764,1.22348
+3.335,-0.361523,1.2411
+3.34,-0.355317,1.25845
+3.345,-0.349025,1.27552
+3.35,-0.342648,1.29229
+3.355,-0.336186,1.30877
+3.36,-0.329642,1.32495
+3.365,-0.323018,1.34083
+3.37,-0.316313,1.3564
+3.375,-0.309531,1.37166
+3.38,-0.302673,1.3866
+3.385,-0.29574,1.40122
+3.39,-0.288734,1.41552
+3.395,-0.281656,1.42948
+3.4,-0.274509,1.44312
+3.405,-0.267293,1.45641
+3.41,-0.260011,1.46937
+3.415,-0.252665,1.48198
+3.42,-0.245255,1.49424
+3.425,-0.237783,1.50615
+3.43,-0.230253,1.5177
+3.435,-0.222664,1.5289
+3.44,-0.21502,1.53973
+3.445,-0.207321,1.55019
+3.45,-0.19957,1.56029
+3.455,-0.191769,1.57001
+3.46,-0.183919,1.57936
+3.465,-0.176022,1.58833
+3.47,-0.16808,1.59692
+3.475,-0.160096,1.60513
+3.48,-0.15207,1.61295
+3.485,-0.144005,1.62038
+3.49,-0.135903,1.62742
+3.495,-0.127766,1.63406
+3.5,-0.119596,1.64031
+3.505,-0.111394,1.64616
+3.51,-0.103163,1.65162
+3.515,-0.0949054,1.65667
+3.52,-0.0866221,1.66132
+3.525,-0.0783155,1.66556
+3.53,-0.0699877,1.6694
+3.535,-0.0616407,1.67283
+3.54,-0.0532766,1.67585
+3.545,-0.0448973,1.67846
+3.55,-0.036505,1.68066
+3.555,-0.0281017,1.68245
+3.56,-0.0196894,1.68383
+3.565,-0.0112703,1.6848
+3.57,-0.00284629,1.68535
+3.575,0.00558045,1.68549
+3.58,0.0140079,1.68522
+3.585,0.022434,1.68453
+3.59,0.0308566,1.68343
+3.595,0.0392737,1.68191
+3.6,0.0476833,1.67999
+3.605,0.0560833,1.67765
+3.61,0.0644715,1.6749
+3.615,0.072846,1.67174
+3.62,0.0812047,1.66817
+3.625,0.0895456,1.66419
+3.63,0.0978665,1.65981
+3.635,0.106166,1.65501
+3.64,0.114441,1.64982
+3.645,0.12269,1.64421
+3.65,0.130911,1.63821
+3.655,0.139102,1.63181
+3.66,0.147261,1.62501
+3.665,0.155386,1.61781
+3.67,0.163475,1.61022
+3.675,0.171526,1.60224
+3.68,0.179537,1.59386
+3.685,0.187507,1.58511
+3.69,0.195432,1.57596
+3.695,0.203312,1.56644
+3.7,0.211144,1.55653
+3.705,0.218927,1.54625
+3.71,0.226658,1.5356
+3.715,0.234336,1.52458
+3.72,0.241959,1.51319
+3.725,0.249525,1.50144
+3.73,0.257032,1.48932
+3.735,0.264479,1.47685
+3.74,0.271863,1.46403
+3.745,0.279183,1.45086
+3.75,0.286437,1.43734
+3.755,0.293624,1.42349
+3.76,0.300742,1.40929
+3.765,0.307788,1.39476
+3.77,0.314762,1.3799
+3.775,0.321661,1.36471
+3.78,0.328485,1.34921
+3.785,0.335231,1.33338
+3.79,0.341898,1.31725
+3.795,0.348484,1.3008
+3.8,0.354988,1.28405
+3.805,0.361408,1.267
+3.81,0.367743,1.24966
+3.815,0.373992,1.23203
+3.82,0.380152,1.21411
+3.825,0.386222,1.19591
+3.83,0.392202,1.17743
+3.835,0.398089,1.15868
+3.84,0.403882,1.13967
+3.845,0.409581,1.12039
+3.85,0.415183,1.10086
+3.855,0.420687,1.08107
+3.86,0.426092,1.06104
+3.865,0.431398,1.04077
+3.87,0.436601,1.02026
+3.875,0.441703,0.999517
+3.88,0.4467,0.978549
+3.885,0.451593,0.95736
+3.89,0.45638,0.935955
+3.895,0.46106,0.914338
+3.9,0.465631,0.892516
+3.905,0.470094,0.870493
+3.91,0.474446,0.848275
+3.915,0.478688,0.825867
+3.92,0.482817,0.803274
+3.925,0.486833,0.780501
+3.93,0.490736,0.757554
+3.935,0.494524,0.734438
+3.94,0.498196,0.711158
+3.945,0.501752,0.68772
+3.95,0.50519,0.664129
+3.955,0.508511,0.64039
+3.96,0.511713,0.616508
+3.965,0.514795,0.59249
+3.97,0.517758,0.56834
+3.975,0.5206,0.544063
+3.98,0.52332,0.519666
+3.985,0.525918,0.495153
+3.99,0.528394,0.470529
+3.995,0.530747,0.445801
+4,0.532976,0.420973
+4.005,0.535081,0.396051
+4.01,0.537061,0.37104
+4.015,0.538916,0.345945
+4.02,0.540646,0.320772
+4.025,0.54225,0.295527
+4.03,0.543727,0.270214
+4.035,0.545078,0.244839
+4.04,0.546302,0.219407
+4.045,0.5474,0.193924
+4.05,0.548369,0.168395
+4.055,0.549211,0.142826
+4.06,0.549925,0.117221
+4.065,0.550511,0.091586
+4.07,0.550969,0.0659268
+4.075,0.551299,0.0402485
+4.08,0.5515,0.0145564
+4.085,0.551573,-0.0111441
+4.09,0.551517,-0.0368476
+4.095,0.551333,-0.0625489
+4.1,0.55102,-0.0882424
+4.105,0.550579,-0.113923
+4.11,0.550009,-0.139585
+4.115,0.549311,-0.165223
+4.12,0.548485,-0.190832
+4.125,0.547531,-0.216407
+4.13,0.546449,-0.241941
+4.135,0.545239,-0.26743
+4.14,0.543902,-0.292869
+4.145,0.542438,-0.318251
+4.15,0.540847,-0.343572
+4.155,0.539129,-0.368826
+4.16,0.537285,-0.394008
+4.165,0.535315,-0.419112
+4.17,0.533219,-0.444133
+4.175,0.530998,-0.469065
+4.18,0.528653,-0.493904
+4.185,0.526184,-0.518643
+4.19,0.52359,-0.543278
+4.195,0.520874,-0.567802
+4.2,0.518035,-0.592212
+4.205,0.515074,-0.6165
+4.21,0.511991,-0.640662
+4.215,0.508788,-0.664692
+4.22,0.505465,-0.688585
+4.225,0.502022,-0.712336
+4.23,0.49846,-0.735939
+4.235,0.49478,-0.759388
+4.24,0.490983,-0.782679
+4.245,0.48707,-0.805806
+4.25,0.483041,-0.828763
+4.255,0.478897,-0.851546
+4.26,0.474639,-0.874148
+4.265,0.470269,-0.896565
+4.27,0.465786,-0.918791
+4.275,0.461192,-0.94082
+4.28,0.456488,-0.962648
+4.285,0.451675,-0.984269
+4.29,0.446753,-1.00568
+4.295,0.441725,-1.02687
+4.3,0.436591,-1.04784
+4.305,0.431351,-1.06858
+4.31,0.426008,-1.08909
+4.315,0.420563,-1.10936
+4.32,0.415016,-1.12938
+4.325,0.409369,-1.14916
+4.33,0.403623,-1.16868
+4.335,0.39778,-1.18795
+4.34,0.39184,-1.20695
+4.345,0.385806,-1.22568
+4.35,0.379677,-1.24414
+4.355,0.373456,-1.26232
+4.36,0.367145,-1.28021
+4.365,0.360744,-1.29782
+4.37,0.354255,-1.31513
+4.375,0.347679,-1.33215
+4.38,0.341018,-1.34886
+4.385,0.334274,-1.36526
+4.39,0.327448,-1.38136
+4.395,0.320541,-1.39713
+4.4,0.313555,-1.41259
+4.405,0.306492,-1.42772
+4.41,0.299354,-1.44251
+4.415,0.292141,-1.45698
+4.42,0.284856,-1.47111
+4.425,0.277501,-1.48489
+4.43,0.270076,-1.49833
+4.435,0.262585,-1.51141
+4.44,0.255028,-1.52415
+4.445,0.247407,-1.53652
+4.45,0.239724,-1.54853
+4.455,0.231982,-1.56018
+4.46,0.224181,-1.57146
+4.465,0.216323,-1.58236
+4.47,0.208412,-1.59289
+4.475,0.200447,-1.60304
+4.48,0.192432,-1.6128
+4.485,0.184368,-1.62218
+4.49,0.176257,-1.63118
+4.495,0.168101,-1.63978
+4.5,0.159902,-1.64798
+4.505,0.151662,-1.65579
+4.51,0.143383,-1.6632
+4.515,0.135067,-1.67021
+4.52,0.126716,-1.67682
+4.525,0.118332,-1.68302
+4.53,0.109917,-1.68881
+4.535,0.101473,-1.69419
+4.54,0.0930022,-1.69916
+4.545,0.0845064,-1.70371
+4.55,0.0759879,-1.70785
+4.555,0.0674486,-1.71158
+4.56,0.0588908,-1.71488
+4.565,0.0503164,-1.71777
+4.57,0.0417275,-1.72023
+4.575,0.0331263,-1.72228
+4.58,0.0245149,-1.72391
+4.585,0.0158954,-1.72511
+4.59,0.00726987,-1.72589
+4.595,-0.00135957,-1.72624
+4.6,-0.00999079,-1.72618
+4.605,-0.0186217,-1.72569
+4.61,-0.0272501,-1.72477
+4.615,-0.035874,-1.72344
+4.62,-0.0444912,-1.72168
+4.625,-0.0530996,-1.7195
+4.63,-0.061697,-1.71689
+4.635,-0.0702815,-1.71387
+4.64,-0.0788509,-1.71042
+4.645,-0.087403,-1.70656
+4.65,-0.0959358,-1.70228
+4.655,-0.104447,-1.69758
+4.66,-0.112935,-1.69247
+4.665,-0.121397,-1.68694
+4.67,-0.129832,-1.681
+4.675,-0.138237,-1.67465
+4.68,-0.14661,-1.66789
+4.685,-0.15495,-1.66072
+4.69,-0.163253,-1.65315
+4.695,-0.171519,-1.64518
+4.7,-0.179745,-1.63681
+4.705,-0.187929,-1.62804
+4.71,-0.196069,-1.61888
+4.715,-0.204164,-1.60932
+4.72,-0.21221,-1.59938
+4.725,-0.220207,-1.58905
+4.73,-0.228153,-1.57833
+4.735,-0.236044,-1.56724
+4.74,-0.24388,-1.55577
+4.745,-0.251659,-1.54392
+4.75,-0.259379,-1.53171
+4.755,-0.267037,-1.51913
+4.76,-0.274633,-1.50619
+4.765,-0.282164,-1.49288
+4.77,-0.289628,-1.47923
+4.775,-0.297024,-1.46522
+4.78,-0.304351,-1.45086
+4.785,-0.311605,-1.43616
+4.79,-0.318786,-1.42113
+4.795,-0.325891,-1.40575
+4.8,-0.33292,-1.39005
+4.805,-0.33987,-1.37402
+4.81,-0.34674,-1.35767
+4.815,-0.353529,-1.341
+4.82,-0.360234,-1.32402
+4.825,-0.366854,-1.30673
+4.83,-0.373388,-1.28913
+4.835,-0.379833,-1.27124
+4.84,-0.386189,-1.25306
+4.845,-0.392455,-1.23458
+4.85,-0.398628,-1.21582
+4.855,-0.404707,-1.19678
+4.86,-0.410691,-1.17747
+4.865,-0.416578,-1.15789
+4.87,-0.422367,-1.13804
+4.875,-0.428058,-1.11793
+4.88,-0.433647,-1.09757
+4.885,-0.439135,-1.07696
+4.89,-0.44452,-1.05611
+4.895,-0.4498,-1.03501
+4.9,-0.454975,-1.01369
+4.905,-0.460044,-0.992134
+4.91,-0.465005,-0.970356
+4.915,-0.469856,-0.948361
+4.92,-0.474598,-0.926153
+4.925,-0.479229,-0.903738
+4.93,-0.483748,-0.881122
+4.935,-0.488153,-0.858308
+4.94,-0.492445,-0.835304
+4.945,-0.496621,-0.812114
+4.95,-0.500682,-0.788744
+4.955,-0.504626,-0.765199
+4.96,-0.508452,-0.741484
+4.965,-0.512159,-0.717605
+4.97,-0.515747,-0.693568
+4.975,-0.519215,-0.669377
+4.98,-0.522562,-0.645039
+4.985,-0.525787,-0.620558
+4.99,-0.52889,-0.59594
+4.995,-0.531869,-0.57119
+5,-0.534725,-0.546315
+5.005,-0.537457,-0.521319
+5.01,-0.540064,-0.496207
+5.015,-0.542545,-0.470986
+5.02,-0.5449,-0.445661
+5.025,-0.547128,-0.420237
+5.03,-0.549229,-0.394719
+5.035,-0.551203,-0.369114
+5.04,-0.553048,-0.343426
+5.045,-0.554765,-0.317661
+5.05,-0.556354,-0.291824
+5.055,-0.557813,-0.265921
+5.06,-0.559142,-0.239957
+5.065,-0.560342,-0.213938
+5.07,-0.561412,-0.187869
+5.075,-0.562351,-0.161756
+5.08,-0.56316,-0.135603
+5.085,-0.563838,-0.109418
+5.09,-0.564385,-0.0832036
+5.095,-0.564801,-0.0569669
+5.1,-0.565086,-0.030713
+5.105,-0.565239,-0.0044473
+5.11,-0.565262,0.0218248
+5.115,-0.565153,0.0480978
+5.12,-0.564912,0.0743662
+5.125,-0.56454,0.100625
+5.13,-0.564037,0.126868
+5.135,-0.563403,0.15309
+5.14,-0.562637,0.179286
+5.145,-0.561741,0.20545
+5.15,-0.560714,0.231577
+5.155,-0.559556,0.257662
+5.16,-0.558267,0.283698
+5.165,-0.556849,0.30968
+5.17,-0.555301,0.335604
+5.175,-0.553623,0.361463
+5.18,-0.551815,0.387252
+5.185,-0.549879,0.412966
+5.19,-0.547814,0.438599
+5.195,-0.545621,0.464145
+5.2,-0.5433,0.489599
+5.205,-0.540852,0.514957
+5.21,-0.538278,0.540211
+5.215,-0.535577,0.565357
+5.22,-0.53275,0.590389
+5.225,-0.529798,0.615301
+5.23,-0.526721,0.640089
+5.235,-0.523521,0.664747
+5.24,-0.520197,0.689268
+5.245,-0.516751,0.713649
+5.25,-0.513183,0.737882
+5.255,-0.509493,0.761964
+5.26,-0.505683,0.785887
+5.265,-0.501754,0.809647
+5.27,-0.497706,0.833238
+5.275,-0.49354,0.856655
+5.28,-0.489256,0.879893
+5.285,-0.484857,0.902945
+5.29,-0.480342,0.925806
+5.295,-0.475713,0.948471
+5.3,-0.470971,0.970935
+5.305,-0.466116,0.993191
+5.31,-0.46115,1.01524
+5.315,-0.456074,1.03706
+5.32,-0.450889,1.05866
+5.325,-0.445595,1.08004
+5.33,-0.440195,1.10118
+5.335,-0.434689,1.12208
+5.34,-0.429079,1.14274
+5.345,-0.423365,1.16314
+5.35,-0.417549,1.18329
+5.355,-0.411633,1.20318
+5.36,-0.405617,1.22281
+5.365,-0.399503,1.24216
+5.37,-0.393292,1.26124
+5.375,-0.386986,1.28004
+5.38,-0.380586,1.29855
+5.385,-0.374093,1.31677
+5.39,-0.367509,1.3347
+5.395,-0.360836,1.35232
+5.4,-0.354074,1.36964
+5.405,-0.347226,1.38664
+5.41,-0.340293,1.40333
+5.415,-0.333276,1.41971
+5.42,-0.326177,1.43575
+5.425,-0.318999,1.45147
+5.43,-0.311741,1.46685
+5.435,-0.304407,1.4819
+5.44,-0.296998,1.4966
+5.445,-0.289515,1.51095
+5.45,-0.28196,1.52496
+5.455,-0.274335,1.5386
+5.46,-0.266642,1.55189
+5.465,-0.258883,1.56482
+5.47,-0.251058,1.57737
+5.475,-0.243172,1.58956
+5.48,-0.235224,1.60137
+5.485,-0.227217,1.6128
+5.49,-0.219153,1.62385
+5.495,-0.211034,1.63451
+5.5,-0.202861,1.64479
+5.505,-0.194637,1.65467
+5.51,-0.186364,1.66416
+5.515,-0.178043,1.67324
+5.52,-0.169677,1.68193
+5.525,-0.161267,1.69021
+5.53,-0.152816,1.69809
+5.535,-0.144326,1.70556
+5.54,-0.135798,1.71261
+5.545,-0.127235,1.71925
+5.55,-0.118639,1.72548
+5.555,-0.110011,1.73128
+5.56,-0.101355,1.73667
+5.565,-0.0926714,1.74163
+5.57,-0.0839633,1.74617
+5.575,-0.0752325,1.75028
+5.58,-0.066481,1.75397
+5.585,-0.0577112,1.75723
+5.59,-0.0489251,1.76006
+5.595,-0.0401248,1.76246
+5.6,-0.0313125,1.76442
+5.605,-0.0224904,1.76596
+5.61,-0.0136606,1.76706
+5.615,-0.00482529,1.76773
+5.62,0.00401337,1.76797
+5.625,0.0128532,1.76777
+5.63,0.0216921,1.76714
+5.635,0.0305278,1.76608
+5.64,0.0393582,1.76458
+5.645,0.0481811,1.76265
+5.65,0.0569943,1.76029
+5.655,0.0657957,1.75749
+5.66,0.0745832,1.75427
+5.665,0.0833546,1.75061
+5.67,0.0921076,1.74653
+5.675,0.10084,1.74202
+5.68,0.10955,1.73708
+5.685,0.118236,1.73172
+5.69,0.126894,1.72593
+5.695,0.135524,1.71972
+5.7,0.144123,1.7131
+5.705,0.152688,1.70605
+5.71,0.161218,1.69859
+5.715,0.169711,1.69072
+5.72,0.178165,1.68243
+5.725,0.186577,1.67374
+5.73,0.194946,1.66464
+5.735,0.203269,1.65514
+5.74,0.211545,1.64524
+5.745,0.219771,1.63494
+5.75,0.227946,1.62425
+5.755,0.236067,1.61316
+5.76,0.244133,1.60169
+5.765,0.252141,1.58984
+5.77,0.26009,1.5776
+5.775,0.267978,1.56498
+5.78,0.275803,1.552
+5.785,0.283563,1.53864
+5.79,0.291256,1.52492
+5.795,0.298881,1.51083
+5.8,0.306435,1.49639
+5.805,0.313917,1.48159
+5.81,0.321325,1.46645
+5.815,0.328657,1.45095
+5.82,0.335912,1.43512
+5.825,0.343088,1.41895
+5.83,0.350182,1.40245
+5.835,0.357195,1.38563
+5.84,0.364123,1.36848
+5.845,0.370965,1.35101
+5.85,0.37772,1.33323
+5.855,0.384386,1.31514
+5.86,0.390962,1.29674
+5.865,0.397446,1.27805
+5.87,0.403836,1.25907
+5.875,0.410131,1.23979
+5.88,0.41633,1.22023
+5.885,0.422432,1.2004
+5.89,0.428434,1.18029
+5.895,0.434335,1.15991
+5.9,0.440135,1.13927
+5.905,0.445831,1.11837
+5.91,0.451423,1.09722
+5.915,0.456909,1.07582
+5.92,0.462288,1.05418
+5.925,0.467559,1.03231
+5.93,0.47272,1.0102
+5.935,0.477771,0.987868
+5.94,0.482711,0.965314
+5.945,0.487537,0.942546
+5.95,0.49225,0.919569
+5.955,0.496848,0.896387
+5.96,0.50133,0.873007
+5.965,0.505695,0.849434
+5.97,0.509942,0.825673
+5.975,0.51407,0.801731
+5.98,0.518079,0.777612
+5.985,0.521967,0.753322
+5.99,0.525734,0.728866
+5.995,0.529378,0.70425
+6,0.532899,0.67948
+6.005,0.536297,0.654561
+6.01,0.53957,0.629499
+6.015,0.542717,0.604299
+6.02,0.545738,0.578966
+6.025,0.548633,0.553507
+6.03,0.551401,0.527926
+6.035,0.55404,0.50223
+6.04,0.556552,0.476423
+6.045,0.558934,0.450512
+6.05,0.561186,0.424501
+6.055,0.563309,0.398397
+6.06,0.565301,0.372205
+6.065,0.567162,0.345931
+6.07,0.568891,0.319579
+6.075,0.570489,0.293156
+6.08,0.571955,0.266667
+6.085,0.573288,0.240117
+6.09,0.574489,0.213513
+6.095,0.575557,0.186859
+6.1,0.576491,0.160161
+6.105,0.577292,0.133424
+6.11,0.577959,0.106655
+6.115,0.578492,0.079858
+6.12,0.578891,0.0530393
+6.125,0.579157,0.0262042
+6.13,0.579288,-0.000641762
+6.135,0.579284,-0.0274931
+6.14,0.579147,-0.0543443
+6.145,0.578875,-0.0811899
+6.15,0.578469,-0.108024
+6.155,0.577929,-0.134842
+6.16,0.577255,-0.161638
+6.165,0.576447,-0.188405
+6.17,0.575505,-0.21514
+6.175,0.574429,-0.241836
+6.18,0.57322,-0.268488
+6.185,0.571877,-0.295089
+6.19,0.570402,-0.321636
+6.195,0.568794,-0.348121
+6.2,0.567053,-0.37454
+6.205,0.56518,-0.400888
+6.21,0.563176,-0.427157
+6.215,0.56104,-0.453344
+6.22,0.558774,-0.479442
+6.225,0.556376,-0.505445
+6.23,0.553849,-0.531349
+6.235,0.551192,-0.557148
+6.24,0.548407,-0.582835
+6.245,0.545492,-0.608407
+6.25,0.54245,-0.633856
+6.255,0.539281,-0.659177
+6.26,0.535985,-0.684365
+6.265,0.532563,-0.709414
+6.27,0.529016,-0.734319
+6.275,0.525345,-0.759074
+6.28,0.521549,-0.783673
+6.285,0.517631,-0.808111
+6.29,0.51359,-0.832382
+6.295,0.509429,-0.856481
+6.3,0.505146,-0.880401
+6.305,0.500744,-0.904138
+6.31,0.496223,-0.927686
+6.315,0.491585,-0.951039
+6.32,0.48683,-0.974192
+6.325,0.481959,-0.997139
+6.33,0.476973,-1.01987
+6.335,0.471874,-1.04239
+6.34,0.466662,-1.06469
+6.345,0.461338,-1.08676
+6.35,0.455905,-1.10859
+6.355,0.450362,-1.13019
+6.36,0.444711,-1.15154
+6.365,0.438953,-1.17264
+6.37,0.43309,-1.19348
+6.375,0.427122,-1.21407
+6.38,0.421052,-1.23439
+6.385,0.41488,-1.25444
+6.39,0.408608,-1.27421
+6.395,0.402237,-1.2937
+6.4,0.395768,-1.3129
+6.405,0.389204,-1.33181
+6.41,0.382545,-1.35042
+6.415,0.375793,-1.36873
+6.42,0.368949,-1.38673
+6.425,0.362015,-1.40442
+6.43,0.354993,-1.42179
+6.435,0.347884,-1.43884
+6.44,0.34069,-1.45556
+6.445,0.333412,-1.47195
+6.45,0.326053,-1.48801
+6.455,0.318613,-1.50372
+6.46,0.311094,-1.51908
+6.465,0.303499,-1.5341
+6.47,0.295828,-1.54875
+6.475,0.288084,-1.56305
+6.48,0.280269,-1.57699
+6.485,0.272384,-1.59056
+6.49,0.264431,-1.60375
+6.495,0.256413,-1.61657
+6.5,0.24833,-1.62901
+6.505,0.240185,-1.64107
+6.51,0.231979,-1.65274
+6.515,0.223716,-1.66401
+6.52,0.215395,-1.6749
+6.525,0.207021,-1.68538
+6.53,0.198594,-1.69546
+6.535,0.190117,-1.70514
+6.54,0.181591,-1.71441
+6.545,0.173019,-1.72327
+6.55,0.164403,-1.73171
+6.555,0.155744,-1.73974
+6.56,0.147045,-1.74735
+6.565,0.138309,-1.75453
+6.57,0.129536,-1.7613
+6.575,0.12073,-1.76763
+6.58,0.111891,-1.77354
+6.585,0.103024,-1.77902
+6.59,0.0941287,-1.78406
+6.595,0.0852084,-1.78867
+6.6,0.076265,-1.79284
+6.605,0.0673008,-1.79658
+6.61,0.0583179,-1.79988
+6.615,0.0493185,-1.80274
+6.62,0.0403048,-1.80516
+6.625,0.031279,-1.80713
+6.63,0.0222433,-1.80867
+6.635,0.0132,-1.80976
+6.64,0.0041512,-1.81041
+6.645,-0.00490083,-1.81061
+6.65,-0.0139539,-1.81037
+6.655,-0.0230057,-1.80969
+6.66,-0.0320542,-1.80856
+6.665,-0.0410969,-1.80698
+6.67,-0.0501319,-1.80497
+6.675,-0.0591567,-1.80251
+6.68,-0.0681693,-1.79961
+6.685,-0.0771673,-1.79627
+6.69,-0.0861487,-1.79249
+6.695,-0.0951111,-1.78827
+6.7,-0.104052,-1.78361
+6.705,-0.112971,-1.77852
+6.71,-0.121863,-1.77299
+6.715,-0.130728,-1.76702
+6.72,-0.139563,-1.76063
+6.725,-0.148366,-1.75381
+6.73,-0.157135,-1.74656
+6.735,-0.165868,-1.73888
+6.74,-0.174563,-1.73078
+6.745,-0.183216,-1.72226
+6.75,-0.191828,-1.71333
+6.755,-0.200394,-1.70397
+6.76,-0.208914,-1.69421
+6.765,-0.217385,-1.68404
+6.77,-0.225806,-1.67346
+6.775,-0.234173,-1.66248
+6.78,-0.242485,-1.6511
+6.785,-0.250741,-1.63932
+6.79,-0.258937,-1.62715
+6.795,-0.267073,-1.61459
+6.8,-0.275146,-1.60164
+6.805,-0.283154,-1.58832
+6.81,-0.291096,-1.57461
+6.815,-0.298969,-1.56054
+6.82,-0.306772,-1.54609
+6.825,-0.314502,-1.53128
+6.83,-0.322158,-1.5161
+6.835,-0.329739,-1.50057
+6.84,-0.337242,-1.48469
+6.845,-0.344665,-1.46846
+6.85,-0.352007,-1.45189
+6.855,-0.359267,-1.43498
+6.86,-0.366442,-1.41773
+6.865,-0.37353,-1.40016
+6.87,-0.380531,-1.38226
+6.875,-0.387443,-1.36404
+6.88,-0.394263,-1.34551
+6.885,-0.40099,-1.32667
+6.89,-0.407624,-1.30752
+6.895,-0.414161,-1.28808
+6.9,-0.420602,-1.26834
+6.905,-0.426943,-1.24831
+6.91,-0.433185,-1.228
+6.915,-0.439325,-1.20741
+6.92,-0.445362,-1.18655
+6.925,-0.451295,-1.16542
+6.93,-0.457122,-1.14403
+6.935,-0.462842,-1.12238
+6.94,-0.468454,-1.10048
+6.945,-0.473956,-1.07833
+6.95,-0.479348,-1.05594
+6.955,-0.484627,-1.03332
+6.96,-0.489794,-1.01047
+6.965,-0.494846,-0.987394
+6.97,-0.499783,-0.9641
+6.975,-0.504604,-0.940593
+6.98,-0.509307,-0.91688
+6.985,-0.513891,-0.892964
+6.99,-0.518356,-0.868853
+6.995,-0.5227,-0.844551
+7,-0.526923,-0.820064
+7.005,-0.531023,-0.795398
+7.01,-0.535,-0.770558
+7.015,-0.538853,-0.745551
+7.02,-0.542581,-0.72038
+7.025,-0.546183,-0.695054
+7.03,-0.549658,-0.669576
+7.035,-0.553006,-0.643952
+7.04,-0.556226,-0.618189
+7.045,-0.559317,-0.592291
+7.05,-0.562278,-0.566265
+7.055,-0.565109,-0.540115
+7.06,-0.56781,-0.513849
+7.065,-0.570379,-0.48747
+7.07,-0.572817,-0.460986
+7.075,-0.575122,-0.434401
+7.08,-0.577294,-0.40772
+7.085,-0.579332,-0.380951
+7.09,-0.581237,-0.354098
+7.095,-0.583007,-0.327167
+7.1,-0.584643,-0.300163
+7.105,-0.586144,-0.273092
+7.11,-0.58751,-0.24596
+7.115,-0.588739,-0.218772
+7.12,-0.589833,-0.191534
+7.125,-0.590791,-0.164251
+7.13,-0.591612,-0.136929
+7.135,-0.592297,-0.109574
+7.14,-0.592845,-0.0821911
+7.145,-0.593256,-0.0547857
+7.15,-0.59353,-0.0273637
+7.155,-0.593666,6.95205e-05
+7.16,-0.593666,0.0275083
+7.165,-0.593528,0.054947
+7.17,-0.593254,0.0823802
+7.175,-0.592842,0.109802
+7.18,-0.592293,0.137207
+7.185,-0.591607,0.16459
+7.19,-0.590784,0.191945
+7.195,-0.589824,0.219267
+7.2,-0.588728,0.246549
+7.205,-0.587495,0.273787
+7.21,-0.586126,0.300974
+7.215,-0.584621,0.328105
+7.22,-0.582981,0.355175
+7.225,-0.581205,0.382178
+7.23,-0.579294,0.409108
+7.235,-0.577248,0.43596
+7.24,-0.575069,0.462727
+7.245,-0.572755,0.489405
+7.25,-0.570308,0.515988
+7.255,-0.567728,0.542469
+7.26,-0.565016,0.568844
+7.265,-0.562171,0.595107
+7.27,-0.559196,0.621252
+7.275,-0.55609,0.647273
+7.28,-0.552853,0.673165
+7.285,-0.549487,0.698922
+7.29,-0.545993,0.724539
+7.295,-0.54237,0.750009
+7.3,-0.53862,0.775327
+7.305,-0.534743,0.800487
+7.31,-0.530741,0.825484
+7.315,-0.526614,0.850312
+7.32,-0.522362,0.874965
+7.325,-0.517987,0.899437
+7.33,-0.51349,0.923723
+7.335,-0.508871,0.947818
+7.34,-0.504132,0.971714
+7.345,-0.499274,0.995408
+7.35,-0.494297,1.01889
+7.355,-0.489202,1.04216
+7.36,-0.483991,1.06521
+7.365,-0.478665,1.08804
+7.37,-0.473225,1.11063
+7.375,-0.467672,1.13298
+7.38,-0.462007,1.1551
+7.385,-0.456232,1.17696
+7.39,-0.450347,1.19857
+7.395,-0.444354,1.21992
+7.4,-0.438254,1.241
+7.405,-0.432049,1.26182
+7.41,-0.42574,1.28236
+7.415,-0.419328,1.30262
+7.42,-0.412815,1.32259
+7.425,-0.406202,1.34226
+7.43,-0.399491,1.36165
+7.435,-0.392683,1.38072
+7.44,-0.385779,1.39949
+7.445,-0.378782,1.41795
+7.45,-0.371692,1.43609
+7.455,-0.364512,1.4539
+7.46,-0.357242,1.47139
+7.465,-0.349885,1.48854
+7.47,-0.342442,1.50535
+7.475,-0.334916,1.52183
+7.48,-0.327307,1.53795
+7.485,-0.319617,1.55372
+7.49,-0.311848,1.56913
+7.495,-0.304003,1.58418
+7.5,-0.296082,1.59886
+7.505,-0.288087,1.61317
+7.51,-0.280022,1.62711
+7.515,-0.271886,1.64066
+7.52,-0.263683,1.65384
+7.525,-0.255414,1.66662
+7.53,-0.24708,1.67901
+7.535,-0.238685,1.69101
+7.54,-0.23023,1.70261
+7.545,-0.221717,1.7138
+7.55,-0.213148,1.72459
+7.555,-0.204525,1.73496
+7.56,-0.195851,1.74492
+7.565,-0.187126,1.75447
+7.57,-0.178354,1.76359
+7.575,-0.169536,1.7723
+7.58,-0.160674,1.78057
+7.585,-0.151771,1.78842
+7.59,-0.142829,1.79584
+7.595,-0.13385,1.80282
+7.6,-0.124836,1.80936
+7.605,-0.115789,1.81547
+7.61,-0.106712,1.82114
+7.615,-0.097606,1.82636
+7.62,-0.0884742,1.83114
+7.625,-0.0793185,1.83548
+7.63,-0.0701412,1.83936
+7.635,-0.0609443,1.8428
+7.64,-0.0517304,1.84579
+7.645,-0.0425014,1.84832
+7.65,-0.0332598,1.85041
+7.655,-0.0240078,1.85204
+7.66,-0.0147476,1.85322
+7.665,-0.00548149,1.85394
+7.67,0.0037882,1.85421
+7.675,0.0130592,1.85402
+7.68,0.0223294,1.85338
+7.685,0.0315963,1.85229
+7.69,0.0408577,1.85074
+7.695,0.0501114,1.84873
+7.7,0.059355,1.84628
+7.705,0.0685864,1.84337
+7.71,0.0778033,1.84001
+7.715,0.0870033,1.83619
+7.72,0.0961843,1.83193
+7.725,0.105344,1.82722
+7.73,0.11448,1.82206
+7.735,0.12359,1.81646
+7.74,0.132673,1.81041
+7.745,0.141725,1.80392
+7.75,0.150744,1.797
+7.755,0.159729,1.78963
+7.76,0.168677,1.78183
+7.765,0.177587,1.77359
+7.77,0.186455,1.76493
+7.775,0.195279,1.75584
+7.78,0.204058,1.74632
+7.785,0.21279,1.73638
+7.79,0.221472,1.72602
+7.795,0.230102,1.71525
+7.8,0.238678,1.70406
+7.805,0.247198,1.69246
+7.81,0.255661,1.68046
+7.815,0.264063,1.66806
+7.82,0.272403,1.65525
+7.825,0.28068,1.64206
+7.83,0.28889,1.62847
+7.835,0.297032,1.6145
+7.84,0.305105,1.60014
+7.845,0.313105,1.58541
+7.85,0.321033,1.5703
+7.855,0.328884,1.55482
+7.86,0.336658,1.53898
+7.865,0.344353,1.52277
+7.87,0.351967,1.50622
+7.875,0.359498,1.48931
+7.88,0.366944,1.47205
+7.885,0.374305,1.45445
+7.89,0.381577,1.43652
+7.895,0.38876,1.41825
+7.9,0.395851,1.39966
+7.905,0.402849,1.38075
+7.91,0.409753,1.36152
+7.915,0.41656,1.34198
+7.92,0.42327,1.32213
+7.925,0.429881,1.30198
+7.93,0.436391,1.28154
+7.935,0.442799,1.26081
+7.94,0.449103,1.23979
+7.945,0.455302,1.2185
+7.95,0.461394,1.19693
+7.955,0.467379,1.17509
+7.96,0.473254,1.15299
+7.965,0.479019,1.13064
+7.97,0.484672,1.10803
+7.975,0.490213,1.08518
+7.98,0.495638,1.06208
+7.985,0.500949,1.03875
+7.99,0.506143,1.0152
+7.995,0.511219,0.991418
+8,0.516176,0.967421
+8.005,0.521013,0.943212
+8.01,0.525729,0.918797
+8.015,0.530323,0.894181
+8.02,0.534794,0.869371
+8.025,0.539141,0.844372
+8.03,0.543362,0.81919
+8.035,0.547458,0.79383
+8.04,0.551428,0.768299
+8.045,0.555269,0.742602
+8.05,0.558982,0.716744
+8.055,0.562566,0.690731
+8.06,0.566019,0.66457
+8.065,0.569342,0.638266
+8.07,0.572534,0.611824
+8.075,0.575593,0.585251
+8.08,0.578519,0.558551
+8.085,0.581312,0.531731
+8.09,0.58397,0.504797
+8.095,0.586494,0.477754
+8.1,0.588883,0.450607
+8.105,0.591136,0.423363
+8.11,0.593253,0.396027
+8.115,0.595233,0.368605
+8.12,0.597076,0.341103
+8.125,0.598782,0.313526
+8.13,0.600349,0.285879
+8.135,0.601779,0.25817
+8.14,0.60307,0.230402
+8.145,0.604222,0.202582
+8.15,0.605235,0.174716
+8.155,0.606108,0.146808
+8.16,0.606842,0.118866
+8.165,0.607436,0.0908939
+8.17,0.607891,0.0628979
+8.175,0.608205,0.0348836
+8.18,0.60838,0.00685665
+8.185,0.608414,-0.0211773
+8.19,0.608308,-0.0492127
+8.195,0.608062,-0.0772438
+8.2,0.607676,-0.105265
+8.205,0.60715,-0.133271
+8.21,0.606483,-0.161255
+8.215,0.605677,-0.189213
+8.22,0.604731,-0.217138
+8.225,0.603645,-0.245025
+8.23,0.60242,-0.272868
+8.235,0.601056,-0.300661
+8.24,0.599552,-0.3284
+8.245,0.59791,-0.356077
+8.25,0.59613,-0.383688
+8.255,0.594212,-0.411227
+8.26,0.592156,-0.438688
+8.265,0.589962,-0.466066
+8.27,0.587632,-0.493353
+8.275,0.585165,-0.520546
+8.28,0.582562,-0.547639
+8.285,0.579824,-0.574624
+8.29,0.576951,-0.601497
+8.295,0.573943,-0.628253
+8.3,0.570802,-0.654884
+8.305,0.567528,-0.681386
+8.31,0.564121,-0.707753
+8.315,0.560582,-0.733979
+8.32,0.556912,-0.760058
+8.325,0.553112,-0.785984
+8.33,0.549182,-0.811752
+8.335,0.545123,-0.837355
+8.34,0.540936,-0.862789
+8.345,0.536622,-0.888047
+8.35,0.532182,-0.913123
+8.355,0.527617,-0.938012
+8.36,0.522927,-0.962707
+8.365,0.518113,-0.987204
+8.37,0.513177,-1.0115
+8.375,0.50812,-1.03558
+8.38,0.502942,-1.05944
+8.385,0.497644,-1.08308
+8.39,0.492229,-1.1065
+8.395,0.486697,-1.12968
+8.4,0.481048,-1.15262
+8.405,0.475285,-1.17531
+8.41,0.469408,-1.19776
+8.415,0.46342,-1.21995
+8.42,0.45732,-1.24187
+8.425,0.451111,-1.26353
+8.43,0.444793,-1.28492
+8.435,0.438368,-1.30602
+8.44,0.431838,-1.32684
+8.445,0.425204,-1.34737
+8.45,0.418467,-1.3676
+8.455,0.411629,-1.38754
+8.46,0.404692,-1.40716
+8.465,0.397656,-1.42647
+8.47,0.390523,-1.44547
+8.475,0.383296,-1.46414
+8.48,0.375975,-1.48248
+8.485,0.368563,-1.50049
+8.49,0.36106,-1.51817
+8.495,0.35347,-1.53549
+8.5,0.345792,-1.55247
+8.505,0.33803,-1.5691
+8.51,0.330184,-1.58536
+8.515,0.322257,-1.60127
+8.52,0.314251,-1.6168
+8.525,0.306167,-1.63196
+8.53,0.298007,-1.64675
+8.535,0.289774,-1.66115
+8.54,0.281468,-1.67516
+8.545,0.273092,-1.68879
+8.55,0.264648,-1.70202
+8.555,0.256138,-1.71485
+8.56,0.247564,-1.72727
+8.565,0.238927,-1.73929
+8.57,0.230231,-1.7509
+8.575,0.221476,-1.76209
+8.58,0.212666,-1.77287
+8.585,0.203802,-1.78322
+8.59,0.194885,-1.79315
+8.595,0.18592,-1.80265
+8.6,0.176906,-1.81172
+8.605,0.167848,-1.82035
+8.61,0.158746,-1.82854
+8.615,0.149603,-1.8363
+8.62,0.140422,-1.84361
+8.625,0.131204,-1.85047
+8.63,0.121952,-1.85689
+8.635,0.112667,-1.86286
+8.64,0.103353,-1.86837
+8.645,0.094011,-1.87343
+8.65,0.0846438,-1.87804
+8.655,0.0752537,-1.88218
+8.66,0.0658428,-1.88587
+8.665,0.0564134,-1.8891
+8.67,0.0469679,-1.89186
+8.675,0.0375086,-1.89417
+8.68,0.0280378,-1.896
+8.685,0.0185578,-1.89738
+8.69,0.00907086,-1.89829
+8.695,-0.000420593,-1.89874
+8.7,-0.00991427,-1.89871
+8.705,-0.0194078,-1.89823
+8.71,-0.028899,-1.89728
+8.715,-0.0383854,-1.89586
+8.72,-0.0478647,-1.89398
+8.725,-0.0573345,-1.89163
+8.73,-0.0667927,-1.88882
+8.735,-0.0762368,-1.88555
+8.74,-0.0856645,-1.88181
+8.745,-0.0950736,-1.87761
+8.75,-0.104462,-1.87296
+8.755,-0.113826,-1.86784
+8.76,-0.123166,-1.86227
+8.765,-0.132477,-1.85624
+8.77,-0.141758,-1.84977
+8.775,-0.151007,-1.84284
+8.78,-0.160221,-1.83546
+8.785,-0.169398,-1.82763
+8.79,-0.178537,-1.81936
+8.795,-0.187633,-1.81065
+8.8,-0.196687,-1.8015
+8.805,-0.205694,-1.79192
+8.81,-0.214654,-1.7819
+8.815,-0.223563,-1.77145
+8.82,-0.232421,-1.76058
+8.825,-0.241223,-1.74928
+8.83,-0.24997,-1.73756
+8.835,-0.258658,-1.72543
+8.84,-0.267285,-1.71288
+8.845,-0.275849,-1.69993
+8.85,-0.284349,-1.68657
+8.855,-0.292782,-1.67281
+8.86,-0.301146,-1.65865
+8.865,-0.309439,-1.6441
+8.87,-0.317659,-1.62916
+8.875,-0.325805,-1.61384
+8.88,-0.333874,-1.59814
+8.885,-0.341865,-1.58207
+8.89,-0.349775,-1.56563
+8.895,-0.357604,-1.54882
+8.9,-0.365348,-1.53165
+8.905,-0.373006,-1.51412
+8.91,-0.380577,-1.49625
+8.915,-0.388058,-1.47803
+8.92,-0.395448,-1.45947
+8.925,-0.402745,-1.44057
+8.93,-0.409948,-1.42135
+8.935,-0.417055,-1.4018
+8.94,-0.424064,-1.38193
+8.945,-0.430974,-1.36175
+8.95,-0.437782,-1.34126
+8.955,-0.444489,-1.32046
+8.96,-0.451091,-1.29937
+8.965,-0.457588,-1.27799
+8.97,-0.463978,-1.25632
+8.975,-0.470259,-1.23437
+8.98,-0.476431,-1.21214
+8.985,-0.482492,-1.18965
+8.99,-0.48844,-1.16689
+8.995,-0.494275,-1.14387
+9,-0.499994,-1.1206
+9.005,-0.505597,-1.09709
+9.01,-0.511082,-1.07333
+9.015,-0.516449,-1.04934
+9.02,-0.521696,-1.02512
+9.025,-0.526821,-1.00068
+9.03,-0.531825,-0.976015
+9.035,-0.536705,-0.951141
+9.04,-0.541461,-0.926062
+9.045,-0.546091,-0.900782
+9.05,-0.550595,-0.875308
+9.055,-0.554971,-0.849645
+9.06,-0.55922,-0.8238
+9.065,-0.563339,-0.797777
+9.07,-0.567327,-0.771584
+9.075,-0.571185,-0.745226
+9.08,-0.574911,-0.718708
+9.085,-0.578505,-0.692036
+9.09,-0.581965,-0.665217
+9.095,-0.585291,-0.638256
+9.1,-0.588483,-0.611159
+9.105,-0.591538,-0.583931
+9.11,-0.594458,-0.556579
+9.115,-0.597241,-0.529108
+9.12,-0.599886,-0.501524
+9.125,-0.602394,-0.473833
+9.13,-0.604763,-0.44604
+9.135,-0.606993,-0.418152
+9.14,-0.609084,-0.390174
+9.145,-0.611035,-0.362112
+9.15,-0.612846,-0.333971
+9.155,-0.614515,-0.305757
+9.16,-0.616044,-0.277477
+9.165,-0.617432,-0.249135
+9.17,-0.618677,-0.220738
+9.175,-0.619781,-0.192291
+9.18,-0.620742,-0.1638
+9.185,-0.621561,-0.135271
+9.19,-0.622238,-0.106709
+9.195,-0.622771,-0.0781197
+9.2,-0.623162,-0.0495094
+9.205,-0.62341,-0.0208836
+9.21,-0.623514,0.00775215
+9.215,-0.623475,0.036392
+9.22,-0.623293,0.0650304
+9.225,-0.622968,0.0936615
+9.23,-0.6225,0.12228
+9.235,-0.621888,0.150879
+9.24,-0.621134,0.179454
+9.245,-0.620237,0.207999
+9.25,-0.619197,0.236508
+9.255,-0.618014,0.264976
+9.26,-0.616689,0.293397
+9.265,-0.615222,0.321764
+9.27,-0.613613,0.350073
+9.275,-0.611863,0.378317
+9.28,-0.609972,0.406491
+9.285,-0.607939,0.434589
+9.29,-0.605766,0.462605
+9.295,-0.603453,0.490534
+9.3,-0.601,0.518369
+9.305,-0.598409,0.546105
+9.31,-0.595678,0.573737
+9.315,-0.592809,0.601257
+9.32,-0.589803,0.628661
+9.325,-0.58666,0.655943
+9.33,-0.58338,0.683096
+9.335,-0.579965,0.710115
+9.34,-0.576414,0.736994
+9.345,-0.572729,0.763727
+9.35,-0.56891,0.790309
+9.355,-0.564959,0.816733
+9.36,-0.560875,0.842993
+9.365,-0.55666,0.869084
+9.37,-0.552315,0.895
+9.375,-0.54784,0.920735
+9.38,-0.543236,0.946282
+9.385,-0.538505,0.971636
+9.39,-0.533647,0.996792
+9.395,-0.528663,1.02174
+9.4,-0.523554,1.04648
+9.405,-0.518321,1.07101
+9.41,-0.512966,1.09531
+9.415,-0.50749,1.11938
+9.42,-0.501893,1.14322
+9.425,-0.496177,1.16681
+9.43,-0.490343,1.19016
+9.435,-0.484392,1.21326
+9.44,-0.478326,1.2361
+9.445,-0.472145,1.25868
+9.45,-0.465852,1.28099
+9.455,-0.459447,1.30302
+9.46,-0.452932,1.32477
+9.465,-0.446308,1.34624
+9.47,-0.439577,1.36741
+9.475,-0.43274,1.38828
+9.48,-0.425798,1.40885
+9.485,-0.418754,1.42911
+9.49,-0.411608,1.44906
+9.495,-0.404363,1.46868
+9.5,-0.39702,1.48798
+9.505,-0.38958,1.50695
+9.51,-0.382045,1.52557
+9.515,-0.374417,1.54386
+9.52,-0.366698,1.5618
+9.525,-0.358889,1.57939
+9.53,-0.350992,1.59661
+9.535,-0.343009,1.61348
+9.54,-0.334942,1.62998
+9.545,-0.326792,1.6461
+9.55,-0.318561,1.66184
+9.555,-0.310252,1.67721
+9.56,-0.301866,1.69218
+9.565,-0.293405,1.70676
+9.57,-0.284871,1.72095
+9.575,-0.276266,1.73474
+9.58,-0.267593,1.74811
+9.585,-0.258852,1.76108
+9.59,-0.250047,1.77364
+9.595,-0.241179,1.78578
+9.6,-0.23225,1.79749
+9.605,-0.223262,1.80878
+9.61,-0.214218,1.81964
+9.615,-0.20512,1.83007
+9.62,-0.19597,1.84006
+9.625,-0.186769,1.84961
+9.63,-0.177521,1.85872
+9.635,-0.168228,1.86738
+9.64,-0.158891,1.87559
+9.645,-0.149513,1.88335
+9.65,-0.140096,1.89066
+9.655,-0.130643,1.89751
+9.66,-0.121155,1.9039
+9.665,-0.111636,1.90983
+9.67,-0.102087,1.91529
+9.675,-0.0925102,1.92029
+9.68,-0.0829087,1.92482
+9.685,-0.0732846,1.92888
+9.69,-0.0636402,1.93248
+9.695,-0.0539778,1.93559
+9.7,-0.0442999,1.93824
+9.705,-0.0346087,1.94041
+9.71,-0.0249066,1.94211
+9.715,-0.015196,1.94333
+9.72,-0.00547939,1.94408
+9.725,0.004241,1.94435
+9.73,0.0139627,1.94414
+9.735,0.0236834,1.94345
+9.74,0.0334007,1.94229
+9.745,0.0431121,1.94065
+9.75,0.0528154,1.93854
+9.755,0.0625081,1.93595
+9.76,0.0721879,1.93289
+9.765,0.0818523,1.92935
+9.77,0.091499,1.92534
+9.775,0.101126,1.92086
+9.78,0.11073,1.9159
+9.785,0.12031,1.91048
+9.79,0.129862,1.9046
+9.795,0.139385,1.89825
+9.8,0.148876,1.89143
+9.805,0.158333,1.88416
+9.81,0.167754,1.87642
+9.815,0.177136,1.86823
+9.82,0.186477,1.85959
+9.825,0.195775,1.85049
+9.83,0.205028,1.84095
+9.835,0.214233,1.83097
+9.84,0.223387,1.82054
+9.845,0.23249,1.80967
+9.85,0.241538,1.79837
+9.855,0.25053,1.78664
+9.86,0.259464,1.77448
+9.865,0.268336,1.76189
+9.87,0.277145,1.74889
+9.875,0.28589,1.73547
+9.88,0.294567,1.72164
+9.885,0.303175,1.7074
+9.89,0.311712,1.69275
+9.895,0.320176,1.67771
+9.9,0.328565,1.66227
+9.905,0.336876,1.64644
+9.91,0.345108,1.63023
+9.915,0.353259,1.61364
+9.92,0.361328,1.59667
+9.925,0.369311,1.57933
+9.93,0.377208,1.56162
+9.935,0.385016,1.54356
+9.94,0.392733,1.52513
+9.945,0.400359,1.50636
+9.95,0.407891,1.48724
+9.955,0.415327,1.46779
+9.96,0.422666,1.448
+9.965,0.429906,1.42788
+9.97,0.437045,1.40743
+9.975,0.444083,1.38667
+9.98,0.451016,1.3656
+9.985,0.457844,1.34422
+9.99,0.464565,1.32254
+9.995,0.471178,1.30056
+10,0.477681,1.2783
diff --git a/pendulum_phase_compare.png b/pendulum_phase_compare.png
new file mode 100644
index 0000000000000000000000000000000000000000..7d46bb0ba0069964e9146cc0e0d8779408258994
GIT binary patch
literal 94671
zcmeFYbySpJ^f!tM(xM<DDIg&&EmBH%=g{5VEfPvfcSz?9NOyNiH%NDPzh}O`cinZ@
zy?3qq|6O-2kZ~Ahp68r>_Ws1)L2@#pm}mrO2nYz6;$lJy2nbKr;NK|E!81+93G?8`
zXGdW*M@1WBM;ASNBLrzZM_Wr9M@ut(QfDK32QwRMRz~KJjO_HJrjCxb4xgErtp1Nz
zFxuFgFsa{~a)Wn4wG~r$KtRCKgMUBC=g%`kc!Gc+F7#E&HDzzX$yKR)s^$1lVt#?Q
zRnYcwMd`x}2ANcX%IbsWs*3U7IXMh3*gyPT(GIo{6CjoNS%2H-^*CMnlDyvc3;MvO
z+ll{tDxJrS;qXuj*ZXJ+ae<eJU%{6t$BEDF)Bhg6JYXYl!Tz6TjsO2grvD#ZgADb(
zrRH~uQe6-Cx5*7Q3JTaPiJ|NL@tn6#3zqRE_vOQUx7AF-FZ~~1zS2c)vogOvS?@7q
zxsR`{<zj$T=pM}18X6hh&&5-te799qe3-){MQICjJ8Zl}K|%RlRu<)lj8*1(tY2ll
zAfcr6Ixa5m@nRkIJL!C^&^Jny>e^TDMgHbU;vsAdB>F{1<D~mMa3ynC>7T6iKAud#
zUzghPGJ|wp?>Qy`VoPTT-uawLiMI6SQ0kx3(w32tNbzW@$fzg<i{>ZKp8thuac5>_
z;eWCv1)t;U=Em&vaQAsrOj_FLY->bKU440Hr|)!_UshRJIo0{$;b9<wIcw+w{N+d8
zmTw~IqJmb&0|~y(&CL&+MGn84t~UsuK7013qQY?NZ$@@@HmNxFVe=#3;^Ly3n%Ysz
zGpva8^rfv@ru6RF*`$sRp+HQ+z}Q&aw6wH_%S8{dD5XO_$vAql4<AriSy}6x_xply
zsLgpvUcG7!#b-sq!04EtCvtIdF&<13*4EaBI#W_o@?6e4T;1Lp7#jx`710R>Vl1C+
zk5$eRb32DFxBoCOG5L{`LwSFDx%oFk@OgSNDGF!$Rx7qYx0HauQv?|q83fO(<sS{#
z8_7}$AAPwTHX@><+uH)rx2H<pnGB`0E-q>}+kE}{r2Pk$3AlOqi=1{RkNfCKUJ?-W
z{e1NvAwNI=Uz*1O85dWgNt)YpSy@>XD5P_-(ZlB2p>Z~e-69_b+t|)ar{d>Nzdqe$
z)oVipThjre$89}U_2;i&Cd+LB4Oc56^jdY}|CrecFu`Z#iT)xPNas)ApQ}E-n6t@J
zDS`)xd8JmpGXwmlFQyGZOl=IO4<|4ih)GFxbaWto1HX(+Naz_zWVLf~*_^L+pjR*R
zci0@VJKK^sWWh)H#sBbWcM@s<BCx`2EU=-0=LHE*54fi7@d6wKkIMt2j-Rg_59SlA
zm%IsUHHXTK`ropdzI?np#agIyve@9JM-hk?0}&P%$Dl#=Wb|O6J|`uGh=!6<_+~v`
zhk}}#y0@)OKtftNHYzHLB0zx53#@JBMObKPOpJsPbRTR(Jc8MJU+j$)2&ky~`g%6!
zJ+=EPrsg|^r`b#1x6;kf;$kVZ7cb%v%$AzGZuY&sy+^@*?rM5GKHTSkHQV)Ray`yO
z6zh*;uqYig8q1T7zq`BJ+1p)NA;*35W~aLOW~T_7G$0^AoHkaX*$W(tsDgq5C3SW6
z&FQH$<cKuy8?$>3s0v*e0lNeXJA16Xy}fzrQg5$#-|+BM^+JVNG@_W#{dv5%hMSvP
z>gnCx=`c1a@h96a&4WWjGVVJCc?1pczYp;D7i$m1jIMxKL06Fx5ye34nVr?5ez!dh
zA`|#pGl)sT^A-;e&(qU0fz1qia&ppgy7UPX6Vt=hDpm!A0f$P8l#^5SasA*xMobLl
z_F})tiQdA(g2eku?|wKpH`j4@G7OxN`zokL^~&;cYmMFN*&ICsgWK7NsLeyPRmauw
z>YwuRvB&vF4;KXZpZ&MU6B85JIXU=FVE;FF9vPy06S!R%!IOK7jrA(^;6SbX`}g~?
z)@G>*q4FRVEY!nNY;5e>#>QxtDAqSfyU)eN1razsXJ=>bB{V!dDK#~pa-|Xlw6)V7
z9xIEBLp=^^e>_8e@q5BN%-tJA1CjnuxtG=sOP;5gAisSnP+Hm85CQuW+3%E|y0Wqo
zK@k)Y5#fH>$m8ggSY2K1ov_1#jEqc9PJYI(Q|B1;@87@A`;aQj86w%uy6c;p$(w8Y
z()HC<#lws5-=F$*$MmlwK7T$rJDDkr{w4l)V)~j1Swl6Q8k{GWC9ilL@9TiQy*<c&
zNO17kV;a8?9|(%>?(QE$sobpgYht<5$+^vO;3g1qWz!e`RpQ~|PM}>OeyyqepL}Y)
zP`7RJN?WpMf;_r+y2^?WEg*Af6>L|fH>?EnudYHh+0=8rcr&)7=fh6tP3NhqStH|f
zO&P1~mk#DXnKu(Z>OK8|^=>04UOQ9p#|t$LjjRcCd_GTCC`leF4%Odk8yybI=@xJ`
z*Joq0*K5(TSF6AH-!kj_H|^)8drSOyLA=9zSov5DmJ$MBgFm;LoZQPOidQdR{yuc8
zl?O*aNLZLmTmgzeOGT9{qXE_q4IO>gve|K4AvG=I=AzNvb$`dp1{bO#sjsgO^}r(}
zM3=Lm%3?-CLz^x)!8&ZZWwdELkMq7=U(B~~b9Fre7jXi<qf%3)^JG%5j@q&Cne`FB
ze*KCtJv+<ddi0NqkM8SBYotg&N)(q;W`nNZavxkT7hHDFra_X<<N3xc5>6!U?*191
zlQA1QCMJ{KC`zZ<=SWEKTvJ$7bUw#nv#6OTB;@t|`}Z2#<)>U+TsKxG!)cA{MksF>
zAlZ-A6yo%d3KSe1oP*lUG%Dgvd#tI-M=Y?LM$mM20%_>70D`KjDi1I3dCterE(cOz
zQPRCG@N;r<oQ9mvd2tYzm&n{p5tm=QdHuQr`JHD=QAv{osK!~Mzq-1*0z>ea%JkZw
zlX#uUYkMAdQW2j<ijwG!WC}|qbA&18$t;5tRj6FF10~=$86uj5YIGkhx5M`m6&1Bu
zyAiVVY%D>&-1zu<Go96P`lIo1nzXYs$CB42vDI8vPEAdX_>^bkz~JCalNUD#xIB<P
zE$6Dj7&NMmW-UsVS5`)|4Q6I%M@w}0L7M(0k<-@SACk)LGFhnlypBK(l*CX%&hXOG
zkHt{vOrr-UwM>d`>vyDYjGTMj?|ckFCa$oWi%VoRSy^8fhCm2FerTVZjB9?lDVjO(
zBSn#>{_o~5eI74;iglVvK)$X&Z0ZkTYU%-ypchoT+Q*06WKSMRNy&@7nRf7mdW|jF
zJI|vhUN>h2)uh{{dhKeZx=;T6`2(+^L|pd%gUOt$`}<Z$JRsv3gEajb7nj*)k>}y=
z6kgMEN}f5<eRz#lWwRt>Y)r+}c!muw`rm%_(#HMeQZsB7s#PDS*B*F0$hma1Q&a+C
zv8~E#&b$)ffwf-hbPAA5KxIkZO!rAkNO;?Hf1$B4n4D+BsoR1OPQ)b;&#0wVVfspz
z|DLTso~e6bAr-vxAuz2P)NC0lc9+~d0F;PzyF&4cHL78YWS;>378JsYBSra6iXy;@
z^W^{G5tkbH9rzlQI@1N%2s~tC1*q(QKaw{c7lT0K&dwYyEiDN&b)?~#-oK7QJTp5R
z5ft)!{WF)(uXOQgczKE6y-WAGWr3sn<tk9#^p!G}xqVSeLk$fKo^5FpRaI40ucgq&
z27@hTaom!Vl9ICS<$B!h;4P4z|5XQmNX|#kcHHOh8ZSk!tmuQPaCVsE@(jHD_DSh)
zD0H6zvlJxvKb4iZK8WT&Jrt5_-Z=$%D8$!LR|eh6PeJRbT@-@{7nont!f)uiEqV}w
z<bNC_Bk}+Ah^W{&cf?e#KxxpPK2{<?p&+}g3_DC@jJ~@;D<L5Poa2Z6{{L=sm;7n5
zF}XN)Vq)U!H*Yw0nHLro#KpyHi?E+Dl~-4T^}mOC9)OQ(+m}XE8(g!uUEkRW&dD(<
zM??aPHae;RBKI(<&GI)oeSd#{@6gcmmiG2lohI`CcoD%XUG`^TB3W3ll$4aD{TlEm
zJ3Hp!z#JALptrQOJ^i+~XQ`>B)oGgnzZ;F({l!ZDo2~Z%^#zB8VZvarP!irG5GQ`O
z_Yb#+73LFY4h{|if`T&uij-@Ot*6jQO7<Ib=i07&bEwJyU<dLiZMD|7^UEcl({V*v
zcqVe*pAC@6(Fb5OCN`G6W*8vCL>@Pma+6_zo>}1^Fp?#T0}4X%6qS8IQhZJNfA_mn
zMMys1<mCZPk7v>e2e1+($xNMQ@AHGx2~{0t&nsJP_iajqMW076@Clun!XZ}&^@r9s
z?CAgPj7#mldnrs=NeS^=R+fRE6$tLOf31ENR)iduZ$-n2Y73^EIj5U__*oK*)lFp4
z{`<^>s@>MQB$c9dkPWk34i_sdreLkkU~_6}YbRzmKuI+=Huk$!QdX8%R?c~>t*LqY
zcm0`GGETNaK?DUVR3${Es4*>1fk`~-Y$^G)Mm3qsfr?HQR$T4{ZXcwk!G90&B}KLA
zx9bKHQT`G+qtvxJO_$_MlA`~&_^dzHUYdL|sVK`U3>XM97K!DBfe%0(4YvpNPF08V
zwdFD_^$G<Y;D~}S0O>yY9wH$jk#wIBU!X(_@;M1$0?ClM!GVFZuSN!a{ryiC*tHL(
zx<Ld;NlWi8Xv@pD`aVOJE1IYznX9yza!TEmp*#@PT1gwHJP@~9@g8?7Kj>Y*46g6B
zBGesB<&Fob$>CqilZM7dLaSYXm{e3$pjH6X)zsH>)(nHx-`C)Fdd3g%*6QjiJlTPR
z1f8e?bSft1H3(E@PR{0V6GeXUs1GzWtzBIkxs;yC2?@GJM#5rZVyWE#u%e)$t&A5a
zI&S@a@(sXP5Vr8*`RqByU*u#C4vw2!`=ftfwSDfLWYTzo%F9_nq1o_xynP2Q1pxpQ
z7K=%GfOe)U%y6*yu1Em@Dsp(}>yx0Tr{9_?Nq=Z6RHB7PO9Yvq^-l0%HM$-D4)$d>
zqn)fd&Se%X*-JL`y2U%McK<28c$DkScHT^>-m}}wLuyjemVbP_9v6ngX}s`EePdPc
zyq^hbDdqv3^&}>$r|wfxQ8{UQ5`;ZZlnT^joVr{QixLXh>58i!F|SlovXCoe6S;h$
zp70^*b!ac(qLn(kCsjr1Q<ZbDdoD6E-^ll(C#}fuN&%t(a2O64hj~t=prq!YA~l>(
zYBZb<aaV?W>|YzPs5f3VG+DW@{$H-%N%o-Y)^iR?O_ulkH3(g!v0Ult>FKT0e1Of)
zI%)ExlLO=9@!olzy+Qy4nI2F96Y%Dt1nj|Z02fUyTV~iBmF%2~ON(i>IBPc+z7(-_
z8K`GATk$vvHs8R?O3Px-qNK4ahDI^T^WhiY&Cees?qcr-0{#7u&Zl(7ntgoUFliSb
z1`z<x!qjji5dDh@o++#S<``Qb4X(@xU@P-0y=Kac0Fit4ZEbB0!b{%hey+biTiI~j
zMc8mLYvJ$jUuw77C4#ehNChzN_|jBA5ixN|k>usxOu3MdP^s}C!F^S~_zfPDb~Ye_
z2#(vM>s^eHmoPGMYyzl1Bun_cuS6Eob!-qGS|UcR=C}#~Dw8$)PmB9mcL~aU9v?o>
zb^Urb46wUR8}7t#o6y%Yk9O;=w;(@8tzcVPS|zawO)G(zLPSQMn$d<p(8ilK1C77O
z#KoOV8~i#RU>zQJ8<?7^p5#JWW&z<`pb)L4DJ&z7%ax=2I!;wlGb1x!K-exIX+<LT
zph!SEM?x?bA{h%2%#pZklz^`HNh<d?WYzDcbSsf{OVM;I72H}IXSRSxU7A5*wWw7a
z5|#{7rR<!olLA4h0jP`|#x-imtCj}A(XsfseREB9VPH{PtnhRf7!6s}qkrtcawg2>
zlW9xYlpp9UUe(pqAVfq)e(eq?eu9F9W#gDGllu7;F|n3S3)OrhtulcEI;|MP2kOe-
z-(!*v@dI!T<F~#S(w+~}2-{bhhsBwPy(z?~w)*LpgE};6Tr-!ry005l?I%1KPs#V<
z%_oiIpfr}RF9CMnGWXWfz>xxcV{cFD7YXkbz}2WID5Tun$()O>StACGCw+84#_$6~
zhy`H0;^N|;;o+02LwE<8Q52Etn&O_$G^jH<9h)&x5n3VwGBh)kUBYY}8xoq91GZHh
z?Y(`kH5_pE=u6J%XVepP4PYJfLcWO#Q@4iNW9UZ4<X{0sp(;9wm^tH=lM-V2mDm&J
z(5B7ZlV&<)0tvc_o5ep-61bhQ=D~DIuVYlBH6YSpn`(2E!7Gv0Y0>(WJB;EdZ;1wC
z?4PDUQSARv^>hZ4s#<*4EJn4hYU`7_>&5l254f_zn+710goLEBs?u^M3LTFTeo*0v
z6sS68Gi8*go5Lm`$zzffdEH*z0Wj9^aI<^1KZhp{Pip!r9YLJ8W+>HiITGyw1K2}3
zcy^4930r6SD`gTNimY8Xien3&z7v)7vKd}adxuBpplR`)7JV!i%T7l!CrYmXkvn7~
z6*Ff-;<ZYC4^07ieRfo6W*?-{-V6!X@U^mB&ZIqAxj%ZM)9#epjK<%tu{aKrs*2-^
z9B3Yc_Qf0h1?jIf&w>zk8LK_7?c<nq7XPgRfVlzic4d`TYBW2Ll0LiH0rkQN+z%!R
zD-F$d9ZdPkC7%s4Wb)eKM&ZdaO+bny6BSwBYb)OE2((%Zern0@TE(dLm6JY~4iz1X
zqia<!DAw%p!&P!WK@vwt7jhRlXv5;p+R(5a9C=+(RnJ$}W0j*-)V@OWkm@r_#@EZ)
zRY$><ezfuUeDnEl?-YsZ+(uCzHA-8vAR+*b<58-R&H_oK6dA^~vz({oqi6+66NA6(
z%UGb>0e`Z>@))2CR!0tHbw$xF(y#6BQi{QU^mXZ`Air>9lyRb!1svU(NATGjy=N$2
zs}^!4B@B;rczS6td7yv3nH}q$@|E#^QE^%!Tu|e2SVTG>4kx27wVC#~qD&ih6kjiK
zqm^Au`zJNk$Ld$U<X1E1+gCEzLp`#s*^%iK-4Q>Jy#FiS423```RZfx&&b;p9iLcP
zssuIVSvUwiN0>C0sJr3*%i0r^<~szoLYNGD8)=yz0J-nB@dXMNpX~m8Yc?q7ic09N
zJ=2Fly|Gu!rA_#MB$2%Kc$y0B9H>cdQKFezH*}k2$q2zh$Wb;YS3u)RE#4L8NsN)T
z%SrNL=GqJCed74UrW%3zCh!w$X%1bJOk7y1$V-180E`ir86&jSS|1XKE;<bzKJdk#
zSVWEZX%?R~zUO^PY*z-Wmx{5qP)nxS#@&-D(KSI}g9M%8cM?gDpMNB2&PT6tP9N64
zyry5=Ao3kjIkVYr`xXat#Io(U`@FM^`u%Uie+xz`9`#d#&iJ+#<054k#+o(Q*%kVP
zL30adMQZp<-W*E-1UjOi0?m+s78Lx0(RIqHD@#N0K`eF64<H6e1qv_<(!^)U^~m)Z
zCD7rjCD2-jcrpiQif}V=&$`Vp=h={gjO4K0NhHy;ewaWcqeV-~Tpijm&k{#0(Kat6
zldfwLSmk6QX2D5REcLh#7>WxeT=gXuD2n|QtJ!jqFI6RK6s4k;;UmT97vA&&qj-DW
zbXD&*9seYnBB;$CcUu_O5KlEyM+JIITSC>WblLd3IBArY-DtwRuZS&1r2z9am9jvG
zyx%5=d{5~|d0nI2jy5G<kf>k8QGJ3W>D!nEXT_qvfCqlkim^%fk5n$kN#jTJwps-;
z>VfXGkMBIvh+azB<pc}b)$aZ3)$_6BQ14XU<4YerIGy>h#!`p;i6y%d{e<uXj21;;
z3{EDj4Ioe<0p^B#Rkr$}%?JnOud?VkNY6BCKURcs-)q#|S@7aVWz!8M#;A%YSmTSk
zt!KZ9iI!IrH@2h17sfpwQm{nB34r~OpqV;XF&m#yOGwUYY~agKxxC-;d6v(HO&bQv
zQ{~8JRKFwdw*%)luG2{%&HJX8<37m5U2&@~>zQ~<KKlsLuZX|<NAmG!;!&T{<=bFe
z^i}EoYn~#^KX6Vyr9>cqn2B%*y=`x(;T(9TnmkuBrSQ_48ZM&D$!V&f61I;`yHbT!
z2vA0#ZP8|6neBI#Iv<>&+nL3+rFKP81dV@3(`S+V*-J~tQRE*|Tlc#!0ikPV_O&XZ
zLrSsq`FSo8gS1@*M`x>o>cqmRly7VSc2Uw{oN-<7fvRGGlI22OY~=e}PBl}doDl_W
zXhs7BdaIpt>jKWl_au_?@AkMz@gAdng}wBJ6h$@Il`7;#HNnLzv_q2)mN}Y%zp^Nw
z45?JumS^PDvop+Ff)dcQT`SL$D3#9kxcBcR<9h6$RZXfna@J4L3PP@fQ^*>b+r)bV
z&xjk|PEKMHo^H_f05%v7KW!Y5iVB@wtY(&<qD34<{&?3X3g{bpFp+Hi6D}d$)QD2e
z9yJZ>rC+u*CzChp)a;?BVl0XoEew1{gT?J|ms)(}Qq|Etf-TF9KEFS3Tv6UKF}W8<
zWt{wBZCbtOPq`^XH)BF#ElxR7T}j+H5|-p)@68o|(pM9sI+Sx~UpN6_+=#OSXQL6X
z?EJRR=-;8Gup}oTI7B0hbKw`-7t`vC4gb1^dxJ%9k(kT#nD}kxgZmnZeS{6M(-eC6
z?P~9E;`?_A*D$R2yQYV<!6v;ruR_d7{0Zs?r$HBnO0n9Lt;u(17Z=8NSI2O>AR&1-
z@Fmc-0jtslW&RuNhwf~J8PO-(Z$SLlwXzz#J!~EZI(+ZIK*!iv^pAJm2~#>g#EOcM
zx*qRAws~g9b!X3$$h%oCKZRjMv(ECo!f|;~&P7Q)58q3t-dO9+hB?3qF{&`S&q<J;
znQ`(=*5CpdHFBR2+54W(q__i)8|`ES6S}(;`oo`zR`#_RAZ|3R2Fwn%F72Qy)g%Vs
zY@pT}bxfXZbQ;FVDP@o|=Y@8puv7_aso#zb_eRMvakn+>Z?Boi=EvVlqeksZ=^0|_
z7++$pC}`s+w~fubO%u_V!Pg*XoyJb|O@`vHa^HT;2>JEl9%v$Bh-y#awgdpQ`AW0^
zWOV|iJhIo&^Q4#BX*MoCo)w7efRTK1JtBSb<cZ}{6ERe!AFyLtTicKF^71?<J?{Z6
zKAtg2zegY5x`>C!4cSmDUf&y{;S0y!>=S$L;ZMyZ%V&^$QcK(kY*$FSoF{+^Ng1P3
zN1bqaGpDbLUsu}KGr}wB;#``X4L8JNdbDpL5G;w*!3xRCTFt<`Mx?ZhH#aQkztI&O
zBnrVvTLy>sRe`WjF7CE_qj?h}9xl7$PSkY$HTP)elJAiBi$OmB%}v8j)=U4Rv){S^
ztekdlvvCCGMJj7{W_lgd&*I6JkWy1QpX;e<Tym3tdgHGF%Gy)FjsX{Z_7AW>z_n*8
zEmTtxib_i(<g-NNA&|aSKjiaUjCXt~KmypELwf!k8waO-r87kM+XNy6+QENZTl^`d
zqbb4C>sZ!95{G1Ot1}zcgbDL?c~2p}qHmq(-Lo~_$s+;lO=MB-K|P;5FY~{i2C+@z
zLoF%ayCBArh@q+hc7Jf2a3ym|TTNTq5b_G#Xo@t=+IY^>lfFVH-+keQQ7(J@it~yr
z*`KUleyQ7ghjP@1dm^x1d(@w*A{B-%jvUQtQp@QzL|*m{00HCF-<;TD=`;`vmBf+0
zl|)n%U;sNu#OL{zpT8M02VAo4rDlF0R>M)>^xPb$drD>|IiM^yE3u1Q612+2{IPv~
z@8iV=7{+W4iT64>U`-fStCM@YD8lQsFS<7EKl1%}_NTT|;xmF;BJI}N=9fzZQ2-sV
zHw>8EnXR9CNGje0)@=DPibsL>SncTal%c@2C8tSWyR#=BbL7<yxun*$CZAHa!*b5m
zLC1sCsB=pGw#ZfbSlEc1HR}-pf~roj;Le*RwxSKK>6Y7<5*hpL{A?J0<J~s?8pU^u
zuOGi4s&R%;_!i!Eg=b9cgv&z_Y9rejsp9^2@Ovh6+H}p%5>!H@m6dVrYg2?n-b|RE
z?v)Q?zkS;S)2c76u)I^W^z`HbsQ7iG>T`<qxIcHc*t;@0JJIdX!I;q9y}^n!Z^Sw^
z&fRNxKBfB{qBWwP(xCL4Ng1Jzq>%C9#TlkuhD#}q6;H=X+aqAm@$GNc^ar!8n-C1&
zDBFMFtEM6yqRh(<e)flp=;z>aJ9P8du0q$=g7bN`bC$+8gK~@!cW$+l`G0SCct7}q
ze4^&IhK;=HFoU1kIkZJDpb1S}>`%8#Z4~~;fP(q*$>d-r?T<&d#lK{0-@FuE+!=_a
zph*?|Exymx0ZlbBG6H%v-iKI;u5e<FqQS<?#s01^!fPOcxjkHO67r}3H5h*GK^lY~
zVd=)3dI2GGvZedfma2TI`;WR2A-H26*Q~kGoRh|brxrBg*Z@D@{HA5Bub5mVgH4`U
zEDJ2XG^s=Sq;Gb!bnWnaL;_A6<+P=}6NB%{%!6qQX^KYWRC02Qb2|joV*}A*Av&E}
z&{(-5cEj}#YKhK70V@(##dJ&S05O%aP2j$*WNTD7X<cl4jZBB*6@=m;Ip)(iTVJ2b
zWx(yhT2;;o?2KsTw$`NO`S(F?*=wq$dve(QFDUg4VA($Cc!3pmt7((goOcj~9wQ8^
z-J!o#2OTEyr7K62lj$;)jP)^`93sb^Ftyyv6BBbRetBl?m$2id>k!&I3&847Uc7j&
zyFHrY9}sXnCd<$4abf9|T%ed||9F4N3RD>ias9;xH>dFEw6r0x$lDV|c)(?@HJb9_
z2Hw;&yIRj`eqV51H~Y^Zbsy_x5xl;qCL8svpI~z(zaO0;ij=q5lGT~04}(>=cONhH
z=E+-BWaFwtr0B?q$Qwzwj-cH)mrKyn6v|Dgf2%Vylv9|dpRzE>?dY7u0L69QiotQo
zqOk7v6J%xAb=O#|&yWRDI|njl9GBNKni7>$SxrWdA(KCwo*ZsQ6PDpUx&Xo(OK|x?
zYFWT3^713HzM5}^aWwGP5i?=h^wvce(DOP*0`S7OgxkMzk1Dmd)4s>|<Z*Ua;^l*d
z&^M>@1hpOaXzOn(ML9Luh#G{1Yts1S4Nt)NnbP(Mb35H&HtKr~gsHP%(&>D}z&ZeG
zC{T*vF7!?J=;-KM&=3HGY-3Pbx^xbSWr|{_31VBTZ?VrRi(>5YFMqh5m_B|1H^I^G
zre7{G?ar9Y@Cu(|T?;>{icR@rX)K-KTn+Q@fL&>5ts}d5R1Xc5oTEIZW)B-2!DuB#
zI$FwRO&#mDm)z)DHc=qYUBu<8C2t3ZLXv3zuqf-A0gNl;D=sY?t3dWlT(V=vw$5?K
zUkdi+y|`%wWSl??$t6}Lvka1@;hYDVdanYYSGIz*d;l!pRIfJp`-yo4c8pR1O|N`(
zg5u;qC->>Z)lEZn#i+L6e@P0sfRl1MiIYnzQnt_5u@*zQ381iUd%!iSgm<)&=Q3Gl
z-oysg2BoM}*{^x4V_0q435uUoZBPyD;Ix2TVj0%AcH4~eDPDWvq+PuDvwM)ooX1BO
z-H&9}gZyNI{{hfCb;B|$tci(?iSI!oE-4ysOGDrBr^Rc#2iY`T=c>F!s!O8>%MLHt
z6hZK(D=OHYW4!&Ap8gJQa>3oQi+B@)MJq;R6`jMN_Z*U(Y$j%fx(cdrbkNej*w*q2
zqo1j0<CkJD{V%x)_qCti^|e8;&6UNAGz`ma_pzc{)uKu`%%g=SOc!G_8ot3vR+jKq
zck;VUpjp5A3|Y~$@!eGB6(DhbQ!}$uSUabYps7ldAdw>w=^m(OwP2mkk)T2+uUSA|
zQk+!0LKh&+<Ri;eOiJ0D5=C1HyM*RPWd&VVhU=LXl6DLRs#tSW*j8r%%D>;Rmt^(!
z${ejWbjZ7|>;)5+g}9>#vxd2QdDLk?>TvYw8I#GM@}C<`AF;ZePjdZ!-8)^T(Bj%3
zV4bctU62q353k-nLxtnP+#|;ap5&o?Ijpo=YX3Lnf3Xh~0J`6iqm3N^qA+M(IPJiZ
z9e2CS_(3AT7|-goqXe9FYisL{?rxlS?|xOg?C*q(hJ~HZJ6Ax0tmG3tE2&l9sm&zN
zB~EaEOKiOVQ{C`~2RBxvAMn)4R0+Mq081qT)Cj%I2<G28beC0^@HAg+-A4Fn%RXzR
zT#_ppA_j6TsOy?NA2J|{)m!;e&mUw|{A(aM|MYW;R<sp+7Y4iT_{*mq1%V!M!S1H^
z6;tXH$TJ|ZMxFGD4>7%`sZI$2sL&`L$W9V&m4W3z-H@gkKYSnkH6nz4zi|)cd@{Dd
zbk}UIxIGj!7geP>1IVzNqsM^S95dX;kL3Ux{|;D$$~$S}^ASTJ7rh<pO=eDQI4Z4g
z`mIA1Jwn})$VWCLl!N=n)P`qn*r<$4K()cqFdun1_={u>dT)09KJn3KTs%C`A0sL+
z|Ej90@`n>G9bK*KF*$&WH#?hyUyCLbG&MtkF{Q<|rn2PKST;1@ldMvE=Pnl25$>Sw
z*+iGCqRS4lC94NAo11u?Mb4X;)6-)^Z{A1=>+RUgbSqvfQzJ-EfAm4?;KOqdsa<*K
zBzB@o&!3R%l$wO$UP&Y;b3<R4ifVp5F?8O_blX}IFb08n>xWs7^XrlZk#PbBaW|t5
z!#HeEI|4%WGe?8PnhS0BjB?Sq^!S_|&!=KLxAqRdS+TysYxI;2#C+Epv_?LeE@5<A
zD|JskXOE9zzTPFs>$#1$@_psG-x83#nig@oFC6NE&sp$8G0y)5kTE2AIq#icfscET
zw7%dq+v7cxp@dtj&xs`mR#*4&K1FMyu<7XLj7WguuXjEo31p8A``M`SN*XNZGkr@F
zo9`*~({)aC;e%{`l3B4o#U`MNE<o@&iV-M;sbhDKDt!fVLYuj}4#4^VIlOd=gk>o8
zpgLEQO-}^MyKYr)#wfjtRq2=+7a&)3T5^yqve?naML_K_{0nNt;#Zk7RJ&Y{Z;Is@
z=d^1qUJFp5DgsWZ?m`<2AUGiMod>7tuH0%LYm=F9>aPCj8#rrinys4kyC`xy@Co9X
zT7~o(N(w!n%VJ5Kp7^nOfZ94yb<G!w*5(rlr;eWiIr->wi*zwgzh$A9sq37MK(dYJ
zD(I^$UmKh*OHqEaMX7)e8+f{hyVlXpd-ry<OIl}FEJtBsIvPRYq@U|$e0yus@4~Aj
z5?WC@MY!-Zu@q_jBs^1O64U+<vw<$1>hmglBv|peYo@V!X0-S<#d@p*UseJTeC}M2
z$iaT5-V?z^o935zv+lEtM=y(jz=2bD^D(0c>v$%om^W^qPLU@2jndI}_}iv=;{GFN
zl7XFlS<$84<bdhf_P9>0-KWrD=Z?}%0S=2_lz=lR8DFCQ`}6R1a8{8T<&hFD3Q+ZZ
zDAa8oQUjnuILfi{X>|Sd(ZFxQTP1Irl2D@`QCIthXzLRMUpPaoHBD@C9WSjuV&xZr
z%yBd>;4Hf9PS1#CrfqBi%T|qG%*z%1jq{aJCDUbxDyr8I@sq}@f0mv8Fg^qz=h*M*
z^C7P~b_$Q7(R~6MTVw|h-@+@uqA>i+3TFc`LREJpuB9V6%hDotn}w;s_#f4VpyXSG
zYpqDxlli1dZ<dsAJ6<@zcOtOLt{(QUuJQ*1|KL{Namcl2!#+=5H2Sr%&QptUN>)&J
z#@ufnch9>JGiu@5O{h}AXzAJ)asbTbGDeZUWC`%P>TR8G#)5MT1kJmvVPR(>9U7il
zz|_>ep4RXWl&ha46pj<T=vprW=y+kX++y91W{u_Z_3RjDM*v796_;hVvS)I!sztp(
z{;jS6+6`_eF0BOZM2u1)4NOTMKt+k197tA<1T+Hz1^)^|N1~GHHm8cCd)8PCdm?%r
z*O>>TU$g7j55%AiNUcpLCF@$iIwso?xzTapc0={Y)|oC0Le}+WY|XmaBnO=Y>dOGP
zovC1+x9R=9)0*KFYf)MXox|PH*VnErZ>Z32{6Dc~hY<ptvG7+2%>f5#^|J>ntejKc
zOqiZKrX$^C?2}W$H^q3gqq1sUV;dhp7;9lj`SnPj${vEW_kxF3#)z3g4nAp(J1ypl
z8z9Vru;#}Wp=<<j2ZBS<iXc8Zh;e7z@8-2U#OVE^!On*8^VPJ@CG%zXTB)fHPaY%g
zRyCICc3TRc@7ar{<H|)P0)`(e4gfB;hC3uyMvYkw#GKg_6kU1I?HXvQfI15O{k`Hl
zngV*CI9)L*v=pAg?InwVqCR@LqV<l;uJbxD86S|T?ujlURYF#{3sKJAJ=Y4?<~@n%
zLF%Z1eaWH$l7}zjBw#eG&^&%+b4*d3(-{Z8kcAQTY&_+iqVr~|_z}*IMEQMQ{L!xc
zz`(*ex0ye>0&hz~O?!9V$E!J=VVecudX}#9=<Ej>h%osWU%W82e@K_gEqdW2YrzTX
z;PM#pAI$*<gNxv3K#n$`9&<klAZ^57fqeY;C&;3U_q#;hj5~|Pyn6#~PKFi-7Ke6P
zPa;(4;Br;SMW+L!ma6Nx5{-!^HIwoAi<)K5H&B(8txleY&&fkT6GiJQSu?GjO<-<F
z<rbW+8R2c&&c*6At-$WRUZ*gOk4n&x5OBsv<;tPhh+~Jm-!<Q$vQL2yI`T?xP)#S$
z{bBykoT^O3X3c?7_bCAriw0O($l{W&uAlVuh~+*wHu_)#kx?jC0@z+ttI7qV3K^qv
zkb>NNft*KL5V2~o%nAwMjY$F-tM?kSgwEVV?|XAJ<yY7wVm$<BFZ1?b*VIkX{pnx~
z+D)}>24E?Rjm-=r_?;kh^gWcQ@K_|L@uJ(C5{RU5?Qbe=0h*D09{5S?@){^WiJTRb
zvM(@<+Y{Nm@2DgFQ&`>{gl*>e;U$g^#*5w{txR?-+XZNL0X7b=LdjmJ^t`T-J}dV4
z4-@=S`^()9euCCD#X+QZ$#9wb`~y^>T-OAH?ge#5tYZN4yTf-KtM`5|3yye5)_TcL
z$EKP1FP;~%ZCQ#QSIqS`2rv##j;tL8Z!RAZ!#@v7=FoM!6sR=*$dDg^svtQZ=T4;2
z7AZIY+h!}NV-M^okU`G`3(oCI*;@NspW1jxHW1Mtl}#}S0^=_*q!NFK!x-oTNkl!`
zjBKA-237-elXXZk2N*}r^NsLSqvSQk&ApLmkbn-XG+rE;zhY_r%0w~5eBY)p0%y-$
zT0>T2As&=@Ud!alo~?;<SQ_E{_p3dHDj~yCN|w~=Vg(@g8(&^q77x7kpY644RQmFZ
zG=BHSR@XXH*Pc^{%K2E&q~btOKq-k4)n`3YGW2j|5a-$VBWKfDb8L<cs=KA1DpCg<
z?LRbz%2_{$tpA9<I<@><^2>5CK}K7DTCRoxo*QAH-vv}bx62Y!mJp}&V37d#qn#cV
zY46o<bOEAxd%+`2mHGxSL*v1tzA*X-4V4_@F|dWf3K6zzzrE|j5~IMW0vR(J6t}^}
zkjx1Q5TN#-Ya>{D15(5pNr8%dqteXG8HuxHDg8SH_ba0+kUTUNV$3%Ndq<Um(xb8Y
z^8$B6VpR&n89r<RX%7@P;6GxgYe@kAF_sn{U_vIZPj6|oJQ6XUrW9{&?S7%=_xOCv
z^>W4Bq1`Eu5#70RW2Tjihx?O1!1WyI(k6ng1T@#UM1ye-XWckgT<R>jS)8kNt~yh}
zPwi_%m-l&qSe)8y;BaNE!$Tc~rshDOxFnMcM+*+f&pF-Nexyg^O6EE(%Xu;$J~)Mg
z&CtHOr*BS`T5d<4d$mU!h#4@~?{mwPLOL%%bG_bhzsYqm8KVUZueE#R*^!a}$>?8B
zT-`e$q292g>@!HaX4{Y|dfY7h9Y0GLz@8+k?|7Ft24eUb%Nh%)@@+Lki*OOD7>RF!
zfMIhq1h`|}BON@zUCCGMd*Ub<VZ~!*wyIb3c(7?WVcFX56Iq$4(0p|=0ZK7Yk$?=#
z6|d3(j4PlHMgt#L-x@!t)~J|2wUA##RL7(4ifa@&UoZGB23b7k+6DvN1U2C53{m*7
z@v=^L5G~8Hf;N}VUif+u?;ijW`ve#6x27_;JB5u{7IvNh5x}0F`B%wBhutT#U$LT$
z$GbtVf%33<{P0zJXk-Tn@Np(LCu6N4p0(U@26(6V#}oWKvrG}S&jhV+MrFVM)dYuj
z{v1fm=`W~Gu3>7l$`Gm7EF|F6Dn9cop_AiMVU2w-ls>7eOoSb6?KM4_B34r_V7L6$
zX9(~md*=tIyHtAAO4{Z1pl8Q+=4rB5Q51IItbzpbDJj3`pSFTB_iq-?$T1+hhBsX}
zp4t7*D)EYTustxeua$~NIW+Aptx}y_9bkZxvp|2c#-jl*>WiyA8L;slg8J9fYc!jt
zp+$L<Kygh2@Dk0QYP|m-@Vip2rU;P#PQF)Syq!<yWp=xBW(fc!?}n^{kb!ZQ_is?8
zuMCk)&w4pAGcZOCdwqo_i5feA^uROApD)fEM}@W!aR=Di;`J$!2czNXU=t!oK;G#{
zg4|6Y+r8i~(s^_8mb(7I1ZF>6Iu(REc9h1(Mtpv69?;yL=IurRrYgWlz*}B-w%`4B
zi5yl0$S;U=K_dZZhLZ7VC@iF{b2%KEDK`Oq`WVEY9cw0J3&eqm?P{mx?+vXX@eTL<
z_&G**DmPwBY=CAx3mE6PsYqKVRj^CNJ0oDc7xTFXO^7l@Y7|OhsKTYD)h>W%w{|T0
zL8GE=bL+p{8ime`8qJIDwIdhHaBtT$77Yi=g{LW7_-jI(KB5q}>8+4dv@VA#4g+0D
z0BXl^@h40vLGpx~eSbQ508EKgRe@sFkUmG2!~umv4`AP$fSUQgrDZt<WybqoZ2*ge
zLl~e?PSP^E1DsQSi}-hP4A$Fyh`Tm$L!C1HF1p=>+W@XFOnI!Td+;P~{;1H^$4jTe
zR0kT;$?6&7Ug*%u0{?I%M6Pu_J)HGV2v$j$xmUZS9BSJj#Z!7;Aaa*m&af!a;)2dK
z{hPCGFf70aT8}?lflfVqZfANsJ3AsC*NAW5zCnI9-<|Zky1UzhE>R7q>nQ-;PVRk$
znr4YbD@8)WYNI$sEA>3_4ymZe-^3`NPNaQOdDrL<q05NqPZ*#0VRC?4d!U_KQ;hBX
z*)@`XC|h2uTq&#`$_2nROF{ClhZ;_WUS5E9Qa4#<>=>h?#gXz$Br@UA%lbEHv9(S=
z3si;2XhE+i3VG;A=BQXcdtH(mZtTRGih%i7B;#E3H5Pn(t{x*6saSh@>DP}zpLKqt
z$IZF!1S;iS90^8I00oLGC8B>BaUsI;Yi)4Y^0p<0tmyyPt>AQ*Rvk>8fBjdct7@^>
zP>soiY0(?^6GLU{HQxQIBY{tfOqR)S9EY3dA4_vAqNzl|QUS7J^hFX6IJYc5q8NA%
z{jOeuulunmk7s)(F-*-oGaIF-4AeASZV<Uo0UwEbC$lmYO>;+_-2T{AVIW6Wz1xWN
z-BuA)oR)zB3>TM$kAc5_VS%|G<0+Vy)6-(mT_zGnAZ%tv1A6Pm4;^Me^i9_~Q14Ea
zn9NmKRqx#-?+6$(Gu@MXHB7ReocgT-yE|-^o8M1*gP~khS<DmFG3Bvx#w89E!jst^
zm8sYWI&o}K?9;1<L!pQ8!4Vs*(<%d*r7t2C4$aFgq@YEBnEk7A2YdM<F!#5XMgx2q
zw6@>;bM417pERYkmnakih!iN?K%+R3DC(grq5_)F_cC*d!tog80vc%XwKg>OVSOjI
z!Dl1=`LI!Dgq~hz3$USc3a|ly-(!%rEoJK*61ZIGoqf%z0VK~syK?sS-r2oe<V2ug
z0IRIRv0Bgg5CL#{Kwf4%$dd1wXMj94f_H!CD2f48=}^<nA;9V?E=p?;W_<s*ZVZI$
zJI5n(jrXi)v8&Hgp$Q9|-+++LtVr;f6wzxKigK=NOUMaNLaH7sKl>StHcoKPUO2Cu
zM_QS#n%!kKs~Afx);2S|7vyy{@<Ie#nNWF0Ver}gc+$&CNE~^YU-bXgQ<-w-p`!~C
zC2{i)BjnUKn>m|tuKq4Ucihe&L_dx1C-Gj-M6Ye`vU0gKTsr-^_eaL~>W9$LVGPT4
z>-OC&h>ohYn3pgJrMHt^sX*}E+S{}h92*DB@QRfuReISBz6v(+y}ygn-wV#wF=vNq
zWR<TcNy-NVXV0@RPExp2Z^lMytEnp*R+OnQ&7K1?b<J(c-h+!)5yiNyNhe-u%vA`t
z)a$4|!px6cRTX=TYGxCbS51RTvM9a7<E}n$KM-%}dnpDM#h`I5Jax4A@&MpcHl9i;
z6IF8RW*KnOB{iLC>^xSl-EDZhW#Z=N7X6U9-L)=5>p>NzPnnNY6|K<kT&9>Lk)`^R
zd%3;KYsWLn89}q)^@q(0!Z#7R_=IP=H`(U0vm7Y<KUPj_Tryyb6Ac**$&QD>Xec{R
zYyygr$Ws5UtS4i7xW(|dqzu)sS4_YSkp`d)cL%K<lQ3h#yg*L%w-QZcf7otqsT_pu
zdeHTBV-P-5p;A;(SO_$}a?_Dah*g@`g*uot`yZQ6B8mb`p|ygk3K`HtE+!#iK6-5v
z0D!{AJpqjA?dO_G!bgu%t?0a{JUo@7<+xMJpaBF&r(A8K*{EYJ&!qW!U~PkxYPh^O
zD=bP4pr*{yH$pU5w7$X_?8Mge<!vI_I)#yWA+jvh2-fzwTGpD%IVVas!mI{}G_XSf
z6{v}jAGjXC#&(c6cQeG42OBV#w5o3qSYC-Qqf(bfL2bcG1eGe~U~Qe1QZ*c()eMSF
zd<t4BsL;5;7iegTmFNUB2>4v~YS7PW@jr0riYjA@#zE`mhmvbr`jXsIft*`ySmtj{
zVQVv7_0Cw}Ohsux0z~K{<(0%m<SDzECZX7e#ug$!i!jNoC*eH>0m<xey!|@#?TVRA
zE5JCe`StIFacM!PjJ}2v6|%kq+`Q+!#Rj<W>3)MH{z7ZWZ97kig_o492f8-#Oj6z<
z>T)#>&E1hKIdFvGjB)8eR#(NwC->saMnTsQ#C_3wjZ<4Je!fL#UxrBh;!pNLgRk%#
zSQ>Bv9Vg^{ZKhZF?_A#M?W>(u$>wxQvb<3IewmMrdGAWXExr0ZbdWOm03Z;j9mjRl
znY)imznqRSP)lNiBAfkd@uk;pNGK~~X}VfLkCC7>=njWYY%F>l8m)GPc>-&P2MnfF
zl4yXT1~3uV0LH#JJ?}Z&bC1{-r{4;T=MYFLA|1|8RrS`YOqet96F2mLoS83Y7SXQ@
zk@ZP?H=5bYix-t$wDABC+Py%3TrL{P!E$#B-;=3E-3k>tyN`VFI<mQ?yP9t%2%ryt
z4xWUE9&B~~bUqm5i%}>TwPkGlc@#rFl=~Vx64H}%ck(>&z;T`EE)|O6Sk*S%i)Mq2
z&a=;ORKW@O{9P_)J7~OJxbc%fa%S6qlmhw)Xa{tcM*@JFVl&pEAh*rKUYjcs>@2P-
z-0E(<(!BS!$49JH!`U$sh4&+Q>;`}55G{BD60TR9yLxOAFJ9R-D^J)xGZ#>Labi^l
z9;?!(Vh^{rd?6NB2~%YpiY!I42w3MwM(x{dZyr-yavJRU=J5M3eW+PLXH)sj6{lG(
zDG(Q$-12c0R~+1KhaG_Jc5-rq;>{O1;Bi^~ethm~?M9~Qg{50A(>t5`7P#R7_E-?r
z&6DfTv;Bsov}`7nL2=-}|4+y2Gk9lWTU*-|7<f$J^{8qZ1Rd4zL6k&xi#Jge@M)5J
z128JH-V^ygA#vgW6WDg>SiENu-f=5XppmRV!{kBnMh1A6S4U>=?^;@hV*H7lkym!p
zQx80T<VBC)TG1z>U+~oKLACv!`se13iO^x)sbt$({VOj0e0<Bz*mh-MO|^YBNXOdq
zcpE{RPOoDu#X#d_H`9j0o<0dEKj5?~9R5uU3B!l$&ii_jbS{LDnwj}GNFuvgN<DVf
ztlbMkDd4u9NSF$gwgY#|Bz_Lk!hJ||{7%DorR^%PO5KTU3xC#FX5D8-CWd{1jSK|4
zhUGLNI#x>HkJ<YqP+tQxFG$P;hyXIwc=n_mz-Z@Eqr(-VGe{V1PybEDC}RzL@`7Y0
za8}AGS^R7+I)O*ihgWZ)?tMiri-DqVj`c`|6yE5UI&&kX6ZfvEN40(x=+Qm*OGJi1
zxB&?ao9?|1^#&ChyvTw6tdo^Plb~V7^;R3K<GYAAJd;dY{9IguHQYTE1sTJMZ4<#E
zAz)@OD?cAaV{X=_7)<_YHn>K9`-b3U=C?sWPXE7~<1t?i0gMiC3WxQ4{?Y{)0cHhT
z2YM#J5OKb8uHHnU@<0k#G?*w&z|--31)8Z1!8@Pd=H=zVr=>tD6TLiGIKH^xxN(QU
z-2;|8*0K>JIdTPbH}icng%i4n{(swF$$(*ABQCxIc*%xMb4y`Xd<4aU?Z2Y;Fq`dg
zgCIB0DpnDl_P$Z2R=_a^wh3LeYPkUw`oQ<g=m$0c5rn7<=RgmFXRaVEucUn(PwfJj
z>V|11V}4zVi!-~41uGEk##+0>FBUIA8)WCq%?1WPf&QMwno18Ni~^9Oo(gi{EBq8=
z0Bx<-L#p4(alvwL;p~C_!A)Zg&s)%l)0{4~UL8$SIW))65?KKB@5Q0}x;`t@N^FfR
zmMc%y;)nBp<_2B!Ut6VicIMUu3P67LtXb#rNt^I`ds0^Y&kuQSyI=h+U2}1g>f=w{
zZZ55Y811hzo?HcjsX6%%k|mLk!Jz-2zyqrhfX03?Y0T0jKe%^W^Hu|tzGua`g-k69
zMH67o`E=f4_;@9RX|lkt67-^jk;Wm>cU~QmOpQvL31EB&5fO3TmbiEqwG_DCpkVXO
zyOYF<w9U1CFQIbEF4tMm{?WD97}2>)nA!7Tbiyy`Z)ft9NR{=;5d?HYzq8>UJ~*x0
zIm(sb8gsuo?)XNU0(*}@1LUU%C0e>)6p^;dzsKIU_=+z$+9Yr$`DBioa(NYe1FclR
z9HFFb%%8MPmwL{yV7c{bOGwp6^z+s1s+q|m{ca~NF4Z6X!~Q!pqOdb27(eG^M=IC-
zV*6aZNjZsX6a{DshwHUC;@2s4N?)W@#8YnxLEbymHF;j;m=j%ck2y>N%`et(9p)Bm
z2?JurIqIWzl`&i^TeEJOI(JvHr~s{RT>u7(G5q!VedbiL_9#-JFT{OG)l3C2@$xxl
z<c$IE-_~f(L#wfDU9BhzZ~nx-IiIvFft=Qv*-)@Pzg<epo5D~^cd(zRoYvpp>;xps
z6ezK{9B9HPt#M>|<TsDO&;bf?Zb4du8|I+H{IN}WQW<2fSf^K(A$^FtY8spyztAld
zu;jn0v)eqn$vleBPK`wU>hhnwS+xuW5F1dd{vCr}Q*(0z>8+J^)=R`yy{WV1I)GTb
zZ#Kz+@KT^oA{zhhR995ilNKkDt7;eXUY@>C?hikJYa{A+#L-#&-9{jH!Q=Gu3pH?D
zG+jtk<>grp@3;~dW>>lhANoUXVX8)D-osg#e2b8xf2U+2$wc3J4OM9yejRKfeF4@E
zFpq%Ox~}WV2vjJc>>c;|H;1w<i=+OagZAzCY}f-C<J3fb4zQ}6VqA?3sqOnGK*L-B
zdv{bXEo`Mc^^a#GXWH$o2TRc}pJ=pD;NW(-954I6(7tmgPb|6YicZlPinfp$>m2r-
z60OWN;1w*y++J!6NFBahJx%=s?_rQ$-iFgA?#s$`-xp~jNS1&splW$-t(gofS`57e
zzF#{(@oFMS6b`aK-?F^6PMj-4-UUq@o?t*G<+D?8XlN*;k?wp3OjCh*jpB0N_wTc0
z81e$=3wYHYjik3*gC*!zdfD@U@7gUywmR_&nm9ApES~=RQoCm*_B?VeMu{xGHKoay
zhrdQR`UDUj0u>?|{pCeh39vnw*86>rVWwVM!eqlHugig};*%yVsyMd)a!tSUO#6Xn
zdIa48Y3ja!wZ0~b7!X|0@e}Fa0C7_Sjp#r*&(-;f?j@L#oZ_mZ5YxBnGcW4jaF7(h
z8KMwX8rdTClp@HyHk9S}&YPx;S<}ipj<s&Wo$EeY*cy=H06v?3mn^7v9jjjktaKo5
z0I68lRl_CABX#Gt5j1g6ze(&Z6U5{4P?oOnX3%tP@FC@WmYOvGOd05wK%0pp63Z6I
zdGc@Zf&`Ap_`;==J#he5q1%1WrBfca380MU$2zTO_gUIP_J-RjE^n^Lr(cG@P&Xxw
zKS4$h*lMi{+-f!Vt~SC_QCG*;)6*MBVh;h+z;7FMz<eY0QB74<o^@U3=(hK@_R?G7
zN=QhxA5uuJW2WD)#*y22m4a(shl+<^w!r2>@A~m-(%%39G$3!J0_7q`^~D!LERDst
z6G__Ad-qR20SORvvQ(mlUjX_R+2ng>W0!;GtVmaj7o%LxKpWjWl<RP&4;noR0FMu>
z8ky)oJFVh$@AFg_e~#n*PU57}Zp+D&%5|uKE*g2Td$er(a<6Q|HA}9DcE<gPw@K_K
zdY%dqkX^3#JKNW@-osd~ZkHc--da~}+|2lbE^k(v0JxR9csc`IA<*^pOYqpOp_Vxq
z2xQVPsu)=nY2Pl4gp3e3f&$z!Dku(0`xJHOkL&4Ep~o-4rQ^J*1ijg7*JKO{^Mmn7
z+y-hcpJM?ShHEuJ4_|qhNqe@)_COuF<ErKa=G@VF+NUaEBYV(G_sILU?{8I?*T<@l
z%16i37miqtYv-8qMB)Pm<86NQDbtJj_ejek^Krats`VWF`F!ynrC_#u=XDQT9N46D
z5Eo>sN39#CDnzx2TkgScLJ$9Dlf`5Oxiwtfs)N)T(W~oxh@ee0Stjl#Re-eK(98u%
zSK9?eOR^opk{j(39r&J6)&9}mC8cR7O7l6KE*I;_HI7Y%p;Cd79p{vO!_`DKpdCUd
z6emWe(w40jfVmX*<-JK<>Zenja`Gm&8#gVh;za5ao+I=(Z>0N!EP^#6b+RV%)$7h*
zHTChkY27w&Gyg;tY&Jjf293kh1c|+qJs9^=N`D8X_CQtu{R_2ul@_T}C4Vj{xJpvq
zJ&3P?s;e|H?gaXxR}wu0YN{JeqJK<fj)h$7O0t0taD*efihuhab1XH|V{z3%;G_pE
z4Pi&;(8X})M&sEmO;w4vKZ4xGQ@O#$tWKHm!7%hf`E+?;IUy++?TFO9)H)EJPTZZg
z{`vxOakkQ;oBOaq@Nlv5abFS}rU<Ck@B={sQ|9&Ef4zOvTe7oYs$|%u^JHNORV>PS
za`Zc@-WiG`%MAfY9NwQIdO(M&Qeg$?sy9Br*aX*{q=Y9HMG;Ohj;O*u3<icw1XOKE
z_6hw<6vyaRC8L1nPY%jZ8?Y<S+hc$4s@FIBQ3J;|l%R^sNAEpOc;ig=sY`39P1j+|
z=;+n08+RmK%s{OTz5{ILf3b9xQB|$o8jp$r2#QF92#9n^mx_W2f^>&;mvkyAEg)SY
z-Q6YK-L>iNZn$%Q<NotFIJoy(Z_N4B%pFcYv%AuF$t@pRz24E=T)M(ZJWmifBJJG0
z-ofL|15{rEz3=D_<w{r)8;v{t<4O&qUQgp=m9~}^mG&B-2PfOJ+OtqjxfS=XS8b4l
z!jgB$VJLO{6=kfa<AVKiJQffnc*Oc8d&N54vD?N0U5oDY{UG0C(pwTiEwNnMx|qOI
zWl4#PAa>=Sj$yQEE?9i?A0TQA`tL~8KW~483Lq))@up!nsl@U8($QmMpSIZ(zlX^I
z{Z6|Y>953Srk>h<z?2gcLkFW{nrH+A*jx9Yk1sSFrU@kG5d!pbeL5{O(>F7db}-t{
z&u?#UkBoz(3_+3&w$96|tC*5|q9GK{QC`cDiPlva+1V7-)DOU_t;DAwa9!ZX7LnaX
zlhH6C)~>fOVIe`g;O!{=up{ckkz$Uzk_3>XYCDtnqQ+eTH`Nv|GQM-L$B{G3a}bSn
z&-^IcG5LU2mP#*)q<182TP*jb$o^y%^B4GW1RZ1iYy4UASe6C{oS2$zzsSH@{Y4>n
zK8V%e(uF4AG)ouXVKRob(wzzvM9<q&_Bhyb<hpMgRfeQ8ZL_W9{+J<|@+~Q`Xk_P@
zEIC=6NtKj8*so07Wc@wn8dkS6=^qe~*1v^q*)jGszNe)K|2!%WrJg|!s>|;5QU)S{
z^1Aku<YcMt%%pZYzS#GYo=UD=Y4=c>t8<h?pZ#FSk~-L$@uA~!dH|Ilkg(g|-z*>Q
znMq~*9BlWjF6IwejDA7~)X$#w&6^~5evy#V>o+eFb^?Xp2{|$<Kl{9`F|;!ox2b!B
zcnWsf%}poyBaLaCTXN3lCp$rTd5l?dIhiMWwg`J~$loaIIR*poh$4*;81c5Z1A~Hs
zR!vQXh9QL{Ir&#qln+=U7F=lLTPEzd3`M+RJexMd38tc%sCUG2{nei=$rx%YyrOuC
zYOuDdeVO+rh2UB&{M#$h6E6*;7kl3m!h3q8LSNSEgf}j0a|Pe6TzIAPgm0Px)zPq^
zE^uFxI%QWPHFmIqMJ8nXo!H`&uYpgdRVm#}C<z>IGSWZJHfHJw#Tm(z+~!kN*FXR8
z&_U#^Za0ayBfYe@bEm$&bekgXT%Ypet8fcmVIjMCe?yaQqqi^n`xXC2#5{A|NR=4K
z{?hnE4F6(aNk-p_=R!ebY9%ctMRgGIu8>A!`U6+Nhsx2~w3Mdg=NK-ZBX3J({IK@1
z6kl8qe5_5*%=X@05ZlF;;c17$W2!V2`o@X(^TFW+mw9FngzN7wEiH*fv3$6rP!_s@
zk&kqgBjb3$io5PyP0gnO2|19cv#_$_?fKzAwySp1F`tHprrc`nNo{RyWOQ_)zWNLG
z9Z?hw4K%7}{+O(lqZxmd8oehOb~i*+*|q}tZJhXP`4Ep<Zd|u2esxc}#!+P{oK!}R
zHTy+)m;Nh#VE-Hm>eO)j0MH(2WiGh|ZhK~1jW3}BZ$UbEY0VzcT$NNI<FItp4^k28
z>FNrOp_=~04m1l_=B1`d)ZW1lEDIOy-oK__+JC<(A)(Wvn|K|SqQi_j>AdPpN`5|k
zH7lP0TBVpC-Q7+f8BN1*?f>o{73v5{2zZrQ8(F^Xn}3MY8Kk1QmMHpLc0>2UF^0{2
zN+LaU<W5!q3cAL3&o-JcKmDBrn2m#kKztQdx`+{n=|hQ?t-2m*xt#i*ckRMSlK`2{
zAvQbnf=5)(ce{30%6}=kWk~f<VU{jI=_8bIBmTl6KYB)$Py+*><qjbsAu@p{X@VpC
zPg=kJ&wzmD;b9!AwB=5&ipkKagZ=%so}Lzt=RZd|;s+V+S=$6V%YrZ)r@G1!4FJfJ
zs5|?jMNzhC?=F6S4lH)V>Q^5?$`R)WM6Sa_E&H~Gi>_Ml)^M~h#me>#*=DvRW-o60
zoG;FSq|(kn0c?vg#|0JX@0usH+UW$GBuO`;;97ckq+uu_z<tIZYa1Hvkc?0?9aWlf
z<fnHNe!W(CO>27cBIJXo$l<tELcPsQnSHF9Y68occnF0!#q$1mOOglftBhRxtBUbx
zX3&HH^TKW)l{z&*^K9EktGhsZNJ({P%bmE!&R&6bDrWaBSzfX435W28Ygr93U8F#+
zbEr#Mh-IhUas=!9q2JL!-=Z*Lnhme+oDAm$8|L`yxjxW4v7e?0Te(*@8|CP>Q;Avf
zqP^y9I{cO#kQi_%qgZW@1@{Wv#Dc4Tes%RHoDzAp=QIWe2H7eVPrgIIQwU%T6Qw4i
zIy#gB*Qewl*VhKOCv>xXLUDtAe&pojNVow4As{WpI9y#E!ffDIgR{X__B*A>6WA=;
zdU{%h2HmvE(wz1gC@Cr}&^5HY<Y`zH_^;}3QRIm-CuNu+$Q;fLrCML&U`*SR#YBt>
z|B{ySe8;c=6(uhRXVYr3f=CGRRBfGP_@$WL8L+mz({>YJEV~nJ69AOF-da5c2pF?>
z_{>X~ld_z-%*63MssyjJ=nQ2kiAQbN>@GvGF*S8vE*O6~R^3yOhxn(KoYjxn)q7#l
zCqYU<q2K&aN$Z>>Do;qecG3nE?GK-Dv5BsL<Q7ivM)Irw_CT@VfkgKCr|}zshk8?X
zX9!r~sA;M{B0dWjnuYdSg1=qpyTKn}uVY7>WYh<Yk5lEse*%}^9`{`Z(nk*z)SsJ-
z)(Qc?EK#bi0fqh>`M1}h1zS6ri?)!uQ8&r*&oJG56~x7gwN6~Dx?RtyseQn3f1Anm
z+9{k)@f{clAnvW$Y$m=8;gE&Udfn9L2Rs@JD=Re}T{R+2c88gkhUReN7Q%!=S~OlE
z0pLwb<E}8L6LY=FvvK?*;WtTP0DPd&453ro9DkdQp^o#vwo+9}S#G57zjRWOC!_@{
zGviB}KQ(1F{iCkzDZgxQxLem2-@Q3myF3cc!ACSvzK11;lq9&uiVWfsnyl#}9}j+i
zi{~^?*{GvHt%^W+!Y3_4KATg)v@frAva9QPsQ*=tWaFrEz149KDjRB3<k&Ed+ZsiL
z8kRuZ)Ebg0k~FAXbcD457CAf3HyWXivW?OY?OngUPGeXbnLwffN0K@C6D{4Vqeuu9
zvn*b3t3VqCXfXvQvTTvC*)n0B-T9rzV7#;_WnYM)CSFtP?V9ycBd;TpSPlq~1n)Lz
z6;Hn^MQo^fT-lKSm%VJOjH+;hs-;du5Rls5OiK7yDudH}7Uk;vsA>W63ccc&Y)^Jr
zS{q|l3*Z1Ltd&@shFU|UKL81cKRZJQqsXo4v^fA_*tusG-%IfyxS&x{s-GA*fcj6(
z@SRCEn1T;%RW!Etv?<ok1%_L}83D3h=tM{Jh(~$Ge85rH&)9??B__Ax@;gksZy_i#
zfaGNC)R{x3?VxU3{82swEYr#yeF+_MR$TVOYya8VuWuSp7A<{#nH{%&d!;6y_35Si
zSCc7w8}s`)eEzQF)l<qB{iU?_zR<nepIny;jVjz$tw+d@2>+7JR+gM=zf}+QV$&+w
zRa2}~yh2WvZOX4sI~_Ywk~KmF+CHOAHcL+ah*tT8zvWU$Aq=gqjgckJ`6TE~qZ1%C
z=g_R0bK8r<_Z->%V`oW7s^yRkbq4CNR;}YYvRO$0qaInbe+OhO3X!i)?TlYxTJ5r|
zR}<tk{jJ#p5%)8b&nDRtt%M1fe?_N0uUvKaFNVwAuB`rjL)ibY>?Iu=2>$^{T^J(@
z&dn?4PY<J&z<ii{U~s*EmHv9N`<~(jA@A}!gBjL{&ENh}bDpY67qfj!E&O~PWA`A;
zu*rkH<Qmi+5xY-hGuwW8dRE~slj+AKyaJrbB790ZvWB(Oq`jE;7^HIgH8X!54E@s}
zA;tO`HBgR;=eaaoU9#2@{pTx^I2-C;jW%BzHdLFzYW8BS6rl&n@O%=p{JJW>LjYjy
zOwMZ$1|HJFVWV}{Wm>#fUF7~BY+(V21p-jLtOX36$QEu$$)}dAht8#(bwpQQ7l+M8
z0!W<ssD$1xa0$YqB2Bdh3#o+}I+$;HPeeIe4QbMY)>fOVFpJqLHCCIaSP)ZqDLZUv
z&`7!WCmy1+xC{siN!|r(!9rPR#(CnuM3X5yhc6#%WT$SSGMEUP-ag9Y7SYX)v~Uh<
zG1IeM*y+|0y^d{ZaAU>bcd;C>=;|U!;35oFYygSEp}njnzW?@YbCJ8CKLh&1%FF{Z
z6YeziZR);eU+8Tok~M3UU$EF61>N_h9UhCMJ~J14b>fXLPbwBdAxBct<QS9GuTR<F
zw5iBa!U_$!P>m3aA5B!jCMQs9`OMP$SH(S_Kh@Sv|3t|;Ljt708J!`8b(p2G_hzq|
zB=`wQ<@6NtY8|0!5Pd|kzjuuG@d@;0+Ixa=7ECO*nzmNY7;|_;-&Q=NmA*^LI~EA+
zCSge)u(%5XK0r){)08}8O^HprclSWQ?s<|o1zJa@;-&3>otRW>dUhC~B0v*V?i(pG
z)ku+(?Xxf`Lk%j+n32DOiq5h=W&5{k>m-$bDP`PBeP;Jgd=0rveRGLPQtMA~#$~_h
zg3ZjeeyI)}-l6FTP)jg7Obfyt1jJ&M>xYfd^;YZS<p9Z?g0k1!C#;~8&~xQ)Y>&Ro
z-HWTSKlxEA6!DFdD4{ddNJ3g6x1oE)pHjN2uVuO;ee@$R#KQ9Ni(}1BAVK6$z-y`5
z3SdNW<arF}C8S{mgAwQeM8B{NP8}qO{&d<qIBRb>WW85+lz?tk?TS1^KzzgNKhQZZ
zO<znBgykg;=$~m%-gV(kkFg)>=?wP_<pELiRN5h^JJeKg>&Jh;dlO-{U%zT2<l2!Z
zXQXIP;R7<MwTQyC^__p6jmpDSm)?nM7muZT5$q+Irm0m+CoKxB@>X*cvPb--rJc$i
zrNlF<*N-zifjQ6G@hOCNd;0y)%cZB!WYbTrTJMe!4K7hujz#YEyC(|eiKLI{pTS2*
zJ832tsYK*AV_LIUdY=O%|4lBIf}!duys{t?W4{+i{*rmYpTfNC>pY9tSg@ne`5l;k
zi%dHOaPMrrhwv(iI|@Qiz;_2BEjN=6Y63OqOLO%0mT%16xAJPKmT2s(!nOxfpiF><
zmZ`)$L9!^k(2o|$RESfo@#FMvV<W#EK^Xa8_(0Gssc!`)DJ3;S8y#~}`qfF#EUAZH
z<Ox(Er!yl56iaL269z#3(>5xDi$pX|OIz2ARl9Y_A&6~cC^Rr!0@0rroLWifVix@=
zMXEr%o2WK4F85@w*@PrTVl<7AuVwC31%UhbZ)=r`-Xu25)ttqYaB#3Vw8w&=+0K4i
z@rhx$g+qQ4660uDMP!pdu;;xo;so{(d0gs?y-MOCh|p4$%9yWEZy5hZM)+NlpP<&R
zsk}L!P06S1#$WSDavHt0Y}=$UoBx(j+=&et++$Sy+YfIDK&adOS@L{#J?>)SHGzsM
zJ*>%s8RBJFX4&1p=@Q1n4EU}B9-0TLcj*B-75kCqUyB%oY{uCiAlQZO%KLDo_^Uca
zO4v4i$?0c-lea2<r`LmlUnuSZG%c7{cK*WhaWAOzh=82oC&BIjEgegKm{E?Fw$2Bv
z$`{3mS;Mz|6fe?*_s`3_QG2QHqaYq>aq=y_j=ATgyi!2*Hv)d@w_qzSTe&ObMqEcv
zdNaQCnlsP?Gae=5rAxTQ3^ACV+R}|cY4H!K)KjQ?v&b@L{xX0}ok-(E*5@byoTp7A
zdKUvAlYSWHwc>)Yk^^5k@u+1iGA3VJ372F8_x``|r+3Y+@dK2!?9@T3dx2RzxO0J6
z)~_AMH5+0>vt?WurNHvgO&-w)dXi#8BJD+JeXG_xa9EU^o(!>^&R%FO{+3%XHR>sh
zQVoa}XApUUB%y^T8NhE@Y*jQ@l@S*}@Z>jzPeM@I?)9=hjSPWtcUbi|S7mS?>&R%x
zLOGQ+4KVp{51}mORU7dHlz1XM6<QzCKjp8Y5QM_Rj<M>MHG-2P7`=GdcLXml&!2Gd
zh5Y@ieXerA?Ra^4Vt(!DvUbdFq8yY}l&8Y5P#=f@l}-JCAg*FDG&k*@Q)R2qr7O?&
z=ljA@zmax-ep=04$ksSfaR4-;NEfwMPe&+-YCB<(vqvf~>FadtM@^qv+R~w&v=r^P
zQNED!J3USmx0~RI|Ca~%KPbVcOg`J29oW0@MG5Izu+8ueW%TUKm4IaZhT|^|h;fjP
z#WWtxSAbCr<cHhp#J#I$>UXD{vIGQn#g(V?d@uvRv)b6P`qkNWq)stV>X)?AXCP?V
zd51gGXEUWz=FZd`&onyiq5i$cZC5y#p$4nYK1G(daQ|tZ$xnd16Xkzl^ThA8Mv8lR
z-=P%IG}1<O$Gz;vyis|d6b5400KS9sgZ*8(lIwJ%p<$2Q`#But6JsZ6u;_eeKk2jE
z*wnrk4_X{6udybHvAR@!C+`sw>YR&kh9|_!^*pkM5gmE!P&^nR64jk`ySjAZ#m^Zr
zUlyTKzgNmX7y$(tEC%o@RM^hFO>$^_YKhN?Zqh!0ubR&$kBmETM#BW$cV-v+9?AB0
z=VrK4*XKoKCFHRa_)B)m{MKkEJh9#>>;`Zp+}_=~zJs`;B?vYk9|E;f13g%gs&_9G
zK}#R#^R9(Mnj2p=%~0BoASjn#FicJ;?~SmFV>K0tjTf#_4@0i@d`J>f4@VZU*W+w*
zYN>fINtf&jJEAe4@#ZU-9^vj#BOQ+(E~+B5M*P0C)TQI82i693wMh9;r>@n~MTYA7
zQwDU^$Dh2};x>pDPDn_R3+>OpdemO3`=gBm9iDA#!9@5)MLk;XrJr9|eRxG+ZC!Iw
zIT>|uv>14~ua5~<Q6xY%Ebt<#c<~iLvPawB*ub=r7hv2SJw6R$F>;7TxL3#51mXld
zoMgChTb9!<23i`!s|yWNFU^0eOHdHH47^ECYKm4=h0>goJ1LTRhGZG6`H~ksYlLmy
zn5BX*-9h+mXI6B-(4!Km!DWGhQFNoHkeZh`MFm#{!)(QLs5UE54UWY|Yf%MGqqDDu
zRK@}6k~mRHO;>)8EZ9@Pl8P<Yz1{+fCRE3GSYy4mElehB7U0y-pVRGbNpm>(Sog;L
zK@I$BAYbs$n{NTTST93{M0>~1oCH8Tm@|BwGJJJk^|8_l-b|_eZ+JSzhW2&!E3fW%
z*H5&#!+&oQ)K>Or5sz5qo>)652ECzT7nt@2X3{++!wq;j|I2k!qyjTcNo#ki#w~9A
z+8BwM2&V*}>QCOi+KDHFtetGfzf|Oc))%#f{2?dTEDU9tHD$zv@tdE4#0H0l|IIej
z%0NITl_ThW68sG?{}l>~054q)Pe%#)be=%)L6+<LUC38}6^ce>tF5oxSRY0q;#9;K
z&%q%?CbDa8OG@%+gg{oy5d32cbpm1#@KT>UV(gH~QRA<$$_2ESw+nB_sH3%XLmJc(
zy%o;>nTtdTstq1HLA%@Pl`1(Pl{a?HWjydIPG?KG8XCue{iaiu`e)=?V%+;NtfN{~
zT`SP7&TpqWVleFNO2xIpek-(F`0a2aO|#gwjs551dH;YX91x5)tt{&s?jSu*w@t|6
zQiv)%ofCIrVSfrrDrlqd&xQqvM7vna^HMTGK7{h@P0eDVgp*XZW#dp$XEIeAM?v69
z9p6YO#8W}Lz-rJgndD7CWpy-{#9aCBpw%7s%x?1TW9<hHU=}mwhKukhKoTU-I2Gu?
zi2Zn+NP>C-p*=xms<R+<M*;0ZWSLM&L!ZAnK&ab0cjA>Cqd$d(-=bGNU1(Q3B@8yR
z1~Fi;`b{H5KV^&III(5izHww4(x@Q~kei>p+Jm?J9DGC?CaH_={adF?!6YRkU#nvE
z*vK!7lr9_%o?ALl1POd8J9&e3jS<(FihNpJ>^X)eH>Ix%UkcD>BCe{5=@hw>XyN5G
zjZgdrM@0)ge;3sxBi?2=xYEEF-kI>t5gWptY(#LRU3gpOue`j`mn`vnF-+^rFs&iO
zsOQHRQ40gVnBm)s`jvG}tro_hqdzfq<N&6mUR(J)vn>&!M**XSDO7eF31xN7JSKOe
zyM=Wt+&okyr0Je=57PCy$a1O)CkqXkI>X#9$cIso%pR^6L3~aUoK_`kM4%o*`PYTG
zzI<JiRX_J$Bt)TF;D>=|P_T07o14)=Xa5dN(H>g8`4i#DI#v0~ub{uR;hzcec03&>
z5RWa+7Ob(CgSxWNSuVN$08+Z<#+mD|xoWmIzV(&1V>}`RQ~fsDf%ZxD|47-KJHW7+
z-!upcQ5JZYkLMehnzdLRz5~=k`{M3$Hm}H6K+81b3GvtKD_b4sOpU}r{ebCWq=Nqd
zGKb{4)>}Yx3q%gwDakGs&jpdnFh|T)ngvEg!oP^B1^)?&@*>dpmS;TM3ea04Q;o|y
zTWIiqsK9Vym%|_JFNT`nkD&t!T=xrE86!KVBWgL~8V@m4GsL7<*^ZH4!<z_sfFCN1
zdUxB8(ex=JL52|^ag;lJAVUg^Y3uz%@>=eH?a^vky)E7a#zLb?gU#5C+mvv$t}K=a
z)R>X%(gzQce>k$9E5(9UAszZ?besh0B8)2aY+F)D?Wm0$`>{i^?H?LO4b+$a^)eO|
zt*nvcItH2A^&U)6dHDiHia;CZ-R&lWb{k#I2t;OZ$@<A{vjZ#6Ja<99>Bl@pt^*Rj
z3#jh?xKkPCG_lsj_A_#tv=zr+S39c{qSQ`cw+=+(yzr=sIPGMZdJTuGW__;08~HOk
z6}`rd3xkp;a3?RWEL6@K)}JyZed1gUlVd*fP68Vha1$$&)Nzp}?^BjU?RAh<BWMVL
zr2|%)IKkh<%={x0NM>5);*i|YZ&{;N0P9NiE?Bms4Yw0%-`UUpD=ImznQ01x1NHRm
zh|SK~ZC72>P*-sA@FPE3w2aY(vH=eq!@hD!xwdt4TT|n3K7%G&I4A5>)0QsOmGhI*
z*AGc6p|Dfdmpi?v9Ot$)>Omz(a(RpeJ|PUXEbq9xb$p0WM7{WLd85dpd5StB4&KJT
z_hc&v4~X$5+X-POSE%>o?}<g%U!j1L4rwVyQDq*mPLm3NMZ$_)B-CJn*c*AN8rZ_>
z?iQdV2jO6+bpkI=m)`rDa$3B**J8y&^jqhtEE7C)kF=){>D4g7H675g$Bh@!iM*D`
zita$Q?BbGq50kK9s0WM&LM}&`JV`}Nl5KX@?`d6JiiL9q(1gWZly`PTnudy;ICX;R
zjj%m#3cot5<=Kug8CwhUpVeGP<%y5zI$eCBf(q-F5i2Fwf$;X0Zj}lVka!tw7_=sQ
zyXd3+h)c&;d;T<G$CoWKLdVFop%8x>Z%~9|=+xEqeWAWtY&{V*RK#fu6G-QQ(u3uz
zXFU$&?kN@SZbzisYKo*_fb?>IJJ$nNgv9YJuuB6i`$B{%Cylgs)akF0zZ~se$N7Ed
z7niu$Ja{E7V}MV<vGwkqIDWj%a<*eNuIjqtt1~6=@v=IPTlmt*SnU?*9Sl07Z>RNt
zqMO2QT_g<*0pAY*ON0sQ-C9@fh8Tigx%Zd)zxf$$U3}i)(&YS7z5q3x_RddrBNJs+
zmxB5UMbMT2eLn_LI)EC$wtBD_Jy?A%d<SPZfa)KQQdFU(9Ea}l@x583x)~n8((utq
zw5o3A?;;H+JPFJJ`o^R29tHmK$9{>tRuw8O!cgr`b>rsTVa(;}+@X>tn8{e?s^u?a
zTj1Vs_!qC{=+(GafqH_y%{!l0)0h21+Rx7N$Y6+VcwnX?FGq5?XXc#McSd53rplEq
zBT2GCsei2*F75kpci-Vw-n+oAxo=~_YxW6FEpyS=u#KR4wS%Uwj(6g=Ezg0_Nhd>w
z_QZe|-58FaoEz}xr$(lvV4qgC-(GRaDI2AM>*K1DPg$?(`P2gyl}Y45VKXt|>By74
z)^!rIuAV$K+8$yZbh6lf>n)q?lr-K|H`$YK1dQUDGHv!3wWUt%{OHmtu^>4TyS#oi
zj+&X@sa@HzV}{7;3_f4$qjVAfMc8#av{T24vyvFBhfpwpc9h+dkc8nk{3Y+p-#~h#
zkE}jfPBMDd{%o5B?$zkepIo?#<YNConQr!zH6Z|#RpGaE2n9dF<!wUW^_d6LHX18$
z=PnqbL&J&4%8GsAw!S>Jlc+||7KEUW<-OswLqE}8!U4BlDi8dwGVZ9~z3F+FpxD5K
zG5~(x0_@EEO2ep_KAc1`uCuo}S0h&TMToCY-<D%v@gATHw`^yYm`HxLb7#eX=teaX
zgfClB)q=5!keJ+q6GrZ)<5!J>UZBZ5I3S<4C}yDqm0<r2(fqsAITT&MWS4`Cf>cmj
zEf;w&ls)PP9)rj3ghannaN0STBJyNXG0E!+WcKQx*FWxPP;sAeK@^&SIq6)_3)l^c
zPs6ezD=zPFQOXvBM0L`e`|Dq(%Y7wi$98T;!Zc530QWdjp?uotkCXN)R|ct_N+8|(
zQB<OsbOALB^WFum$gaA?b{phly`HFgDe?qVdCXABSbnk^p1N_Uw9V1J3YjlPb<CM4
zi__SxxZe=hG%*neC*&O?qnmAS*d=03nGPoqyVy0Nciz`M6AWpCL3#Y$-pYR^@mE#X
zH&@!=Bz(N8`N2Vwa^V^2*Sg27cd4xQzRo2xJ!SEU>mNsUT46MeM->RyKXLpK8*3$c
zr#$SfvlU?Rri+^JBu%qrHZ)-P-&daV0%sd<={W@y{UC}jGS-zh_E&)7-W~U-2z>^s
zg!XCl-e<fv%n3U^w6F3;`l!aD!iuWC>h+&igdB9>mz^>N8+?FN&;0{(zVewjjEWFr
z>Q^VcJCgbhz<9`*%AadT+^L#ao$R`~a&a)hQ!}b#6ioG1qn*nw`?{=XgQ+fUG+E4g
zuvVC@TC=5U(ye&#(UxQ@jka~aQ2^I|wN+~oUxB6-vgt4+4pYGl1aef}JkEAAp+yl4
zu!w2p6e|oprEu0>5^;YUuEL;oJ$4L?-5>DY_J>h%8NLs*2hp!?M~h>-Cr{}8d=El^
zA#cj~k@+YPaH+^%lqHEqmd6v;aS@Yr%g)6dEoohaSfp(sST-$Vqyt2J+Cym#>BTQv
z==jCJnaCgbEZg-jF3=1F(^N(2ApmITUKyx1Tp5uo7wB8Iatpd;br_9S_(VE{J37=D
z@7mvQnEuzD;~a-cC~K+c{$Lk81<20I7Sk4~eSpw_sk+r)^;48QqN+doI(2Z=)Nt!<
zq0x$^9ve`b_s)oe?A~2SAu5uOWs20#lW9AHVh#iz;N;gi-p78Q{EWRa$o%99)O>=q
z(+U5)SPfn+vD7-JW9RUp=Z%(uE)l2!l--XrC=k>#Hp}n5@GYw1k`sr9K4-Joi6h0m
zekubFLop@G-#|-3P8`yNe+N&2f$BxcuM1pa3Yr`|h>no!-R?=cayu0Cv9Bnw_PTSg
z&7=wa?OXjf$P0asRN6=xI?%I~v52EmQbdnCR7?#s?IEC>gaWpU{dNiwSj6}VXX0Bg
z?%mqmD@8+gJM}D&rf(A|@)r@xr9OPryuxgB_8>`@(giL-NMVqa%lW!ohz+q}Z14?j
zpX}Uku%5(;Yu4kj-ndhH@kSY}-OS~^fPBWQd?N^u)3mxLp+?+4F-zCDfO`;CGJgk5
zyI1dGBL_eEMg5pHT&WO)2Kuc*STqRsF3%M(RZIvHsLR<{+#k%4l2yH&S)XW5teZJx
zx?Sp@Q_>qq)~Uc*Vrp&l7AqHT{6@8blv~zlG8ETkK0f6L6Cbr|B7ZLfarnR{^<B!G
z4_n%qrLA#NjTGEuKy>(y3YVf<`7zc3L*QPaGW{QsBC{y2HnGUiT}3a4!miI&I5U$D
z6Cv_)-Nh-b?bHTNoYLhNKcOIDV2*;pNuBu4Ia%J77x+_D)MeSr*ndsK=PoV0^zem}
zpRpKKFqE%@EX$0__FvP#tYb)|;H_AG4Tjyu$;u)p-7=xk7l2)XW*x3kT0g-&*T3>P
z4T(^eDazQDj<`T|x_7v#xoeN+hVn4QAdalj*fYCc(F>BE07H~jKUwdbw&=Rpq8nas
zxt$80_(Hg3LFWi!guSNqK~%kmHhZ?(OPkxUgTNo$yO1S;Kh@eY<pCVg{DS^l@a?lk
zkfs%9?jacGwvlIRJNR{?fHcw>CU8LIUNh=^{Ss~uXfZ<N<&XySX983B(mD%_b>K-(
zrRU4t@jQ1i)N|*P2P@|OCZpb$(V=ps*C|>_f<Dk|f>3*Lkhn6w98!YLER=AaLu!+U
zN9=E}{_y;$jq9=T6fV=7vyt3mWYzt*A(`8RakS<fpjY?~7<vPdwKDS0%bCH(cF<Vd
z1N1LaTbLx&^>h<JNdN@FBYt3O{HXVu$TVL(JS%{UR?oV%z2kR!u_lSSb%zGZt0_L{
z(O>&~N?Jn7SKIUcwe~lpTcU^2U<5(`Vp+@3?=;?(s}RE$9~=K$xdn8xN%<-tB7^t@
z#CHstRt$&xMUm7|@e`yi-fi#eE5eFWUqg(b9PSkL=oK(-?;ksx99;l5J?J8<kmD?8
zYwu2)N@{k<4O8u=oNo&(j*U%-3LTAGkxt&Yq#=$$R#0dqB!9((C~x)#uH5X92>gcy
z@K<zVPXWEsl5vp*!Iw+q$X#jA*sT>7dwW%ndfr@!gADK9^aWtUeXj!Qt>pSUj&s}3
z;f;wvC`uz_qd;$b$(cj@NG>&?G=gF}J09%xW6`v*XJhJB(!2hCB01lStW6zxNd8};
ztZ<0kw<Oc8Mj*(~;I<5SB(NMI%ZltMDt-k-N%g>?r)wzTdbL1kQ`hv1xFqX~w}6#z
zeknF#&7-$i{#piGN@-N5Dal7-$|D(wV@R{zy;!I*FJq$ue+M8?#^zpML3R#3pjSy$
zNaF*0F?EO75IEfHAP6yE|C8_))`GID5I%b3gyZDFmSEhMHl+2uqwE5kz=Uy%7~UG5
ziK7gv=%ZC%H-<<oAyHex+m8PlYW6Pe*#U-Xfe-i+G+`;mP}p`U*r?Q9c4v-H7nB+E
z{#16Pi{jvjyFFXr@&nqd7$NKxX*4VAf<r$+fq}S0lj)-%f#Pg(vlNrO5(zjHpLVq5
z31WGq`o)s?WG#O}`6iTW$i$ch>C}Yr>mL9#1#4$y`Qm*D>?GuKDMJyK>)!SXs4)Gp
zwkC?P@(BZ?_ExYPKphG(Qjn^nw`-5Czt+KXvNk{ouSRR=#YjUOGBa8djBWONwyFl6
z0By2V$9dN~vkNC5*ncMLKM^j=Vk6JvhaeJITJ4Z84!I=?%vppC>;dxnH;|~4XVT~V
zFn*BgI~-Y={j)U8X}=%L5R);Np+gw<2sBqcF7nUp9|64RaoIsSgO#JQsQjSebE%%(
z)4YnKypo*6=beo`ZtA2PBJ!^HAaq9TY7Os#;k8<QO;X-%0fB+r0NH`VW`A{^6)*Bt
z8&LnJ8pWpJ3*ZG%aHJcbJ&2qbOn~Kb%kFyA9Q;}YQ^Munpf6)euU6^?@>yCbB~|%5
zIpmZXm?!)kdZ%{!nPbBgDm{1Ei4r9r`?|PcTsl?$BBLBdr=zn4tIXQ?5r4JoYW~c<
z5KLSazo^|S$pJr_2bKkz)7X4QvbuH0nCCGhC%dg(MWZB;haID_zx%<MWY;9e1kOjv
ztaXM(WAM&(C{E*#4S0SEGiBBh^kXVJC>%V}j#_glbom)9t@C{EDskI|m-VB3+D<?~
z@aAhxj0OM*8~=qf$YhjsDcXk|Hav8{xNrLs0;dBY%y^XJ{o~M-4Oykv6<SF?3x8sm
zPscK);b)N%2S#kx1_TF?bpsO2fA7h%G8nZ+^)HB5VA9}8(Z?siO^(jyYXIMkT_=#K
zPINxn>ab4RGs+=tE?t)w#dIj@K1zT8-ND|$M&}xJtD(t8c`5Cgy|wo$;Ky`PBc6c7
z{~h_ndt$^XKx$SUkx^5|*QsaS2-#Q0!LeyBTt@jsjR%5CO#f>b<FC)q(-_$JDKdU_
zo;p|xD^;#}F_S9m*r6tw>p_vxmp&trS~w?00B0%Sc=Lvnc5anQNjlpTgOE4>WL2|S
zK9u_p)0YiHaJYn%4A6rOyPU~^5bu*eeaPPB&SQN_yqWQs6H@(AeRJz|DSpfwJO95A
zafqF_&d!42vXYm7HX223r`aF?46gAZ0Zaqq5)-4_K!<o-UatdO_7Rh;UkA+|kHBBz
zO;HaZY2o>5icrwZc<&ENOxvdS412c53~+b{rUpm3!EKC5YMiD{qBjDe-pjw)9Uc*W
z!*+>9+=UE)7lXcbChn1nb{xnr_QxYu3UMtR!F%1%_Y7p-EakmG2${cTCIwzvG}VT^
zeDz?afUEi<Vw(sgSnaEUY5}D|Vzl$EXqGYrJ|Me3(-&JPx+_723(|ow-|Z|t+twZ_
z+s|kA7FO3Kwp$AlK}}N)h}naucjlHW+1sMcH$NW}T_=n4K*Q>YS*#<sgMtDE$>t7n
zkpPk^$M57p#Y38Ze-&J*yfia5c1rytMW)yPI}pNcrDYN|dwfHmhL5UB>>2V0hSNn4
zJg7jw=8S9UAP>0b(h!IAPS*gHjBIs*M+1<A7s1#z%MZ!Lr)z(5sSN8q@|Dg$ANh3B
zeBF*7gts!;9z%7`;SvZyrEVVYXJ9LO-w4;n4kh-_b+ESI6}u7P&`O629B79@#<AGn
zha6WNqiUp|DT>e<TsuqZLVKHYbdO3~H;MtXskS#Wf-+wD^>xnY6$P7B%{Uu*BLl|0
z=F{Ugom~JWuRLPC6ryR)zAEWeZ_*?4Ykh{(Fc=yKdBzkIUhDzq7D&0wHlbEt1VvH$
zDAlCq&z?SdyUR0=N2n3S6(A6k;B>Wo^9#xr@bY!3S%iepuuWeQpUp(Jc%K#e(ncK*
zGQ${$Qw0$xBaMO;NPJ7ZvVwR-HmEqy41{p$#H_c-d#`$&U3+te)$Yi<?ao-4;Co9H
zV(y)tGh0u9B@~KDUn<m9{`8s)`QrNcZ0MNb^kTTN1PhA$+bF0E;6DG$Xm_6aBc8GE
z^L~YZSOnGa5OOE@B%f4yLc76ztlBoR^4^)fmd_M*Ker=uh*!2KP#q#()$k@x=>#F(
z5UQs&+A3F$5?0*~FZUGa_*f(2p4X&@piqgDnB^E0@2;NtYr=;YBdw;7>&Fq5R=vR1
zbJ6T*hoO_W^<mF1%eJC$KA2@63NX?JENmrs4;fH}wu7KhG@c+Gtq?I`6$pFwwZkS@
z!tE{e(ca+xzOrYp=|2VwvLa^+xg|d21%H?^n!$pM4=Sz6LC9>I8Zd;F(=z*nw;>Lq
zrQXp)LPzy!RqpG0z=`3|(lt*g14TAj8ajtEYi+DPXU0_{{R$*clM=F0il*5%7X%yb
zLaCNE8vl|z36F|a+9h`6!G_R4C1jB^AEhn8;Dt3Pw+5nAj~d;)C0shQe=-{V@9RvF
z)W*2{w$PQge0`JNvv@Ny6z31)|LiREMV-Y*z#ub5)Nj{!2*Muct4v&19;1A_wLfyE
z)%>62We#1Hdm*w_JZXy_F#QvAD&wx-kSF}_zuS$$|NA0t@f0G}1!TU!TmkR3+p#N$
zdV&n=J4%xd?wrjMf$0aP)l92itQm9yv3LHhVDn(jkC?}Y!~cbh)@fdZ46v2fHPu~{
zWOg}F=^#(9|L>ZtTEZx80^^msv{s&t8Zx@kzAdk*<}=_48dIUZDEtuDX=H>tY+%bp
zWn{^rYVWz?@<7klO3uAC40emP8KGB+HRu+QU28?8^2lllMChq!ISGDpSui3$=Th8j
zFF!`11BAOavc)gyVHwDf9ylOl$Xyt)p>P4O11he3U@t>|-pvW*=^QdKbu!W9{Jc@l
zLo<xWf7<nnJ>Vqp3IgVU7ZrNx&PZjGoRlZ%ZgS9>8Fe0N>Jta0pj^+oSDa^V*2dv@
z81ED7l<$dA6h5<`uuP?U{m%l@HhETEuSMe;9qZ8Z2E|{7?$xh;5gHw8cd*=A6AJAD
z<^pWNA0x|%VStJ*y};YIijAyyby)Cs`1@d%2hYP!S>Dq1r#Pq`jX~gw0nsoDga9z?
z7i^mY_JlJ1U#FSLz+KT^1h!^=pB?}SQ=rx7XJabwKL+6zZ>^HNlNB%z@x)Vq`;RXm
z!KTh+<(8eZwvkuaH?w?`4<%kvof23Hs=hE~Axl?XQIqPWDcWG8z;GE`Fok%}Ps770
zH`ptD*Z*kZi;ePb&Q3C4KQl?M!m0vsNzvX{bb|#U>(4qzXi*r9SSEn1d&6r6hbSZ%
z1?6&&>yt?VDe6c1KiD3kpoE62986@4AVpv5OD^cWKJbskiGkTVgkleXHV{*J*iWwM
z&Ana*J_=$az{dES5q(h=K=<Ao0&z%BsSONAJt&6A8T;iG){p;d1;9y*Q3|0o$V*ty
z=$WY+TNMxDQRUYr|3hhio=ew~iG*jc;in$Q<JEXYjmYz-JF63Q@9-qR`^flJWNs;3
zdAc^j5L<BgKB;pQf+moV&Q%Dvm+nJ{31ujdsenu*>`5;8`||EzGTl#iXT;W$1+F1y
z09`<Ft`r$h1A+(h=j``Dy>l0vAdmj8`73^Tfp5Ck<;Ud{ulYN7TityiWV0Tu3ww=m
z`DMnO88sl7PNKD5A_S}B?)DW%gc&5NA|<8U2a1t2OVB-_0WFF0J3N`yYSdq8t2zJA
z^C`vU0M*{xFXg2$5S?S)iP(PY#jG5XyO5s)ajn2_w|C*BQA@KqO+7PZr*rryPjLuZ
zI8;B6V|2^;;m4J+!=Mi3C~qqQBMm8Uy7I^KjT#F``O+`0F?R$tktzdVGeM>6Uh`@M
zBT}S)UMHukq^LL9f3j6~FG5G&(5{Z?D4@_u?N1a2ngHZ_zao{r(&D&~FF2!cE@Cz0
zwof*%<%1~T7stRt9$2}Mp0#$?ny+N?!5qfHq++ISriNNA2~IBb&xG1pNW|Gd`<xv)
zi~+IIPrh}YG7G&8tDKvwxTaS*t&9G%R@2>2B%)vaaTQ)Ny4gnHCvxVKmBFX7ub<T4
z0tMwfcr5h|9ZowlhXP7*O$EwyzFWgkHJDw;4|6tQbb#?xdH*aw(u)HVG9#m+9upCD
z?Jsqjom(RwA+A|{;bsF_W7p>N?w2VYGh^QuMdcx|r-AD`ebEDf@~VJ_H-S)6Y;Ac`
z{{s9#`?lGpEwdp8s)rkQL2y$+$3J0nt8Ym^;C_wNSaD-?Pss!*F0i(ZX?0^8<};7(
zkaF%4Q8pV`PuRm+(v;%>)iFhQo1NA|g^>3Rh)dg6qo1#4l%$E!>)WON5qr51YJtpD
zg;ZiU=-8PegN_ilw|0wJsi^Z}LE=uhC+0cXZi24?M)$|hp0#kyIBCgTz-&+!!=YEG
zkBB}(U|=ub3DLLZuCI_Y#c}rOW)fn5@)uN|eX8&eYV{z<RzF%9w?b+yU<dp85Fa-4
zY><mQ$;%FUp7SNb_NYIyPl&c;2Q1ZK{X%hKDdpR$CfHv4MDHG9q)Xnjy3`Bi(sLxG
zJz_|UJg<3(5)^sr3P-)>K2B8f$-vl;QwL2vOA2;yJH$lS@f;yXIPfBWjd42!JoksC
zrOU9z9-2bK@V7k<2p@3H8JN!*K-2R~Z1sC~s{R_}O`^u9nDbQ7-_C~d;JYx&ZFklk
zlVJE7MuL(*fByY0+Ot071m~W(PM9JLDc_8y`(f9%II`(>Mxmy`OReYk1|}Ly`;U<~
zuqtb(`Sw2zFwS#KT#sT?8w*7EfX?JEHF1H7cK-@UMB;B`IW{?g&cU?Ox2s=)yUC^e
z&!4}khL^)N`Y+0#cvMZ6)E#Wedk#<LO5|f}-L|S9g+#0IC&B%*%%Guh5-9O=Nu6D4
zUL%A#19^F5r`O8|@6$MVjUHQ_DMyTcaoP&{xKBupK{lmEu<cgvjvP)36C6e-V3IBq
z4BG})1=3*tW@di6`DRhD9q~RzDp87!zZ9Xukg%c~yOWgD4>1jMJKF8o&Q}=m3poM7
z;3CoAGHujyz9KMjMJ^7*%BmHNM~NjdvhG`1LrMVe`9h1ZRbygrumAH$sotyXaQFrF
z5etIB#RM`+7;z&unZw76$qQwhH)}Iitm@=tv=$QUl`-4xYt(5*SA0M;b|C*$BAFp`
zXc56=d!##DAOqxBU|J6KR`vSLpEbi2?fTO%y1ASXWGcP7sMWgqC>}$tv3MInB+{nS
z>q!)Uwe*^hWaoz>x%J%y60EjbaHHx*?2oj3tc~oetuN*1>~;y5!pN&JYNrr%Z@RI7
z-UEY>oyp;F6?L*$zuyf8#_q%H)%7wHm`#J6eW9in=;`?(&KY69LX2=endY8^3@X1A
zoyOrNvwI?xyB~ftl)6*~M9;Q}s#&m0v<xWRwWLtf&#RxzoGT@GfYe{f(2$SGbxNBQ
zzh>V*b^IIat_ZV5pD>n;&W?Q~J5_(ONYoy#mH5k!U&dXz+jTN{vv*8WDc$U(ba)Wv
zcdE?`V|nn55_*~qouA#lz+5lx|Fqk9m#g2?l1PkF%{b4%iaOVXnx!<2hAB+63vGC|
zzfJjV#zTJotUvE5wZ40Y-@78rvkg;um>^8^>lbrcir1Ic$@83w!2Nwo<Y4Om<yQv;
zMNUy~`;ugD?7`P(LFSC~Ha9n)o}MznKu6`{c^HYhIZ@(ACg`Q1InZY2j16g{3$+5M
zPmwPBc>KX!WCcLOuV8mSeHqXfUT%uy{$q%{p~!em0z|0*{{S}QMP>blPF1hox80AN
zC_uuzzj?-hQF?VHLn9pco;;%d@R<@xt-7s5k5JB6(XWZM(<dege~revg!1;pEm_sb
z%Xp9rhH$6--@fS~f>Y+^U~eGLPS1^D=Xn1LkKOA26>9z1P7s)*dzPK#!^Jm-G%}*U
zD)}hVN<b80!pz{7!i|FMl~US~g+W+jQdV!ifM8G8SJgF~p;JR#%HsmMGb$f}L3(>9
zW5z4Pr)3SWSX4;vR>n->+zPL%;!#vA8BOfy=x7)jDMcV?QDA&XSJ%2t8rT=7_65Fl
z+xN@_s=lD9!6W=e3H*W9ZaL}B&zEV%(a&*d<B12JgbGzwkW2e1C`iBFskt{XzcXO|
zJX%qvJ&Vw~0zK#$P1}6Zt7<Z7z}HT%2#);&2sTi*xdkJhi=$a|h3NXqV)VBK^B96S
z&YiYpZdzbap7>N~CFp)MHCO6;RcCbfA54F2N?0dqiB%R{dBmDq%*<RrFyKKsSjluA
zBM5%zl>@#9=bo_}MA*~b^^)p0g1{NyOp<h7S{$v|--4+AcERZbWWc5THD_z!%K2Bl
z@!hKgj$#}~hQ(jMq+5h17ZjKh=d@<%I5yZU%c{3?ZIoYDaLB@F&GDi%8`a-1g{~jQ
z!@92dUK8Kd8Fs1^ln*sT{Cal2q)lK+K^BCp;oCK?%UecYX3H7b8%!g$`N4_XykiA(
z?~gjI)u93{J}6vjPNXL^cC`1218Yisj;ej}PMFjaRhKR0tSv(9GWK&PfE=odjaUQm
z<>bTnqAhH04To7fN<j)uzD6}e<k?(;A2{%8>b1C)WA=`c1KSLJf0+gtbG{{kJf$2M
z4~V>aIXKvALp&;c+(3H*Al}uQ%%i5|*Ar@|W>s(#z-ZQn#>NMjnD?x7@Ze7(;^L@Q
zjgBywbFj?ya<5fHOl)x}LVdZx6V2&jtL*Z4(v0`UX<7$oTRUOfKM}xW01#7;ca4fo
zN|ds0w06JPs&ikkRrj&{E4x^L?$|9UjCx0)&-}=`59dB#NTj!?k6Rv<wQ+uAx*RR@
zPFc}8r490ms(zWcF_CP;tn~%U<Gh;5R4^xj=Vqb`VMG3o@37P3YUcbt;ERO3x)5a%
zU!7^9CAx#`+JS;vWKqqCQSDd6D7}jm^8)CGQe8ov*<Xm&;5rGndK|BP2>65t3bce#
zV3xEnT;cW`Ib|qqZEbz`lu?jVkH!l<;hiGyez&`5r+clW`0U0CHLZ2nA5w7k4lJhm
zkoFeTh(>tg@1afxW#LlF*Bk;9@HYI-qde%jGO;jBexom=^cc;iWi^kyFJ-P{4=LmY
z=}hD>UBNdl(yy}OTZ^)fRbVPzq|uF#%Ehg%LR|0CWB^xyivU$vYX9tVMLqrfgVLmO
zsqTY1ucUtV*x!iy)_CEIwf_nMxFg8k2Sg|w2-0tGH<_LIl{_?)hw=<&Bcf1<WFA;o
za9=<n1~C_|an3!lT!JtS2L_eHAk&3#^^>{}z@Lvj381LI`WkPAY0TTt0#h2m!hM}k
zbMPqW@8-lQ-(=zVAp-5zJJIJueRqNpcO)O@qtG1tPWNtSrRSYb+?DkG&&}<{r{KSb
zB%fC4A&ztF;EI{jW0RNg`J4Y%Y*kf8byqewwcC0S-+Jt~Z@>9yRzyIb!_K3o;)3^#
zFo=xUjj8n8PtELh!^VTUhdND<<J>Itg3O!87PDEL4$Jy%kCw;8_kYGEFP?E)Bj${W
zt3uAIU=TG5#)pwgH(SD{bXlU>$SE8bQ|{Qd9F58>qhT5+{tQ}lZnop(aE%_hQY;7E
zkIGG_Rf&HFJWk|_R41oZU)z1l?z_kCc)%5_r9Jp_S=8^TLQ`|W-uqiNX}{m3NzSDN
zZyG=CJ+LzxX2zqpIrQ0UwDVe{Lg|_b_G(mI+U+yiMVM?3%;LuM%xbGqUQStcjnRN@
z{>ljpzEiM8edHAFe<&Jdip&eE5tdV(KVZJpWVAhOUaTjCURM+Xh+I}O%B>kx=C|<<
zP7d<$vwQLAmtomcK{#7GUS+0Rci!L~S<~c6G0Uyyt<#;Da&6=hJjV5ZyY-(&>G<Ax
zN0NB!HdZ(06NOQ(XEDS@BM%#6Nmpll4PsDGVkB@h2iyPCA0|Q&&-hSB7Iqr$t$7Wi
zd><9Eee)|#jrrJI7rz!qdin;Rw3Uv$wqXC&fUgnOdP?g(Z0^q1J{`$X2MgOE<EeBC
z7=w#)|B=W)t1|AaC>|UB6(&;+V-ylnimB?F!uk8(Q0L;N8=1?UpVP6E^xin&J&P%v
zkqy#U7u&+7--H;jbY@yiyJgNtJN|y|enOscE53WJWIBn$uO&WesIJgW$Nc!+V0c=w
zwwNkLNypBEz>yvuyeN4W^9ED*lE;-qFsIo|tsfL=<nNe!^b6)H)G-?w!e8~0b~%x`
zlJwM@-789*|K3Yw8y4~UBvySUZ{wYwuG{mUEldZ2GwWAQb3f^Q^t_w?DkpQ$e3t9F
zT*}uB!fCazbA89ldqhCg&d?f5zbQ3`);LMlHHkB>Q*x>qx=-{T<>xNjY(~A?^VpK(
zJDHz5-2C-je*LQq%wSU5tqXX^ILs<I(csREiG}iPOFW`^47;rOYs>XF7Il)RSKD?r
z2D=-sy}lR+40g(5X*_>tt9800rUstzB{|<h5%FGbw2LRc<cT+93W9mKZq1$?`mC<&
zGtY&R<mOy$DgS*=Ye5V>>6#AzTVD5Ef)7DLr83DsV}(j}@cT2{w94y!>)i_zYR<Sk
z6}dYe9fBTtwEMJTkz4PpA9tg{YG9r*5qT?8qVa?~L!N@Qw0Oe5_dWCR<*rTFTvv%M
zAwq>R(u2RR4rk&ntzM=0ihM^(y=|+tTTo2TS0Y&N1|JGH1CEj@cI`+8AGy-B){t_M
zz_bWw*l@4IIi}--NzL*jlG1nIyGOnf;Hc)3!xBu$7Vy;KTJpUhOu+Jj?W|F-XE!&h
zt$?4>Kt}A&RIG)SZ9|gBwU#$vG<;eo+3@9Jr!<wRGwl6=+no{XPZnVh4s4SDLs7#+
zkSI}=q9>T}2J9=<ll#eT-@enE)fJ-TVYjw)SVF!Dzva^Aj$BoKgZX=ve9g^5=cv;Y
z88RzF9R9e-=cHzrK}X*4fvXbZv~JHCNOML=Ll3P-E8iNu<o2&B66W->e(EvEDvC+1
z#9>b4ePZSpD(Z=5o5DJC(_KJ3mx)uTMf*sbRm<D<p-=*zKxDQ}my+WEXgOZv!dgx1
zLRdax(<Pj5tY)glcHG??ccY=3Ah*-5VJ;;f@?YzUqGXFKlKmJ~$Dd06?a^pR4gSYZ
zj1U7AVB12?(WMtQ($<-nK={mW>^T|v@r-)wupfCHe9q_)T&hdS9X;VI1)|nD_eq|{
znd!TF4>PsV2!-!Btnc|onw)E2QK#NAD3?%m9lkIU|5GhAPUyG5Sq=ZN3{gHe7p|j}
zZ&V#_KkxG&*2E#|Uz>vFrw6|^YDQg2em5t}_fbr(&AEyyAkF4^P&6C}e`X2^4yH+G
znit#?-|(E<!ph8d2ww4gYF{$$MIy;>x0{NG^1WHclhkP4fuz*`YI<(t0X$G|G_$FY
zNA&tw3md78t}SS2Cc0)K_5H?6Qgf<&FZ#$k?!n_hoG#!MU7pN-&go<CBc>eIb*jfQ
zMd>4Jk~TfEbM1amXrg}$cG9D>^@JiO#jVxHOYT1kZgq_{M(HRxzQ!cFSIzm({^fI&
zO$pli^+gqPqTPwrK(V>w`iao=*NXj=Q)nl?ogu^p>*kNx{Zi^NO?T+@dMoL3Vz8s`
z^Eo+>e?EZ|Hlia|Jg6fmjrh9hYuC?m4gWyQAKeUN%#k^Pj@dFakBVM431%(l?|J0o
zeSDCk<T=`U-|H`$Z7Or?0ZK!Mkh^#Q9P#jRddKrVsA$2<*V7Ik(pck9oH~JhBwi#R
zqI~X=J7;Oo^Vo(b$hL_EksSYc6>mKQFXp$J+sq?f_l57aEzQ*7M53A9b{7&~6C@A=
zs3!k;7I5`mE4a#yok*WByWWFysx#3nsCE4+TYGwUBqwfGt8X4IlW!l?C!b^T(gn8I
z!|jt=)9`%^Wom#QOO7Y#Wc0Ohu|NU}CT<s2(Ix4Pv+r8P2Ng%;M|7%MB7#HsYT`7p
zEHs#NviIrN)^W|%AsSxR_Z5o7C~_nnLY8t|Q>w2cxn#Hob&3w`7BIhh&NXd6UVSo`
zgLjcI+$t$$B2)$cH1C&kyr|D%V{N1K7UI#xq4p~9R6o~yrZgnAx|(2N&(6KzDRVvR
z#gC=`(!<GTAxilEwDLt>!>hbxx%pv9;y;oWV|IU0CVTRU5qju9e<Z{_qW&;^s^j{S
zHN3nOd6Kr}F=?J%)1mwubk~Y1;O$*#w0?KIzKsZmllN5%0X@6ZWf{|-v%R+_ShI<n
z4YgM4sDVo|{{-{u(fmUea=$g7Zhil?6m9LuYeg_8QE)L(YuWX&gwcw@xJVkFYwG+;
zyje#O)sAE9*RCAZcg*RkD0J-cTn$2bvI`~s@6L9rOsLyl$(73MW3L7}UcA4B0+T5?
z2j}ajKagKMb*bG$H|*}Xo#A7I_8@!XXN9sfT)O?N6ZdMA&RDcK;$Qs>-n7KCGUVm|
zIXzRXZ_91j5paKRK+B;{zqx#0$&ao{_fddnT>~ePUw0sf`~$DQwp2oJ3t^(n9^jOX
z`dzHX(|0YrxbLR_X`UM)xwBG>EA|V;1IO8HhQ>dCJgkA_D{HnE)_K{U_qbuJYb?5*
zi-Wnc9bqwNoVw@Cqe2tHR0^RNQ>{36!>nz1-ygWcLHbUl1mEvN)?Ga}pA~zj0uhA*
zmJ+k#zgYi$hq3ZAKi9VOyox>5vgG`)mS>7y<rMre`NOllMx26ovXE;P+mq)O^ww|1
z`+*_@!nE~7Hf<@AugpyI`VqW&dA9>m&oG*v#9Ic*32)g2uY1=QUgcRE7yPpzLOjhe
z8zJr03%{wx;O2EH%J1!EkCi)|{0{{;fPmHep{#Gkq|}!W<W|v?6#2Q>&o)1PfIGdM
zNg|E*9!COA6FkRq!(qF8S6bc8lSwJ$3KaWJXu9((7cW9q$^DFH5CtXAUy7ZbKK=DP
ztHql`QSyn#$>-&Tw$~YcMA*8w(YJs6?@5+Rb*;&a9_DJl;nsSCuKC~87a5&!){{Ve
z!o?pKJ+wE}-LLO_hc`{uBpMWJN&ak0moN-5LHU&V+VoXc!ECFlL6^e(#GC&%xc?03
z{~uFd9aYu#g?s4kZYk;RmTr&^=`QI;k?xQZknT8icb7B>0!j!+IwYh7^)2r2jq%?7
z!|S+rjI;OJYpprI`OR<6IS8+{E*|Vfu{SB5zkiXP)!WssN%%;*2HjyL=p)&8laQ*R
z;>Q%a)BI8pwdSM<+y$mn1$)wLyW4w8SaP1B7MI<|9~)*B+>zE2w`9fRKaXojrx+pc
z<x_haiGM1O$C~WkhtFZgW=y?fOKl>A{W5Ot`F;RUL-A0hi)6JH^oLmuICKuU-h2^Y
zYX`U<nqOMB&^;f(8Wv;8c?Uo6g->2M*9f^+pONcU&uaDyp>DkEIlIn6$=dFn=?R&?
zk1mRQXlAZn)YeD}u3K_^xJrv#R?97ih@E3GY)l(m5$LDwAneKHca@@8o0|<6J#NnL
zp6p~ENt2EW)=#rKV{zIx*Ee0;{LMUnZd|ux(A;Gm6Op#u^r*S9P>pKz|H_;sYbadd
z8qnYya!}^vjfdsQq`?sWy!uouA6qZi{=J)^Bnt``4^_KUejJ#kob(OP)Td8UMU{Wk
zkvU8XKI^7aQKqHL3O7T{4OTMyi5^#-&cnB?aZOxA4}q6e0;Kg&3O?UpisAbn@g@mx
zaw6Y+wy`MKWO?!JO{`2-yT!KwC$*JIJ%8yF^*@$DtSZo%X+!0XnGFS_nmuH+8sga~
zSil5(Rb;z#Jep}nP$}dYOE2NWqDqmTm%jr<Ea-aJx2S?mavDRZUFYoZYnpb#Yx}rD
zJulDUE*K2Vzh1)caM1O4?I0b$S`F<oGW~Q*ZAVQYjXSdZW8)LW@gEaI_ZDfjh<Z3a
zSNuSutyf;~&!MoB^mv6tk`d>vlbQXOL%16BJ7EhvBLvHK6v1FPF{3aiE#X2ia=LEL
z#nmRJ9lM7QZRqk)isTz$ABOZQdWLXtkA6Y8C2281Trk?vMBbe18hlB-o6iY8Sk-ES
zWTRq4aps3nyK$5qlOdGf?J`-yncRQJXFb($Hj#4U{!*faIhe7ZUVnJJ`_P(3H6|X|
z{2eFD%p{z~k2Uki^%Or&qbMJ^(u>o*<~R?^@lWA}BqwUt*kND5mz3jo`U}2fXSWdj
z0YxoRTCU!6`_eP(=?8?6rDCVYw<cMp0>jETPMb;my4f`cxI3{$RN;iMr;Pz$3;3FH
zfssW3d|0ZZfXPqZWH&*bR5{+tm?>y02v7r-WF<_4>PV=g{@ZWga8f^#M3XNMM_bKt
zZCI>CO!kezU-Oc}R7!Rpu#ZV2ZU(6<d5!V{O%s2TM*)ZT;{(OTzNM`>=gyG~JQRsf
zbJ{HNkaBWb32p$`je)CyLSMM)?C=Z)jJ<f8y)nD`Ckv@NtzxQFyB5Xu5ASR#pL&s)
zI*<eMy<D$-lBb}(H#y+s>77!q6n%T&cdc7apKc5<0NAqIO8ll>FMxk`U=`w>_$z9`
zYW!qoQvHOLD4NL)ugMU=RbB(aqgE%iV+t(DovU-4RkOr@J1N6b$7?x*M@v8IX^?4^
z8Lt{ngOBo_wb8}=IcuVR3%2_(>R8;!seSzWbTf34MD*m1nw~lN?$25;9l?oaJ3C@o
z<vkJOuQ!|Kcx!I)-(hQ&+uwnk2`JvJEr=G3(Siz#bJ<nwz1EbKj)a{Mf>_2k#sa^~
zU$e`K5|WUBq44d6pDuaromR_^)=vHibI0M5aJE4#N5$F|W-Jr|T#L!eQueIZzTVik
zGW+gsb|;H(vjGx|!MT$8NxF+C3WCWizfw4e-8$j0Ny^=Izl^?<iWLJqQIoyibGAMr
zrdcV84h|E3ndH?!(f^pnANf4Vu2um+{D^>3u`JM0&%G~_K=y?P)s((h%eiW5U2Lbk
z?e78gE<)Ner{<)4gv#irQxXi{a-NNiUQA=PGa@udR&(U*pD#?Plq_0b0F<vfvP=i=
z1Ftn;35es920s5*;5#M$LitJF*NEeB!-sTBK#k|@g#yb{tPb7FGBd{TMdduNeca$K
z%4z5?JI=2mA;4Wt33vqCI}=&tM00<U6>x#o=0zEusnCJ~dF&BF$YxAJ5ickhHEt3L
z&mJY;5J4<53nbLbw(XZ@Jo~wY?nD%A$}*}3)7d$C0nS?!%mi;S-ue4>@!%?F(e!E}
z6Z(4{*NFNY>=LnP=CKR$<j!K}hb74c4LfXfKNA?i5MfX~Ya;O*raI#{fPPp*`rG?B
z<2fD55|lNrfs441d-p59_7dhTK>0EGCh1~W{q-Nq)~mayM(qZ33Mud8%TVC?#Tz}p
zqXLBbFq&fL)m}C*OWI0sbjsT9`~KpfH5ySL!{)-3Hb|i86)C1D7T-<9h9e}TJ5YgJ
z{&QWr73EA_h#Axh+etFRAU2Wda?oRdK4B9&8pLbkch8fDgm>3ZL~u0f(3<p`3Ki@h
zo2Eb0L~_QoVgWG+@dqYbTBxo_{B@;6eS^QBXmjja?Rq8u0|6zLnz8aUq-j{%9(A2~
z)=Z1vvpR8x24hmB3<Vcq+72X5WnE$!h<jThy4WnS?5GGABPZ_9!m|@<I2xfmt98o8
z3MaV=3vd_wNUd8|&;JNoGVWLlwTBv??0z)xQAncI(F%KJOox;FP_;Ri)MO}8{C1%}
zkp^JfE#ANyS4SFV{>Ge|%fx1SfMq*g^=vllGsC~A*Y9(nISDn6$LfD>%WECW27nv!
z7!8V-Mf24G@nNFx;G{1G<cH%)dkc<CN3v%db43j?h5W+vjX%Q0g+nn?X-LT#(I~9;
z^}%ZevBj*GyWcwyX@jmm)x(ZQ-&Zk9<8ovegdtBRXEYgV#u8)npUlZ=7}XAwX2e15
z@h6?E3O2dOjRm6LI+h84G_4~Y_n<6~`+y~Nregnr5WLOXsn%!y`Qvd2VH-oI8*A1c
z3B)<;xB;4OzBf*v@-bHf3N;gGzVeDU5ubhv867JLN>3J7J(pn@?CuHMO$p_hkLxwS
za5_5cVh)nWl~c8wjH%BZV;H-mZOq_e7c@Il^ckr|E3zW!M(d|~>1u^@xnwPuJFobV
zmiD*$0?qP#$r-dRm;HdXf(zVrjI{_6unK5-3XHb`EREa#l9SFH0KdY@+a{Y4)%7Vp
zoDpb$t~tqAuo_O47>fS5+ubT^WE^`CCKiO+XMpiHu+R+CwjRLO!yZciw8xIQN8xB5
z&2>6McJ^<Xu}$RT%_wtjR^|<S8IJg(dPnu5>9rkF5clP(-Q#-iw@h`CztmU4-ZvS@
ziXjh9=}jg4vF(2u)L#<Rv5v4C<D+;5u$#jB3XCZ3v7N^NVH9~iyNJL;A}pnV{7id#
zjZ*?fq2+hlJqAfdCq%%2BlsmhDg>L9xhI}(jnPoah-*1FT3%4w7V$OOBLW%_upE{v
zomQhAXIhfLX`!VpCz;>c^CWBX`fhp`Ln1St14nH8EOc3>VfDn&N9o{QS8q;}A`!$U
z<BP?^8XZLDvuHfyPIRzmy;5hcAFcSDb?5=z8@B?7HP3CCo3e}@C0`K}e%5u4I=S_>
z{i{Hp^j<pDoxp9$_Aav}MdIgztFs=I)a1`>D)xT96hyyXa`uQ`z2Pa?2LC<R#L=)N
zdc&Lu;M53IH^Wo$V5tdW>yeDmzEfk=SDGZn9bYlu`H^5+q(4F|<h2F;8!K2BH9I>c
zYAeZuv{egtj?R23Q*!l^z^2YS>Sm3^JXm(m+j9e>@Mbh4COPlXY%|zm(RI&*08zSy
z!K}l&?9m^E@*7XWA!QtH<M>gs?4*SL?R6|N#6>)%-r*%W1cooOUA6M8w*&dx2!$hK
z>G5yiB=`%?$$=$|JU8&<gjlHU<BnqDzwE~gw$k*a?*ad_ybTWZ!qbHmeaW_SY$Tf5
zSlEVe#o~_#xZZ#MM2NM8J(gTswQ#yl!)U?5arACkxySh1vbT-=t<@>xjrwD7j%Tu7
z&I>=x7%a#f0tT58d$>k8+D3%)1J}c<Af~lw^ne~zLB&!abx}3%533x3EHKL!O{)#k
zgk09$%-xL$14YxkHt9<Pg*w*4)`rb9W=tbzCq?Wdzzo-jvZp_1;_GPv=o@7YgRiYL
zBPM)B{X=^_)no6XDsW%M>{I15sWk6&J3d=ZoAyRfL-~;ORx^s%tp#f9U;cd+{4Cya
zja$pb!u*{$4&(CV%o)HEV=)Bcxz{du>NvpK474?m0?2~5Q>M6rN@I6IV^#2FK1o_F
z^Y+Q%zjBSpgc8e&G7Gi;^I%44C8qd_*j1vK4!adJdVQxi9ks!BV`l2mM?$^XAQk!y
z93Ogt>n-HDfTPw9_1vG6O@^eT6frNkBqp8M?;f&Xp^K1to+Sbg%lw8_f4eoj%I052
zUi>7_p-m3-AF0754-rs|#Q9ozhg(U?2LIZZ8k&q+Hu5TOn)y-B#8z06HeEz!f4|p9
z{ahuyc!i4StT;^Kx})svvyk6=LG{s?cGMWsPlje|q>C)F-SzFHWx|qm>tBCK&nYU3
z<Z3;Wyxt)*-+RqTD-N$k^JTWLB!l^ZPsrnzA;8L1UCBbgYg+I-&4uhB`4>z`w@#dv
zp<`Gk^uys>J=><q*;Dr6MS@Nu8Lw{RNPx}_I8`K!{jL+-S7`)2R_&)@&%qh_bYOaH
ze@m4(=SXrAYF7Kkvia&#;4_}z4Jyhw+Lh(!xN0I8K(y$23Xy368NlookydDXbm-+)
zHXd<{eUs<sU}*R#!ZanKoAVm=%2(b1>DC*KMNgbnl2kPD^4;ke?4H~BB<6<indG!8
zkA`Phf7#nYE3b#OFqHttol>(Qs%5TsQZwQjAY3|5{0S>ar`c+0XdWj0WVOBDo87QV
z9>)zqz2%u;8_hg5n6(O^@Fsm8NTRah#8?_PHb#InU9>3o8KBi{uNFDxDXe3{Qo~{d
z2y`Z?KUq2P{N(a`fz{{VfSw?_b!=W)zHzg@b5%}E10E{ffUYm+Hn~UQzRzZ_5pb_2
zI1Ii)O2H;|^OHP1I@}=Nz+BC1dBw8pxnXl*=OeF8?1EVj^*|eHy|4d4X=hULQnLlk
z`-wc*Qp^bIjwz2s)aM(s+xMu^y(`4F<u67U03>tzit+d3a@l$Z^QTaQuPq->a+RI7
z?aBlXP|D|m4uCc(+__Np)9{OlDkt{(lP;)Ah!0*yv!!k2ZQ0rSKcDbZ<5qNn5sEM7
zq-#~LzM>3%E0mWmL+d7kVxx>94@~LBd`qjQ1kP|Qb|vW3Wpu~o`vIph2K$VX$;m<4
zdg(d+$zrsS6KMgELio(&ys;o|=pz0VC5RhEOjTBK+#6eqUFb~sRYaJIbcFKE=|=Dw
zhnx8lOkj@(7&8;iN6G8L$GdIoW~wnI^^<?O>@TFt7AzAqN`?;ni}pY0{r&8yOG?JH
zdZCno#;6eY@GYP&W-`JcmYA)f@9%GCIYmX;`W1Q}9y~BvL@&X#!2(V=33{tpzhXXG
z(#!uBPiF$*>m6HCBOIdF!u3w7*@s&qNI(WHTaazb>W@DgU-UZB%q|yFKXP!Ds#bJo
zjmv=8Rl;MNnOkw@Y!Q_LM8zsm{^VSo?8bil$%nCw*9NsBsVL3M9_A#^NVD6p-NQ%6
zU|Rr9ZG}6K8<!3kx4Dqn&F01ewGjcBVD|z{CE|W_=T1n-{BHqFTB8#ZGWeUBUw0zE
zX!2ekXLB)Mf_&e>7YVRW+y_esTVKq1>UzG=;oxVS1yVL%d(&3W2m;5sz_IwvQmw3U
zwnE;MXfy8@)s-+Xcy)ez-f!fB-~3CK0ACLvnzK3W7Q+MT!*F++l|X18RSGFA`UMUN
zI3x|HnBSr-Bm6h)1Awhl1i7+;;NL7@bW-Ty=ZX?AUk6NV5yV7B0GZT^JMttLE+r-V
zKMZuMTYgh#UR5Xeu0nLyb5c?$`$x#&3<>Vh1-mA6rUKof_3DX!%YyigcC=a%{Fu1I
z9i^^LWQxd$;em5Kz~`)y%k}uB8t?#^3eh)IAo9Le+saR#O1||<GW{~{jTWj=JCq&9
znmY~kCN0tSAmtKltQW5|`KtpJzK>eVc28xc{Fl#eV>cR8UNnlv-n^DjTFQV)#w!=B
zQKoGP+ApuRI%n=2S65f#5)nnl#Gocn2w{U%a5s5$&?gr$dd!Q28%U2y>-6fo5pS-k
z6spSO&*WdVL}qPTElWs+Sj|MHT8;A)5BwR6RccS@o|uc0m!@kCRqHzSqcf)wlOwDO
zKhu{c8?V)9tJU;Jg_VV0i)#&-sFTv{MFLaq#36Vu7S-X|(&08(Tuis>(uPb{Sy=ci
zS3F>G+Zl8fj}ExnEArZ(W#-}<AE$Yj(D(LXXSLB96~}Mg+J-mVf;am|0UIkKy-@rp
zeEjaD5UQ&LM@+e|neW~MkzTetyP|MgFwbUO<8vrgjwaee591e29@ncXFbuT@_0n6~
zq@jDb1F(ayG%%_Twy7R18x7BwY0`e25_r=ZoKPx1^pgKW;eZpR!7B1v#1&<_?p)lr
z{ybsM<A0h53EAw&8V+SaAs<Od!WjAuyT7}7DVX2OIJTYW#AZ&?a>@6swF8+VX>Y;{
ziHm`D9l@-Q9Pl2E`zEx33T(-`6pOUDQfIRRzpXnvI$v+>RI$C)a2@IIC1z^ijFf!)
zyHK-0@^bF&!;O42HWj!1EM?EbSvR&hpYs>?o<BF=u=36OgC#JLhl#}WAq`gpUv!)x
zlwSj`RvRqCtxo!6utUhVUBz!)HcCnTiqmCVm9aEAl52kCO^ECWyM8hvf)ITrb82+m
zFdn^aSzSW)-1V^gCz!h%60lscd%A&{Y(4W)An{I}i|UI=CtlIj0$4uy3fcuwA4y76
zoEgCZ`7#ClY`m?<CgNH`VxRUe(D&#>#IB;4dLKNG<!idpADr~=TxX~W71)HjDJCO-
zCR{5v&1>c)Vfbuhh%yNX2pHJ(&t!wuf^OtR`p}dD^Zr9FDJh!4!4o2H&|!xds1HWL
z$Vwt>vw&S9Ff>Q!Z)b5aJRTk%sh|rfkX>?}ey8{Z_|v76O$4Dl@{}`uFxryPxE98{
zJ!YN;_rucVmNbF<tG-8pGE@_OVqk)Eo0P9BZJ4w>Z(NM#HJrs*IDJsDW<tSmM@Bq0
zgn1}0ww5Q*odPo8ta`*w1_li-XPIB6HW;#lZ;Ei0yRI~U?|_<@7Bw$YHMcBG^ONJZ
z)KXkji9}a4J$GeM_k$n|uSR87J~jxGnr3-(JD9F%s?p<yI=6bsV*b6f`?APc^D^b!
zcwYeytY!g=Uh&4@q=3q$(Q>fnotA4`iO+4$yrkhvUxVMdN_vG9vEb8qi&BBXonZWg
zpylJ;1q9N)@$~oYSf+f3B}o@SiX=*rAwqagPEL0Z56AN!eQ56vNu_C(EjXM!eJ{N_
z<9<4}U#)u7Awsw-Wx209+Tx)oD6Kf!31aC+Q9Dk2Ac8#D5XCh{`GT?hoXt0vXwyqg
zhP1_)W7C9Jck^%VyPr@`xPJ0~I2>sI-z7-hxBix%chJ~E1F;w>cNFGrwOq4sks;M*
z+y{AgnH~ww*&^m6^4(}|Hv^l@Wh;B9>>m7c8Dt;SsQ5k9CKcxtV=I|%i*Xj7TK#xQ
zp5Uh>rf+FFo#asa;0>F{(=F&GUipCy;j^C|S?}~}bl;ZA750Enmi*0J4TbW&{p}4I
z0E)b51G516q<8yyehtBY0zubwF!~IkV?RIWeSUrt3eB5y<3H$XU{N1&9$I~KrBj7J
z>LjH)@rj%8A5>dZKp;kCPtkmo@o147#V%2-cJpJ1;X8S+1prq;x&v?fIL^0N>(K2(
zR|eZ>g*jVlK45_pL*nDFRK@{Yv0bf4-(91BR@RG~1pD#)Mjf*o86fset7Xe$$2Qa9
znH_KJDz3~9-WH`$pA}QTZP1>7jKZxaG$I0#Qq&vu_)BdX#TFkg@B5rr?VcqqErg)q
z@QbIr4ivV!y1Evi%k#l%Bdql|5h2g3Q{neo=#YcckzUiw7L|kxYw{Fe>rmV3@HWqv
z*tX;!y|nMnHy6zUGKzk|(X8i7P^171t)Tcee_SuXNcN|EuYMw2G1gpQ)Myw#i}lr^
z4Co_?h%$oCM$j%yWGJ)#w?$hw75YF_B9G1v@!yGM0v{1O?NfwA(9JU*9<9x`fGaz8
z!-f}s@8A7<D4@*A%#2=!8k9J%)UAB4%=2Qepj3#b+C=6sMghgUWn_B2)~hmVT{(c-
zO=1SQR^X+D>&}M#Xnn=Fatc&F;7Zk1QMijP*J51>1M<a{!FN+j=&tV{jWy+%(i+Pr
zg>gKISN9;4DQQ@YfOSsxsv(RzKLX6Ql$G(Cs`zmo_tZXQdDhy^3GK@78D}0qG<60y
z6=-WvYOTJPENV6=5z<rIE^d)_-Yl-;BDCS7_=ev`n`}%fNgg*SZt~$?c>0RORjaxC
zEfi*EnLfB#=H0Gd`90QkyaQ;L0xLYI@N*UbbTYL&?!5K*WTQz2UppO^4w%~f9*0T2
zK8p@uS#H*Ge>+)C8zR<tYmD)b#!4&q8N_7SjY8^oFB{&dLB9KIAOYD0AdL=ii%pKD
zQeK6sln|Y9l8;0Ou#BAwv%Q)4%@f$t7SoL9<^)|Ykq1Cmcx=H%#w}c<Z_`b(mOa0e
zce_8Kk0l94Zu&f(m8M%q*}|0N;8hdZ;Fb7IJUmp9zx#wK10_iQL1t#c`&2pOX1@gR
z_2Ry9Ms>lj)0-`|uX=yM%}!QNnH>`DIpQHouTQZ5ye)dXtF;}b8pBK=8cFjeI7Y4V
zfxWaNn{=W~{tg!cw<B(R_^~d+W*BTM{I0-Kv=1X-2NHx03=<d0F+ikm*M?R}piy%P
z64iK-hE{C59e^JP40VwX6ePkM8=!(lyL%6Rtv)#aDDV0U-O#z=O%8uLkENzLqGE+x
z(@7L-Wt&xiVB|KUnnT6B@RUD>2%W##xZc8x-SHbbd}Jjw$R>orOI*j`-7@KE{13qI
zfOmuxdUcRABZ4(z+oD@lh?S%}v|nAKFr_S@_RH1``o&-B^EZA=GscAGDVEm5;q_tV
zowRnb9lJiElio$z5d=7D&Ptwd?-_2sh!(ri|1N*C;T?nJi2|v>I$6XLy|y$Z1Hl`8
zl1&C2L^L{x4+adDmac7-{!9^l$-g5tX(AATx-VB}lkptNt}-cf{&RXD+m|o~T&tXH
z6!h3NqPh8&|B3NHZt>X^TW<G(A*L|o8fJ4sln6=K7|V2!k5vGXK<2^FO&Rij(2CZ!
zOEkh?rrsyl13skGdt0N@xm4&g6I&Ht;&rz+Lnz}Lcar+Ix|=tF6Ci2Ih#J<Ba_``o
zXF42{n1ofwC{>e(dBKqJPh;1hxIw$~k*PI8skckTJD#xae%zDQqD7cf9X}Hrt;Q~F
z*)B8hP2RP+GCUjYP!5@&VS;sM&wlzcUBx<TYn&`e<R3j!4&iJj${d@ybLm0ffQJ#w
z0>1z4oI;teWQGR5{J7_&R*}Wu!{hQagT!WVdh#T*4L-TV;M{sd_IG0dsmr(*TOKvN
zhX;ssp69YuhJA91j*drO2zCiy7(-`gslzDw!ED<JmOL;sdLjS)MIehmbqqjD^Rjbq
zG=bo1X9w+Ok^bu(L=4A{M&Hy(Q{?%;FjDPf<WIcApaDFPvl04UBfPT+j-;A!Dq}i|
zSY!Y%mI5Hllj6$cJ`7az8hLaTE;{D^qSZ5&SY0IrzbTVVMosl&oP~vgYHXrRB1%ZF
zow=xnsrE=;rt3_MK*I+fnoFi=0*Ks?Xycv{QfD16eFM15D#-zIbQKlg`|QKtO(~88
zlsI??Rk=Q*%)v@!IJNXQrt>A&Q@<;AUpE(z@g-*hJrig(+OHcd?)t46+q!gllbz(|
zY^U`%umm8X{#GZE*br~%FSc#UfRhtAWdwklgM)lU3gU)o#CTPHjc(vGji%6|ZdpAM
zrv0)(K)6#Q*!>81N{e3O=XFdjIKKYKdF2m+7t|0Pk$+toA6JuYGT8+4q5}`{ez5#f
zXN+f?qoTcDqMl_(nBxvRqdY@OLhzhQtbFOZLdOY*Z#Wb2`95skgR>!`1DiIHz{<mN
zQV_f1ip{cZZM$gY+0e?e<@DMRE0FwkbOWW!&)NU&$RgVHBK`a@lAst@dzcC8xX0yD
zKLVL;+`|#>4qTpbB(MsLM0S+$Avy8LwIfbS8i|+cVjdSJ9|pd5`LNY|i6ZE()n{vS
z-3S!v?kfVJdl4Y@k`TTkHpwUC4x;N5YlJieB0{`0wi{ivA|eArVU+J0Qp+|QUiywD
zfRAeNdC<%rYTd|BC_!n^{xL`IYZ~GgX$6`OAlaByG<5xsoBlJ>(pya%1HR#y_#aJ(
zUkateUurKl=$il;zjQdV>1>@FbLoj*L^2#QRgg%%P38c;h8>j39wQ>vI!Iw%tLkTb
z%C2Z&sE|Q`(Z`<C$9N=ZT*Se>?u-7Z<gHhdo0e+UffYM)Yz43#taki7xlqOpcQ#tI
zMwdwo0hUb02LF7&tb1lo&Zr!UZ%!eVu!PljL=+>O4;lJ7Ddx0UQ?2&t_;W=1gHHQT
z-+4*3bI=rD(*tv>mY!r}{qHx@fNw*}|9Jm9L6yVbDl#7ZBSls$)m9Wx*_Cl^GrsVm
z2&f9}Fy*2)CV3*qBkJqytpAyYBY3U`c~;6-p`L?GLP8RdGh-*~>B;;1=JXrCqCbMW
zLW_<AcnO?xLNponCDr-^BP2jh0(yb@!(Twgvs~0EIIbtn%udm$eR||KH*J?PFxbtA
z29|6DG|dyt1FEg!j!8r*zf5EvkP&|pxips&k9$t-l0}lxT_5FpThXziHHH}vI5bK_
zm(BLvq#>DEgO`_=VVRjE{`t}1pT}nK*Rb&Li+Ncb%Y|Zj^|v)E9NGxQHkcK1Dn&1!
zC8JqjH0lJ*8ZhjApwN2VCS9_FTYKJjIJykDDfi_j4#1WIK?@*D<kRcnAl)r1EOP7w
zd(8F~Ut@c_0*DmS_1U=aFfYAB+o8n1?!pF2iH7Q<jJ6G6@*oZ*CMjtQ%;41A9hj2C
zH(ZQXiA|^5#@WioRVCsxttFE=Nmwlbg41&0ikD4EAQ;!cIs>a$f8o|)CFBGL5sXK3
zdOeJ(7mce~O0@D_&K2o*t4D6$5#dp+&-mpJJm(~UAD%6)ge0Vr=T1OhPJ4S$MrT2U
zC?}X@owNk-iyt|+h3GkdGzB(nzPVEG=<F<NXu$o}?lum#NXxKN94*%&X4Fp6H~ZW&
z-ZPa^g~O$0z?0ff!KKD+%CMDrJf=()I?C*ZQQlby-iu@grR2C;Y^y$az%rpl<q@%@
zg^9x=l~|dDR*zRh%+Wg;ub)dhKAnRqCLY#=sIRV$b=LncI3gm#Vju*Ll-mL#BP)9`
zfPhn29`!ekT-Mi-!^M|6uogX(8tbRctm4sN9NJ4_4It{`=b<0FtWDJ?16S!V?Dxzq
zO${lR+bjM+o-0FOeqy5T?#CyS`&p$<xD}4_tOP1lKS=JQLoM3bC}LGIFb~IG#R7!{
z(r#{=aPgBF2)tRdZ?v5ve!Sl=U}j^J1yk{!X2}4NITENMGtr@f`KTK=o{v)=I$M0$
zo+Z(!nby?^;F#7IYjMK1luVkDh1-@zgVa)_48{@h8BVFKUA7e#&c@Z#gVVuDRdx92
z0;bpsb`NKv(inh5JSm5d9<HKNb`>GhP!(smJUq0jgFUp>Y83tPd>DsR#FGI8klTlc
zv7pk&@@&1+u<uR4e=lJd`|Km#+cn#M5FLT13uB{R1M9RHO~1GT5s+=Ljrj>(>Tv~#
zqtCGSNfjpd8Gr8--Jq7-E{DpfENL`Np;o3P%SV)LlUq!t+P_rT(M-zRqLJ514%T^s
zZ~5}&%kX^!1cWNNRVB~K$i8xJH`{(z$R(A^`)IR97AkknT!<xE-H!^QqIpB}myS=)
z(|D8z36MXC3oVtiuQoV1j6EYvp0mG9N@1lI*=>!x!h!>Kn~3$ivUOF<(6%dm_&Miy
zu=xd&Z_oE~+=d)#oP+CXYe&Di^(O*a!Q^Ie1NBEdJX?$<Dmp}@c)%*-&up@FEZt$!
z#D+WqO}KSGfpTSJVDo>^^zc}pUN$;7_Z??^(b+OSA+EfP^r1Bjq<w)sIDccR8b{ya
zMAYLwWL;K6=HX%TMQDG&;2o$e@O>sOP8p7ZGxmKj9E9wld18J$;3B$JTlds`g5o0T
zH`v1vKQy~&yJjyq=IVY(0J=Bwl=66*5oV?`)&Ed{zsLOeCG4H=KVS!;3cuv!<A`Ev
zw0Gn1#yw(g2zCr*3*ZI}OzcO$(k%FMs#<`erS0i#zAP{=86O}2{rmSJIFfe|``KJ+
zFbwVE5ox`%P3SH|cm@YX%~Wz)lMY^jOBNvkOE7mbl{u~3L&r749uENExRY{nOX{Nc
zKT552&h!%}EFvG2;N$Z=Qdwy_6YTsU=RSCW^@i$KU_Tj37Or?mF|&BA6?7=4uu$f%
zCfM9ekX0wuB1NVwGQ{RA1fD;C^*9g}PcxnA*N+s_oELo^lo5dWbZ%f1x?;g*P8ON2
zzErfP1<k6?mhD$@Yzwlz5yDmb252-q;Th_TL(jL1k-k*xLCL9tKz)YU$(b872q~7b
zBFkm%$!h2t54i^hO<2*o^Aue>&j(R0PwHPxe?;Pu%S$&(yGirilz&lGqx2+R2H{HB
zz$BD=$Znsi4jt!WQMPsmM7b&Ej&d=XupGNXyRX^q#hCh^Js04e0oiaJ3}ox#b3*>u
zxX4ljlY|Cn%|#%Wh$(vWPQFoCadP3iX6&Ug2D{+)Kf3vF+6GpnM&ch;JzUBbNIW;P
zPn10wytoNaLN<I2AY_hVN;Hnd<&t;`{*APcO)Nz4G_;Y~Kng$2eL=#|x7+k@JBZ;K
z7#J*0zqU3l902lfq4t$f&8zk^70RDJ@{WnmKEA;et!R`lX1???NXn4QiZ(;YQ@HOJ
zG$+(#$NRFnocP~$EYbHs#S3yY3RA?_)V?0VvrHs3%s1Xf?yXb_;N}M>1&VT<ZJ$4Q
zvevu+ibC!?w}+#LEx5lIMN<#O5-@Q-K<e!$8A5mWR#~NoY#NIeZIB>$-7NNbaihG&
zQuI?uOK9w6nEGW4VNO-vhowSK@T7w`BCzwxHLlqzcqe;O(kB|S)#%>Tp<m)##X;5L
zb`>D!xIed4ou?bVp3J|OpR@Havi}K~jq{ru*Yh6WAQu-GIqg@35X+W{A+vmji~=&b
z3ZsLc^^6EIW60Reg?9gB*9hv8f^S^N{qXX4Vb|f3yI1Fl&(nb&L1GxXpMj?5S=ly}
z9t%%VE*U%~HD37$-6XkxhOlCPzwi1<u(R079=hCYuL+1Wg8TdXOE2(;|8^wFJk+3m
zO0wfPZ|no=9I(5{UY(lpv<;K;jbk1m6`LM=HM$8GmM76q%k&;oOngscptmQSkTRmf
zBP*_4OC3ox$wS_%BACHxhss1`;1{mpdX_n7i&g`uTQG5uBqb%q;d43G*A~a{i3uez
ziV7A@6YK!YfGbN{L_%0jmt0wv$ECOJxWMypJu|kRiV8DmM`?Qk?W2qfe@Pq&2Ru8=
zR`@Pqi9u8pUaCS<qY3$yV>S&TT}ayU3EFg!J5~58Wy<Z`sp@|%j-Qb~efso7*J<R7
zqd^Ylix8qP$z)XTDWoH{2*orabXr&6?VgpI7_7zoQHGz&p*>>QW*S}6C7Jy89O;)0
zH3G1++mzvhn!!Di&KP52F)8wR^v6qC)a);Co$d2ZRD<UpS<5Tw$;WMlR)LD%ayZHo
zJT8t0jPf#Uw!@;MqvO0itz%=rVYes7(kmXgoEM8HxEaT{O7*|Ais1%FhQqEw@Z_)D
zrmyo)lI-ypPdA0~+xOL4Q)7WyRy-A<p~abI{KXxnFMW^!oyYtX*VS0n{c3hRB~{h%
zQJH^6B-(5k>_}|pDb)&g4W+{R)?L47ZP3_7rWnU+KK)kQ+@qNf{hx{XJfDSM<jvvt
zyrD;qR$t56b}V25KAuWZIQol)nXJ?F5KRMACv;bw4{0d_UxL(Q*>2ye*7%K-a^)#v
z_AKBEOkVexB8BP=PCQqR&v2R+G<5MD6+R3qnj9gvY8v288R#+r(rZ~K^6bHCS2;U$
zNOi(2EP;4i!nAerr;)Scx(E0XTmx)Bt&^p!*9~h_T->7lJ`ou{o@q$LuY{F_wum%%
zts=aheuSLOW_rgo7GpS%3gW~*gfjlUxJRl)ew{?sLOEMN0TXPDhpmU$Pvbg<1b(Ls
z_BcaZ8J01l!(^2RbriH3=a{ANvK3(h!=b$RFR{?NQPz<|Qjb=WltEAZE(QP+>L@wM
zTg7h@G6GUZbckdLmDd`an8?^!@dT-WFqc+)(!kLrG(y+FkG0`MCO4{4s!FbMrAaQU
zfo9U;=~KKCC#TIXJ?{ME<kdxEpUrX@wPmBVNwOeZ7dP;c&mKE0EUa$qRV%a0BOuV!
zVLOIbC2IOr>y_;J>{gi07W_}|znfw#S&F2RG#@WCym-BV$61WZ$49;$+I8I5EIcHV
z`3K9`)HG4R`HRKP$=Xw~`O%-WEM8mm_4Rem+uEax>lJf)QBm^1Uh3G`*wt=7F227j
z=I`VmZcd9<j&05BoD<UrwLNt+xmCl)m64~Myv*o+$ZL%Us^(D2+BJf$Si!IIw6u(6
z(jp`yGhzym(kS-;C*mSl4%We5vH;w*)l#KaWmT25kB`8cw{Nv{brHh{Lk0$3h+i-1
zsQctz8~)z}9pL4k(uM_ZZ^)u>Xp%tF16pqG2I<GyJTabtOB*om7{hujVK9|Zl{@&+
zpHkQz;^E<8@Pm{h+>{kh6puI6-74d6$Q7UAq=ywz3d@ndNb}emu_w2WUZRIaVg(&y
zl_{*F8=SOQMq>xtB!E^^zSGnv10HCUKqW?8R#xWj<1>1;(VYUgUhpp%U{_tMtz8Bx
z3WDRv`0Olx|2hQhDZSlXJ{DL4Fh(K?{~oXAc&tWHd(MY2o=gL%>NfR0{(@!x_IjB}
zY;0_P72ndDPkC`anP_hKo?V)ySpk;xbaXhhol&7SOd0>kGY73Om}<Y?Kj0<8ns^NX
zTRW61;#H_!Rj3cO<juw<AP5I6H7fWXqY-EXACH7>r|tMsQ&Z0;+3F|es&rXF_6-rt
zKJ~o&2+|vtd(+w1`4p0Gg!Su8s_rD8r=dO9*-#3Ni$ez$C{~WV27$^GtFHy4A8LX$
z?qu7UN0gOBXQqV}pm#;vr@o`4haLVw!?)dEk{%Zy%#UFXoc}LFq3I<~qcTpX$C>ba
z_c(B)b*q|k7-J>4dHJH%JWzu%cq@zj<Y!KNnMmF-bkr7&y;dJ1BdZS+6H`t>0a?`h
z0K&z^Wn*V2_zBKT2^5OE2)+t0zX!RwfbYK|f9&pxB+N}s>AWd0YPQ=xZQpV|fBb!Y
zY{^Z^xjjK)#Zv|6zS{MgLVF_v76H@U1}wIrPGF7JgQ}K8z|^ER+{^8ysx(6#pCL;%
zqwI!)KM!dZDpds+PT0N9kOp8=o!_F)p#Q&&gQLd2?BQ2q7PI8r6U{J@We=p{h8G=m
zOiWC}0zVsuvre2K^M%#r9|EYhy6tfwSWby!&wDplmX`R}`i#**bl&BA8V53IMX$fL
zkqWy%+w_NF5fTw?gR|0A-m9)Y$X4H@&2_A&r4<U2pqLbbnECnn>X+0sd8=`ky!7}F
zzvN{i{K8L(<B=!?U0xVEpr*!MF7(NwBpi{{cJ$*Uxyc7~;=TQSBl{*Rb2#gDKh5yw
zkV{MA>u4<mz-K?EH<KLd*&ZymQYd(%4>_xvrL`xL3mg>(kC!WmGRa0`N9sexH7^uG
zXBA}+a`_`>mEV4xx_6jvy{^dZePK)1<#QSbYAUg<gV`h@=|r@BUiJw`#CzO(pjt*!
zWfQ449z!9qt8>uzF!z^=8e$T|pkDoWr4|C$-%RZn)$kiiPZ8L^Ket*&MraWKpS`#4
zTW@c-7ZhpazqP$4dMM%~dH3#J<+9U{{r#07$^UY2N&oIZ(9Xq54KXn>`M$HW_&uOj
z|C<es(%OnjncbNVhaH-T#%MxXV7;zWqE)ULKThjKu2q7DOIAyXrJ7f#u+Z+m;cG}<
zGRT%Wf~47R{)($2Z%Xlq<E|u+n#ET0TK&JAT2+z9T`Fa7PDyTxQf}AM_sctT_o1I`
z1v+mJ77)UbvEZMjqpsAxiUt>gfswHY%sE!~3?V80d^q15<md9WMLBrZwcQ#NW*>a6
zNFH7RgBvT%#GjQ$W$e@we^d~pQepdR2vrK{vI{87)_ajxX)VC5GH&bBl>5Zgbu_I~
zSk`{7{G-G+k;iV9TKBtU;_$Mw2J=g+6}XsLqCTvkJ4C2iZ{T+GoTMx;iRGFF*pQB&
zeGj<A#8Ken!$I<ce>-AQ3gZ^MxkOV)rcNwV&9wUW_s<>Z3{$sTPb<XLgox*!-&~hw
z+nh>*J~d--DQp=~eK4ZOFdIShpG!;Wqc()jP<XMqxRv%7*?g8Ykpu_!5{!lb*6L|#
z%*@OV=QP&Mrex4R-Dh1Gk&%)9utcHvAOQn1NdO>gxZ2E3OuWze30LU0)o0jbgJu?V
zD$w)$2<q^yjRRPgfSHGpmc(g7Wj;6~Rrk=YqJ_l-S;Y>1x^Q`oKHwE*5c=?jl)A`#
zE!DQ(BYjBg(lbSdUW_XV?}6waV5;{iDWSm6P|?!T8VHo#jSy&l2N_8Bj@MUvGg$fE
zSF>UsAO~l*UD737dau>05s?NZ9LLod`n#lYTj3l5tCwb)?JKq{cyd65pU%^4pS^Ap
zCNaGHfy=b@In~fhP$a^A79hscZ|&CLKq@IIITR0fHoAK`=Dv4KaECwQH59<4eXed=
zFDURl3XvE<-d4G;Gu0J8#Vm3jsV~fN+y=Fm!68>8AJd-PD5DlV9bKha5Lt(S_C$xE
zu?5<LwQZO9uOXEr^pd8-oaoK_U%pSiW|H1??izED-nO$eMFjiS+M|!AP$Nc}h!~*d
z8os+V`+{vy=dWOFY)n8kn;6+$mjVxhI|1G#0UyBLWnf<DW*T+#N_c~X$-&-7;IUmX
zaJX1ypi(r`K)B-`7WqcV7lb*x<PKmko%)sPt}gQ0SM5=Q77pLNw6wK7?-l*2V0CV}
z?=SG1HFjH1w17ll7Iw6$V`QPsIHaQRA^z!<UMi8X8z{s!l;auI8DEU$=s6)WhcBm_
zv<&<{X`ZVauw2jLZ<9N)#od|AMP;W6f7UQrodFXE_#IzU5}688*fNF*Ilw_^gN;#m
z0l4YG!DIBg>0gmF^wEc-^^KCyTGD&fL=D6b=~!O+Dh#<^ApSdAsxkmF0VVNKm(=Fz
z^!B?V7N`flUnn<-ZBC#qU*YpX5c&Aai{wVfgz>~)_Xn=aoFNi~c|s~~pzwnPa_lqI
zV#b%8W><P9ra|M8S+%|*#|#@U#EOjx4Uw6Kl#hBd@F62*UTgOAcFo(jTkpnW35LFZ
z2fTsRdWXln!-3Q|S)XgzdzLDFV!0O^rpiW%WFT=U)@>fckZ&k6y=6-J&$?|*%d$nZ
z2X>K(_`%;KJV*i|2Htr&|KHBwE0X^)sSe^r=w>n6%R^IoQ2!07e)8?QXG0-f6aj}p
zGCUfDhBYpvV1HDR09}Cz2D-8V;&Q&uR17izLX;RVcK3;`T3MfH?xaVnv0?&yZ?P6o
zIO(F-qne@;WZOFV@Y#9!+<l>N(MDb?<I{HZ#ELquC8(YN>m^->|M6NiKK1<BmBSNX
zZ?CJj`zcv5z}ttEeuG_g8BI|)CTwC@e%L#Ri>Tk;@Buy~&Uk-Uq1eMjpX6IOj%18R
zo+vFF8wQX;fvh&l(?D<lu3#Wcb$SY(E(jvklv`uT_KWqV*rZg*tkm!gwH-Cl-r;P&
zjc29muWyIy=Lh*%`f?Ol`YM7TgFk7jt&dTPdh<#znn$}Eh3%LDjZTv(tg@z&tVUrB
zZx+OdJ_qx(PtZ+LQu5LZ{PCZwIR8HQ6dzKV-*({_@kuql(3B=5VveDMpyFG{L1&t{
z;^;Zq;ml%GMri@X3jvjlyvhF^T>rg2w@ezvs5T!`o#$xmQU0vNZu4bvG5Fe2neEUt
zOyUgGoP;TS!^XzOiMctq^EcAca3D<d0x1I8a{{TSMgl5KY-r))c^K5@LV4nwg@xK8
z8b`xcr)(py{QGm8jQ9SFFGw`k0(QkeG5nT6AEh{gfZEt9o)@OaO4fXavro|l;D&&f
z1w&Kfn(zacc~VUcyN#`_<^AQZ|6aEJ`F1o-adENCUqybodc9$F6W&)76KZh#80@>k
zAg!-PqADI4*bQ$H&m>Zw%WL>#!otKaL^)0WQPE<s`?U?E8Y{lZ{biy2ns#;vb>Bok
z?E&yX5C{R2MtbIhYFS;Q_4uTe7bQwgqRAi?-bvYb=aAEn42lKO0aG5%iQ!In_z(-t
z|9BCDI`)wvxr_7}Ttmx5Tubn%kqp_cB5aq00V|t^Y5neXe7e?D;h|XsdA(U!%$SD}
z{PEVif3K@y9hPX<zN6rWD`d)f7-b-+m-suEq#l-%#RIIiHVr+Ma)1Kz;7F;v9b^yH
z+cmLJ=Abtg7(ZFAZiLqt!%2cVGtzSAfvrG5!FKuY=kOxc>e94LUed!#r*-tJnyvz^
zc@4KEks&XDB`WwLh`qlg<D1(4ZLrEA0siSl8O%BHSmUW!ra+$E^ZB&w&v_H$ViS|w
zAI|gA&~oR;T|g_biHLMAGy*2DZ*^nKU8z^2bN56|D<aEhlHD@7Cia{tQmfI^q@$z0
zn3d0IMlhPM&KRi!4zd_m4YJ*vKOeBqzFvt!EKYC0kc5GpX&A7MfctG;=FI#T)|<{}
zxH!||ZR#f{O&>uH(KST8*sZb5cc3KUXaIcRfJd&*E4ZU>C(0r-?Ro++J|Y(MiXL=&
zP=>IRTj?ML)=xVEq;8;4;HlEEwu2n#=qX0z?nn!FA}-K@M&8>+iW(Q`i)z)B@_zv#
zU4=&d2O6nEfmKU2eMhX59`0PDs?ZIa)=z6JRY%`Zt860}mqNNQiJ|-P4&vY~v~_gq
zM?BUWlzdTZJgJ@;a)T7xOWP(oAR=j`m7Fw~5VuWVVoqA#7RKg*I}-*9ophOTc-0Cm
z+M$(@UpwTvY&GRLl)%*xT>QAngu9>)SPHoXYKc>_ls@FqrhIQ}*ZHdL;Rf^fzhBGt
zq&J(q$QwW}N4|Zc5cPqeBz!-KMk*;G0W)jHXDowqTqJ?<=rgG_BI-ULcmNP1PcYYM
z5gHb420G|c0`B{gEisO!5@a*9Ec95YU$MOtDkWKY)>=va*7(8nhnoU0D#CQPJ@9fd
z?Xc-IhKABM9K~F7YMX0)<%hUSolO!5Aw}d{IqoJ)z?IfKzfDgkT=)I<TG;c4Qg2hy
zFB)}5nf-|S4jCvhq88x#`DQ2%k6BUK749`l^l7KZi4I2vl-R1l8>PNbWvSL*H%RCg
z69gr*Yw)&sPY*W{Rk=ball;mYH89DJ$E#EG6RXg}3JVgaKGY~DiU%0?jv8BdO{qWp
z#;s0~VPWv3n8=h8frPKxUFDOhB^p3X_*``4n4&c<?E$(Nw~BS56)e-nmO&dAB6{K7
zR;bPMe9U~6ge`noauosM&RURQ1uS{pbH~vkpZpA;R4Y2Nq1gTVz+DC6Q7g6vzCi{4
zByfj7bT=gSvj^b`QtPq;RQ>DcmbtG#6S*SWJ7wWUKKa-1jN2ng&J+wId9wydV(-j-
zyJ1Ker?QBlK6LH)ptz!`ukJ@qW>Cz3EY3(7y=ng|6jq9ts#{2}NqI(>?EshZUHC>t
z7IZV<ZJc5n%G`j;|MzIY94u<;q0EN<eko5+PYCK;V?cd(J(hG!R}vVWVCsK+p)AZ|
zUk-UDI6v%Y0ygx3pA~4sCv?xJ<FGD6;s_L&2=%ki7f<^?eLFJ?!nq;^H!LRV#~$^2
znq;~6!&zUi>ZTf{spB3*ne?9->bzJS)wYhQpynhWht9zbTBo3(^y=?=pI|?E)&B_j
z^X*|s$jFG?n_mlxK)8wW)J$z;WQ6|{+$O4=5O4Uh{$nAL?#CaXU$X;=2~$J*2|vFR
zk=3Z$N~{S;IrQpt#P<_)X1sJhq71=Un#9TgRx!f*%-FBs(f{au8MgH-k$&iY<T6Yp
z=|~}7{YKt}>Y)5Ccz=Z508=&s&gY9Ho(B0|?3fp@m8~mg;Tx_fkRAY7mDJTo)rB@9
z0N3(8o~zFx6`=>ufz3X56@Cg-z$Z6|3?I}xQGLfwLQrvLzcgV{^d>wdOWJ3?HEea0
zd*Y%NgjMF8o!kh1z_=BvC0lIM|1QQsE%)JYK<iJB)IPS-FL;czMCgA^0LFOAi?9v>
zo_Q+y8=yhcm^6z^OA&#8Ee+uc^R=>L?XDpvQos<uo(z8eI!qkY)r|lF%&(XmA5vJg
z4*ldxNDH|A)6f?oiXp?opZ*>B*EJa)Q|?7Bf9eEP&|fCDqJSxMz*J%E*14aRU&wy!
zx_oy0px@<@>G~t%{X-`_5CV;iF8mmd0;G<zi7A5_a&2z5XvX+iy%SULca6P9K9#(o
z9tcFSX^P0&CN!gjG7Wbd3nHAWhYUd#n+qr@FVFhlX&m)pf7Q_^#vA%UIR9828K{67
z6K5@eoPpKhqcxxOQI6=LoW*GD&>^#|Fx-nb^gBC4Jp&#uG&;5N^>&#RM$xd|-xDc3
zdOnZ`e3O`Rwfv89)l!rm)VlZZgTk7q=dOfVH-GtJU+J%BF10PN=mIdDCI#_Dj^7W+
z<?!yKOX(1PQcjebRivR~?c?XkAZ>e#x5Mk_nDW#$GdH9*rz3snj#n`A@PAo^c(7NT
zV$euA$sS%|5Ycm*pmP7`DSi1H(@e}L`0=h#58L`l-lK0Fsy{<3XlQgoNr0rU7&VX@
z*a<IT@_m%FOb76c0kuSw{w;KA3(vzr89~uodOkx?Ht+tq%Ccp3H@%L&6yH+ckwXQV
zL9x-T5Qu;~l7_FHeGUpVuU4Nf&=?-g_G+<owP*{*&C8Po)=K{3%1J~b6mL|0V#D!~
zw~cb7kla~<CWGL>0ePs)?h6yjCmqUu{eiV@xh|{5tX1RWyQlnnydT}C1Yu=yDw~*!
zGp!+&%-$--I392%<X{VIsAN@c`c7Bw5$U~7yFZZ)@|vDGP4`9oLG##lO?v${M)m34
zX`c^J0Rh^Qv5PQlq)MU=59<UnUxv3+<y`tKKec(1DAM#Nspb4tN{#1IR;|C7cV*A(
zT`4ZUWKfY42JsJq8M9*BrT-_4VjEL}cENH{E9kA7dzw2+iY@3vms_4hKb3m9Z!%NZ
z>sED&y*hBmS&!k~zoxvYV8N&n3_Sy_qh4CKeS&IpGJyUKpym`*e1VE49?OG@%eECh
zga7-ed~@EH!H>pws@T?`FA}yL`pPl2R+2;$<a-G7P?tRGI4Or<E?!VWu3bY@8747b
zLWk0mYD-j6X(%=?J5|N^NvGu8#xi!DK)i!(lg?^avBZiUTZ>5BCN|o53P0|lMA&Q?
zq+O}@1dSSN+A}^SyB+#e3}?Yah=B3{RDTd*NuByqM~_q^s#@etLnD@Fhv(FzaTky$
z@IWQ7c3ecT84!Ow)!5*nS*fgMSJ`(YvxSM9g8n~EQW^AC2ogU|2%!OHtZ-*`F--P!
zPnjYIN;v8y4)U8aw3Y8?DUvU%C?Ax|3H6GG96)OdnFn0kW27p4y44HjARU#G#V`re
z??pZH?>i8m)>fKdrE{M#Jq?PU5AYaK^Gm&VFAG35v7_B#_%W)o#i=TX*0lGvGYsbi
zv#LHRhrfjX`<~YqUloaN)xjD|tXn^l6ET_2Wt0Q?Z0Ijuh)nVa{n|&OK1~;_!&znl
zcpsr(RC%Ny@JT>5mmSCoQioD=Hmn6y{Lx#Cwvz()*@s5=3;F;yZT{0HIySN1Sjyj#
z&rfb)fz~W}_VGL({u?!)aM0WS+ru3NyY*y=ALI3kz5Co_uKT;kElZo*sLBz_#A0zC
zJAMezOpHqB>YwC;XP@afLB-Y#Y7%T7n&Bml2$2}UvCs}=Iq}`?>P*l3nxT!EBeQ=0
z*6`aLG0T~=MGg07_v37ty~d~Xf{#t^ekph9K58@%(-o_h$?GWT3cI>z>x^xVzg%}K
zNYixm<3Ym<u={A3v|~UvS%I-7uu+^2``?X_#TO0wyxOY);NEt*PRUSZt`B?&=eF5X
zTvszjm#ptT0?`tGEmFpwk352IJ5*bNF?e-7`f;?>B~S&R5Y)S_LrTeh*`7{ymtBm!
zu?qt)fChP0oC@_l4%R>~+z#_;Pan*S2<Zx~geevwy8a==#5mbE%(e|5$-$yA9b3)7
zQm6H8w+L&E8OP7WD{_4nEA<XGjAOp}>Kln~P*O1WyOk~MaF_cf(12!7z+idQHITo<
z$!2mp{_9n|(+5nNtL_br*)ypmKDKzOs=#O0-J(`2BHLqPpuNKx=i~#3QgVUr&m&Jp
zB0H*Vq)Zy<R2P6PkVNK4AQnp!$yQ~4i`!mcYv27l-b0LZw_mBhiyBIW{=j#@uatmy
z_E9i@LearcGk{{wu<WVIr-b*<Jkuqt0=X8HF*kkv(f0oDYchCMcAT5nwI<YvNBTjx
zHvCfv18_W_muF&e={d2U)|wHQCPf&ev)25NVY@}BmGn9EvRYO-=2Vp}a-o=#>DutM
zh-o1yUyTko#Ntn*`2RNe`mkzVC?nl04iq>4Jp)G6)1`L+NL=H|Y9uj3^<FwYc}sUn
zF>J_<pl2Daha<2-QA%a~8ye&r*5T{hKhNMxMmg&dJ>-DK6qEy5wtd|tY^FzUBS8GJ
zr-Kz#!w}_*i=0k9%?^4B;Blc~zi)qgK4rLf0ZP5rmC`fqmmZ8tETHFeXxrt!7A}Rw
z_RF0^tUuBziauA`<WMV~5VGNd?@IL03n?u9${u9F$O|BcD#&f~*}VAHl|V3zjX^nH
zWKOXi-uNfM^FA3SjOoPn%kVX*HYHtQ8pA=(Bk$Z*7!`>gGz;{OJx88HpwJ`)=D~dG
z8}Ujx3k^F6u&@;VWt8lWyNw0cleQn0K5K~bM%7KYzb&1Y%~_qyT;pPF4g2L>YvP1>
z^t<ybQUEh~0e+@pJb@u2BVz|B906JvG&eUl@$&(M%KyXEdq;Eq|Ns9_A!L&+l*-IV
z_6ng8iR>+-2+!=TtnA82WrVEkEqg0_@4dIDP1f)Be7!&Ce1HGdIi1e)v2OR<xZW<;
zUna!zH785o>ydiZ-VtKEe_n{pg`_|IAu3(94=9AknJ<q72rW5Y#$Sl1>J4G~+%#EQ
zO^n129%Ta&`S)hdp^B8YJ9Wl4{5{W~nn}X}C&&9!Q8TbR{kq0YC=bw;W$owO9p5pw
z5T1nPbu7vhZH5e8`oS_nv%K8v_mqt$LA)>Iv;lh@BR;hk|L`FrZ<ZkzU)Xm<OW<v6
za?iF?A|xuV$-BRT8SD2Z;<2FnrF9j*^$|iuLNRLZs@|rU=p_z$*$rMB%`_#b444J1
zouXJ+D7lGK+&$@6B{a^z{o2QC4Ee)cs~|)OUg76I$htOlwRN%LsflYod`DvY;TD7H
zwD)!&5M|QNeuzqbofMj(A^gT}+Ew{=tOY*rT;D6zE9*@`<XUAmH)<{~+;88#o9umg
zalG5kUEr|#d|_dM$Iyz0`oCSTy?yH`Q;ge&zto_QmRN~j5zOp#A)Fc449K_L$xr+5
zoSJ?dzU%oV3^iQK=#|zzeA6ovy=(*I5IFhe?RUn0mh6^xD@Mk)D#EwL{PEaoQmA0L
zQBpm0oT>E91aMS<CD3RxPkJx+P-D(;NA!mU2ctO+FYNGV$__q5e(cN%N|PUboI+D*
zHO%GW?w%qaQBi;?6F~4zA+;ev+}&>cO&ME_)6QJ8R<R{1boP0jHngfP{;l&+69n)4
zZ|-!K5q$0Dx@m!yQGw85&}#*<lq!G=PUsM6H^0C=vKIr0mQDCU>$}kV)<Ov(qLu!v
zErh`bjREr~THaz*5rm;mkgi_+*K};M{?#N~BF?wfCLBpEC?bIiGGtV1y|vN?rH<`*
zw3uXHO<v2Tl%mi78+YU$o>2FC{%Aa6&wemymS%E(J;GuhnUrj&rt7`LYfIKV)>*Jo
z-pS&B-t6z%@FVlG+9|c`Z`g6!a59#LfdRu6%=IjfFgZ*^L&JqdwlBqiH-4Xy!Ri+f
za7$R2hP!&74BBb_(_W`fcle9UI~za@H92!~us+P^udPP5nkJ`15jdJvnq>QNSBU;8
zKf*Hq+~KCi#qX;Mf?Q7cby8ub!qLY&W&EgN(Qy0{Bw|3TVx1t_N?9Zn$&a`Fn>z<f
z(aX?R^j`h(3yw2JvD%rt6J*B<rrw>3CXE4vnhuxu2>;(W>-Y2J#+Pl`M|)fMK#u&T
zeZFq*^`qZ=LREW)^iCwE^Y2Rj!Y-E>$MXX7r@@V$gF5fTGo|C$kEn;Th0|O-6jd@2
z86?5?v$c!Trb;;+m0!Ppo%_e@J71@?QT5qw`!Pyp@j5$G6b^Uvo_q1!{5&Zc*?WM1
z&x7E^a<ZbNaky%?jU!grKJCn2Ru&s13p~~%`B@qUO1+8o%a>`lRBn7wO{w5OLp>7v
z%5IiT;6@0D^TZaAnLYjMwV}i&mE(;Q3g^DDQmqcYhDSNgZ~lktHiAj|`KE?3gU#**
zlGOwy?{4h0y|F^Af3`vRcsmRpy9{K696zOtXf~-2AfyAf^fLf&oKo1_UhzN=ykPD%
zu&j_6VKY}kf=Gyn^Hn`}7YWrpYm`8w#t!7&kUNNQqAub{r5>z|M04VTf@H4eFaQ(9
z*VFL6$=Rgcw4YaSt9jwr&g;Hfgmo-$1+hpVKJ(k$ec?~P9tx7dy%9f}u#XjZL(6yf
z?%k{P_4TZ*8Pk$4OLU+W|9)m>My}S-B$;Pu5rjd(SK6DKvAMVizvR9y8Ow5dM?1xa
zm3a9*SU)qBXI!|PSB{xr`+6w0Xn+32qnmOLL~5aQ{dWjN)f7-iJ6FVbg@%knYc)c?
zk7JuO?s#MiYxtDow(|em(QicGn%Wy3^^KV01LJ9Ph?1qY`1Guk%O0{H|GyPGq(lqL
zp~Eo)AVoIF;|E&r`mr&zwnR!7oxwi6-5|#}o3$|WgB;>j>ZY^!!=DsMW7fW)y|0iv
zkxKnFz3l$qr{O%z`E3I8%9WlPPxmFsc;!I!PGNR7!ILMBVFNG<C*E+X<orh4m?RU3
zK-|39cCOI*PT-vl%6S$J$by67U3w`5^`!Q(zChd`i;4>3?dw=2!HuwQ_mhf)*peZU
z=|iz3(IV@ZNGPnJ1Is6UFY6;v7_jvdBFpY@ZY`nsA@UCMWnFl_@Y=8_YHXj;(#jV7
zhLeC(@yLaFq7^wFG}+Z2Bg{M>RhtJn{srk9dacgghm$55aN{13Xg=!i<HXW1U4==#
zTqyNB^iY3$sv6xzNN}0MQ~LG*FDXen#nH)0V64nGqT2oF3IaOhfzH#OR8O8f0l7>g
z=;qLqPGb<iu1x&iD>-wFYe3S^d151rX3GnuSP>2p`%*sw@qtaW)FCD5OtnuMKc~s~
z_eCh(#7z>={R27nQ`DBr%ZM*o8l~1~fL{fRk|_f-9LNV<mu6>dl3vx_lEKJY#*V9q
z(9LYlI3n|y<R5)l#8ia+d9MMw5jChavz#VF%wlSLTQa9!*^e4|Qq1}e8#fCBWWW*d
zS(<|6Vr9BkvgUM4)U^^mk4&}ng#ZzFU}1EECLk`doURcEbieR~*XialXegtnlC?><
zt#Fux&UMg&97w8~yVhQoVysZ_U{>!M3G_QSl$Y01;1pgz;xCZLLKqDu(GM6Hi6%y!
zk^i@CmCNGder{F#vdsP_h<5FGQV4+dqf0J*qXi+2jX~1p#YJm2?$1Bhxr-_{YG$~H
z5Yl}%%BrT8{K^t}rG0pqN->60%FOIeTYEb%0OQLmhqb9;m)v*Rb;4t>6X63xbhNS;
z6q!7<VM6vx1QP#NQp~q~@AS4|q8$5^VMkl#v8IW7mDXLc1e~H5+M!{g#P5_jHw%>H
z@9gX^&+0+(No4BQdVCXV#OS*mLkykG^=$5oZ~BP@4EZ!6<w#50Q_){&bvD8+zGkv~
zgeiUa`k}5jmYa}4*PDXT9nC_fxEALZTUjL|8-=|4D=tps?PJW+dY1wh!D(ra`g`ZF
zhQb1ZF#|$UUR{WF2&iq6ZiWD5OPxArq+w-r_wArbM!AZH6FcB#lFtbMYf&IFiWF8&
zowNJG+6163qOhTosYCqj6)5m+u(lXZ!W)-2oea2$l~*XYc&;K!<JleokPz}!bXLYN
z5&t|CmLy=+=&^$dZABXCx!$9GNW!ssL=0F5b40(jS{rF*35BlT`uW{kGJ`V?F+;TD
zTfO!y++_9BywC(&aJu24g-9rd&y(s~0B{qERSf{voePUKbT!UIMc|ICN0;bM{W`M$
z{;>5>pi(X5lfDK%F;$pH%KC?B9Dlks-gud>W|F_fMuPMilsJC11WjB6a`c{OP#QD_
z@PEih5x*Dn?-(fUZ-btIovz@`=&BtTj5e#NczfH|>%`v9H(=T`@>W53+)@6>E<?!3
zP=~FHLWJSh4ZvYelb)Az5S9_1<P{mh@NceSuDO_Eciwq!h_&V3B*#Q{_$t|z>LH}z
zi;}<W+%O}>0m{x0{i~O*&pHea-fZG93bxvl2B9$x_z!dD;I8~pI{(_iMeanf^XSxw
z7=T?%>{6g1MJ7{Va)?qaWPbT_&NUjDMD1*t$cm6wGuICLJyqIl#b|+E(|n|u_UqS0
zL-MEi8-lr1nqTt|Gwk#e`ZyGj-dU0MfX7LSuBEH^AonBu_~<2E<2~HNffVADP~3-J
zhU~-!;sD|zX>s~QJF-WYJtWE)KF=f7VR8->^DBUty0%#Rlm-8zp|N^sWqO(2O>|iJ
z^)&qZWTpJc57Q4UN*bauo9&Nws~u$+C0Iw=#E9VO#3&_F$Sk(1?MHB!rvY55-ekU4
zcmjWiV7AyH(T-0PzEdIP(X7}0Bb<^oR@4IoDp{~n2cQU$>GEWgN8{vC0%Qsok96t-
z%276KG~l3hRDfWftl`I;&-rTVV~*zn<Y9!n54$ZHM>fP_Hr2XJ2rcP+EG01^xMhn)
zZSn-n3n^_=5h7x1nF(X?$13jMcjk%s3eU=Ire;>{hJ<a|-mz;QQ(W49u)4?j>X`yP
z$vt|T?OZ(u&P)N*qLo*7Ce=A^@(<$Y+-$Q!{m1q22LR?>2MXGL@5$~iC2ZF<q?&HM
zw;4^!84kjk1#<JmBlEgnJsY_|B`H&RfS75GUk#qpF1zb@3zmsscjGKN&evQ1lHHc>
zyqo#IfsSQR6L;trMq&XurjGGJ;|bt+!RAHXq^xg&epGedPllZOO-zb=^oSYYd;lv0
zc*G=h3*|`+B<6#;*RhA*gnDr$uL4x?eR)bHQ@&FihcrOb_?!w|0{7Q1l+sv+0El}`
zUHs>sph;1rxicvD(|0)vSW23VLt&Zdl?ml~Weyu^&q~v_@~>8x7@DRX(^1V#$zk)o
zmYKrm<D2K-IIIfCP~Xe1c-#j$Fz%w<D{oHdFx^V|c@>U~07vVy4uiQ}^iKeoD;jI%
z!l3o337*Fm$p;8Az*zfg>IB3~&I!uRCz_#qZwK2L7q-h%*;^(jIj%u52yKjlO(oJL
z2RHSpAyaKgfd3;GF=%TEVhT2y$d^5~4MalTKXSVZ5jP~LgY>qFSV+p2v((Xi`wqtk
z;=<!D_CR1m<b+yNKhtEOXP_d0b|9Tt?>>~q#uKA5Br@%hg+^tfT!R=s8abZ{AEs8+
zlBtoU)FJDZ)chZ-=9?gVPEX6Ov|`YyEX-TKn-}8t)v!spG~d(S-`vrv-h3$rY|n!R
zqJcjViCZPA1vfqG!_`q$JRe|JZ_=0mIPqVvBFaU1KaUpIJgQ0~j=&FKOi6Ep;g}8T
zc?cfz0G9U}sA;IKI8&i}CHaD#$V_FE=Xtnx^!ex3q(!6E@PXRAV$tFS;(QwQut?nv
z84+BLXEoC?$<%`LY19CB2l|~6tp6GiWw+~n+5tk@FlLb#joS7yDKfm>7RK;r>>Bi2
z+r#kD<M1gUg^CD7O0GqcN4NVz`|g6I=y|reD?-bg)3ED<a1oN}KWGr#Ct#2mojk{Q
zSRR3a+5BM7MDBzb!LY*Zf%?K?#*ZoxNtD0Zf<SnQehj;UZ58;;R&x~NqTRa->h<ZN
zab;~zKq-kRzFyDG%yZUBiACyE2x0;l8cOmXhID41iXh&Ft&%n9t(L7lBLY4Nn#=D@
z;Ql~4eo{t=k6BI+wogkQ{)~oax|E#X*AyB}@bJr)+F||`ABmjv9vDRdI>~D)t7<pj
zJ&N1y(Mg?kQTwX3yqHKn{{wcS@viGP0rN@h>hQ5ll`;hV^0v0yW*zMvW3`4Y$%PO~
zT2r}c04ZOgz)$PhtEjLfZE+o#IsG+|8hN@!@pu1^0-O!uMa?rpM#&?kQhNI6p94+&
z9{xT$O1f?bV;rCFrkK6Z^oy3`u+QgfMZTr9n(cbfeBy^d^&oDBlvrw3%n2pn8v0I%
zU7n=zxx8)QJ}6cD@3*uytQGCfTj=EYDbF8gIW)iHysrL@WG>Yryh^)D6cZ-?HlL<e
z=(lpHotaVy<cm0d^k>+)J3FZiKJOj3dpM5pJEe{-05%vL6N?7D`krWX9Chaw`-^yt
zmG?JZb+jBq8Z*1ib*y!ceC&F=`y-K*CDp<^g-D7$C)PYxkBudPXIVnl;`$$;b?!32
zr#vP1-xIsV&CQ^`y<909QHNhJwh>#sNROCJQ-9(&7@MO7C!0_H#}EDv)i)AJt{Jw7
zNx|f8@yYwTw_v=XCk!{}nOt*VUF#1tpYej?%OyL~z0B@ER^YFenEo~cO^_bPHUERJ
zM|L*tInw2|oi3sQr>1HMNy*XI&6LM_W;yvpOvLL+^(JNH+j(&~!0ca^lsxu2GucQC
zHbq_lRl@wqJ;)wn2h_9|{>PZZPd+2)5Pk>Hek~Rv>x3@L7#zRoDL};?S5_L?1wI6(
z+aj9j)@wERR$ss3RJEZ~*7u1?_5ksZCh=-!G~g^XpLRWhEn<O&hAMP~3C+zce3!tS
zz%W6{MN4s*{$&ojJ}w*%u~j+aeN!E#Xl|KuXabetwnggHU4Z)xUxHr+Kv<veCl*4U
zl{XXm-6S?_1)zVvon0xmR+0|5J1-fQuORu4fe_yFYt`yPN6MlG+g`=wI-uJj#=-vU
zebeoAazZFA4vS=kzU6FWY$Xl1J&iFuch^92Dpzw3IW2N(fNMj|_&>`@wot}1Wc8-2
zYhY|EG_`y6{s^hCR8JuZ^&TjUX3?Y9jnfT$-J6_<Qp-0Ab&f077ZP5`LpFJ=t;gS0
z=!U=|@2h@wrzb;bVqE^DI*0=eE<-bH8%6P^I5-X2*_^B`Zl0fYE){i*ygJvZf05Nv
z5O>Y|2~u4TckF6KN`s|Y&1DLvZlhXWedd`$wpeUfVny|BTe^Qo)&ILgL~)Y#`D!_G
z$VXv==B*ZV-3Su5JWv)8%>&xANDzOxbM;(@Eru4u_`=%1HyBQ6n^)ajCr=ClQs!hx
z7Ba=!KmJFFniX@2%ulvmtf#-OE^?Uq*=2u80O3<2zh@UdJF*1~`pM+p$>r}|JVjdF
zgdx~Wq1~!(-Vmm}wl6O{uN7?G9UQ+nD!t^1_zq{h4u}un{eE>mES>Vq?R3*f;CaZe
zS@=&L$d#^co4N``8{$FDvh_s0>w&hl6X0J-Oo;bwu_;nQwbacT5(E9Q75e7x&W%CN
z>fbNkhBJAq8g_<v=9NpoT2>kn6ReV8CE%FbO0<T0S{f1T>rlX$Xm(ny?dg7_C^qxW
z20DmZH4{JMXubm{lC&oGPZp2KVa)Xn>RO$tLyxxm|D${<l6mLo3JYbh!}Guv4&~F`
z1Vf6C)ou<(R^=Q7j-}(S!tMOk-W)D8^cKGnGZ8Y+X?kS^>@-Xu4nT@{`;kkE)lXu8
ztOI7Ng6N}X=HbtjmTc?0*ANkeuL&PgBfjZtWKmPCB(<s+P_0KEq*H9(5DISurZy&t
zIRksx0(>kkjz5hAL@a=swtIl{bxORJW3L=N_s6dMY(9MI`fr5$I-$gu&Gv^d@`DYh
z*lJCyh~QC<>Z`;&g?g|$Y1<qVj$>=`g)|J}^u(QsmuiQ<T+v)@Bg<B!M<+DTG)(J(
z=+}}mdCRj0y1&o@6xJQl&X&K5>uiMXlnI*38bfol9NL|*O@FEHt-x#ZNRP*@WY_=i
z>sI-7<+(ot%)6y8qXAV4v|}eRhkdJ)9iFORu{6IP=qzLpsFf9~>InlD;n<`96+*gE
zgu@-cbqp{nhqw0AxImOvLX>|pJGpfAJ~c(2HN-GTc=d5$Y&Q|YZ(((<L!<PW>n>#y
z<LlKaC3DL5)~76V)1H9B?(f-ep4|kFDp(WTP8DU4?gRijbw4RR%g^egpV#Lpb8UX}
zevKdlx@)<q*SS?6pJ^*wi&y0dJ(LbW&~CgP@OycU`8QD9v0+gDinDD`tmZ<q94}!^
zke0#C?54SRo{CkA4|Sor<=vjk2FC_)S0P=QeLwM*+5R>WV*ky21b}UTx^cXg$k#Cf
zp$Cw9lwcQusuZf9B)uUcj!ZA_INp?u;E1_C-%$0kzj|1Mp}E!BHmmF$#k<xDSjsV&
zgV`y(a4!01v~umyu?T~3q`n4+J3-C;Lf_=Nf{~5mM;*J0!y0!4{)f2-JbMS6ZTU-<
z43MeBefvhHNd-P5cy2kg#KhPCWz~#&#0V=w(~540$S40yFr{3Mx2yd{h`cT3;pxtF
z`ZM$tQbMxo2EcY8FKe|W;63d7;Doa8p9PkL*GNL}qNn7?vdN-E4S>rbH&-jl1JBCc
zqj4B0^L)dP7q->VMiGN;R5H|EtBObFOgZIOp{)E35+eW^rPKM{pDXt2McF&6hAz4?
zOb3U=q#cB5a6TnNlgWok)!bworu75CMr4Uo3b8`78S;JXU*qfLos+vxlvX;^mVU1I
z90>1`+zn?6_%6szPIej{Syav5PS|a~>6wjIm2Ny;rt7Zjti7<#`@Y;P>_!9Kj~BDu
z-iDA>i2HhJTJuOoY2TfGb}^kn6ikSEaW~5&#}jb<%@hHM{4Fg8<pm9N{vJpzO@I(c
z<Z6P#6RZO!<Xe(Euc3cou1JZ8=6+`_pjYqw<Q&?@DT=Mpg1gHdPGV9!=|KeAtLBl_
z^JLORi-*RkPZ%g>Ka5xUCutUQ13#>)WKHPvwqi^fMV7F-Mn3i}v>0t}FjR7(Rq(5!
zYTU9#85li8q#%6o^c#EbH0UA|?aR`BWVD4s;4PAGcQQC!yST`iX{283*b|eWqFYbj
z5B4jQ5{@bV2Qj3pJl*+v6`{`0>n}|2q$uGapa7!=aF>$-bxVhd_3|?Zyd!Dw4e1t0
z&<M5f&Da6E4g{9-3Ewql4+t#YHX*)p&BpUV9@!F~Lt3lW;y#~VNW{5{L2C?L1#XOE
z%tVj3a*W>xnl6}A0GY_eRo%VWlTw|QS2NCOrvY`?ad%&mczFiao8b&`@#)1PM*AC~
zNhlCx8EF4>IgtMMplM*NFDCYIh2q${|5ZB2HAC8726m$3Q!R<ZG!cVy9NgT^ykN6x
zsK~&u$=_t-BhfqR2??~w@>17Ty%$eH;16a5F_}WJ?FEv6Jg_6L?0l8+ls6(Cq`Yjx
zu~ivU-QC3osUsr>8m2L}N{KYIArFZc3m!1$i2BnO5$fNn;sp~xUO>bB9pxB`z47pm
z!MRG+Xmy^-gT3=0D<E&Lf6VkuA(@$d5APzRF!iBt0Qp+k^nztOPdJG+0KvrDLd-0J
z-Pna`dxlivjRA`nM=O?<684R!_v(W&+rAdJ;*>~%KgV^=?>mQytw^Ib2G?;(5A4vA
z)Q));NKV+dM30ls%59t9bPT#P=1HQt6ehkCU#nFD`P%cvo@kAp4~>KekMbanUulZK
z*G#f9J2$}T&>wUKD(%J}YV)%gpq>avA0E6b4+@6|sV?Ij*S0P;dP)H>h?e9H%D??u
zkQcVfgrEK*F#7c8Ee}E$w|t&-)Hy%PGo3e1)am^hsNNg#FgbY<XrF(gbVttWY++N}
zo2E{T0o}KnY3Q5jFOwuLX_%<}x&NGVig}`{2ClRDbK+#ze2!!U2I8&*zG-+KTVBCT
zySHD>;8z(_;~qA_`aKW*#G!$jjTZq;C1}Howx0=~aF39(#;JH{oVY2b`2KEre8f=v
z`@g@en@P4z>*nWXmX3zwp6RjS;-=hyI|23*EnuO;+Ts|5Y9ZJ;H#|SbHK4DpnL4ao
zb~a^@gpX%2-|Q&;z$<~WkRHP6jh1gYPF1_Q_gxG~o_gw@a%?#-CRx*Wu=+}+$H)h>
z?F`mhJTtIDKb3SooMDE}#+`|4z+6|>q#+w7g0GuRB<xx@5$XNMMS_Vku3`Q(mpwkz
zSZ?J^P%Q&zo!1onQKX_0F-|D%y5?u1m&vDU?=jHhoPCS(zn6|rVVZb@ETr_^7Hjr{
z+34xdpB}iDRo&AzlQOPHF7cxG^4L}4eyv|_Xgh%eUTTiXM%=w+JCWLJH8vuyQW4C6
zzV*o0Sm||}ixI%xRp0v5#+g~)5Z^#w|3$t;vm*}Uy>{ln=|SC7-VXF_^@rQqahz)m
zJRo_<&A8)*O6eSEt5~OuJquO|cH6>&3m`DrhEs5H?v<v`sVB@wzen^ik5Q?eKEgy8
zXnzV-NHI-HAO5vdTS*313h2*I<L(!u0C^nO(|cCiCjZ^yR6FBWsOHLqcjzK$N6$D~
zuf^R|N&fhLQzy&1N(#8Nu}b>(5Be}>i{lk_hI_p^v$MBG@EtDibto_<Pi2`C!pB5?
z;L34Hxut;SOz?Sujf6wUz8v(0w5_5Q-4J$)r%VLv)L2>Zt?jjUik7d3TLwNh!~{@g
zY>CDw(JihHd@v{R(zVSK3E07;8W{JQ_5TQY;#-%aVbudKFV5F@#&ATr2*)<X478D0
z05`xi!Q|n(sgA7ut8I3S)TBksNY2mCB&#}UPP>-kW<@MWH)C8122WxczAFAxqp3n1
zWcDqZY#4MM!@`1P_)Xv?0PPwHyIbGX+0k}rS%RTon?>Ob-Ab;n553Ph7N1LP(eny5
zyBUvxP&|BTv^;vNc_i>^(+>#rP$!EOZ7>l{*q2WoN|v25?!`jimDYDOE^zvu>u$IH
zF9Qp6zopH`%~Qo>aJW<nN+_%1YQJ%+`gck?;%cNP&1&;HEAA6iDK7TWJy_l<+pNts
z+(F<m;`gra!X|bgax(otBcVye+4Kt0vn;>9@mzcB-s@CL{(qC(QQxz|>)T>qQG<S4
zk=eg+4zjRY>Dd~*r7BjE6aBg)+xYE~s!7k-)w6^=?ib*T?b8ARq!FH`sp^sD;-;;6
zp8sU-#%*9w^-@n|o+x-tl=S&%N4ByaO2psGXp;BFm-%K$H>ui7hmY`@hz?H~r2r*z
zthf#$-_C-z>pJea9$#R~ebYUT(AdhS)U4-oADonmo+rCLyp$0{fFv_^La}`O1dM5v
z<yWeBvTwj)f%ZM{uZ-eTL)bazJ>LJYD+LGDFil!A0=4^x=)*og6X*_Yv&DW<Q_Wh{
zd2f^4Hz+ELlL>O-@#qp=5@eq;LmMz)h1e*r<tf!z)hWpKzAPE#-TTtWqwC-I!{MIe
zBdB*Jw7GE$zQ{X0^a(8Vl$J_W<vOYss*3OD6=cj64+6;sR0_ORk%ii9y&hoD<%`<*
zs0F1ldW;Vc^82Qq6Artd=fFrtT7a1^^*J(@|0V<UX}&8{@&qbXR$8LaUy=q=%as+!
zoBp`~(+yIp_nFDA)AqIWE!^aX!|>)}e}*%Px2o3Kp*m6i_q~>tuA9L-)7BD!3)yd7
z*7%QC4!eR=(MC4A!7oAX3Z`50#eRZTolgJ*x<a<)AEaze0}`}_cYU_un@t=2x4seI
z&bJ{so6tw?8yT<e1g<Ny(|Ri?t<k(o=#|KL^~n6!n~#Ck*8f@<<v$rFRb44?k0MSW
zX`Qbs-DOp)surohoNEw6$67T>#z%coz6Yh<m+Kfy+vx2Z32p7louUGp3faJ9dDK!)
zn^_emP3o~;ak8t09zE#Tb0}lB+M7!GWbHn6MAB&BLq})s$ai!`Xl4_M?9hU;TQ>{q
z`?nzRhOd~ZK}*<p*>oS^VD07lgPF=t>9H^9US1USweOeknSCL`Dtv)=p0WBje}$hr
zh|HQp+9SWd-w4tjV}g<l8aU=$qCd3?9UyTTT(AL_jghSmo`jY&?OtUSlkH`(3wLnv
zNG%R%Zkzr*<y&aQqp)$Y>box6x_>PNTZLO37k&-g?T#0|(1viaEy@3|f;LnmpUI`x
zwJM#x^rF(aopu-`_ny2S-F>D1OL<kHmM89whQb5x$3~M6EeF}FL?wuP?8+Q@e8rdZ
zp8mjLAlDzC)^iMfr2#fTsJ~5Iz;qvZTS20D#P;Q830U1#a$rD@6v*!jqL1VsomS39
z2I(Vkvt0T(F?*Z!oXZ3)58^wfL9ckl(sHk_4aGioRfJL+EVfFfBhZY7S&7_a<NK8l
zw9E>V;kl(9nYtTzmaaZPrvr1Tt$U5*yr%6|_ukr{_sfjkcdz)cgqG33(j)_LmGFJ*
z5w^D5a@7ILu2nlNbhvnU@3OKu05b5N&tjzI`!EMMWSK~p@u0*|{}|=t1*#+kGWh@J
z#?;_$HDa^&=88Bf*`@xt+prZ#7%9|rV0U?BOU~tDcwv8ayo<H63MQ?bUziMa9qBzM
z)&ze?O2Wb$Cs&nR=#gIN)<xTJ4NUgX25_KgOH^6A#;pmbUh?GXfr2l<#=wa1*gy~O
zIM>p?aSjUHXJ9A=P<bUYf`q%@SU`L8wbOjUbvfPz1le@w-_Xm-h8{cEuqGV_q{q6>
zPQu1O;=taF2@VJGy|zC@p!BnQQ2Bn<5F6L5g4lK&s9j(X;qR?N$uqybJ$$WN=ZS<y
zV5|V~d}V;~+dN#j?v6g0j;S1rfF_e?l?Wh-o!Kdbh0Qw+k1OATy&(Cs<@afarO}D=
zi==H|Q;M*o!G|r$Pte|yvqGMY*iu6GS<vN&)OsrUVtFgMS3R$b=A);>>&%xSy`+{A
zxyl=HY9z<zMV8lX%Xd|Qyz>j?k>nvb@Xo`wo~(z*e9bf0gjS10&wybAcf$FWFd4vT
z?!a>REfy9W4$a)ELY#3WJe1uhzNe76{<VI9<CD-^Q*Nl_UVEl{zeqjfIr4a+iwo3$
z;Fc66oJB&S(Ns))_^@E)PwwqM=vzKHNb#vAmled0XUj4pj;)7oym^;mekTT?7Sp1C
ze1X^AW&67OyN~VGW|q*k^s$%C%ppWSTC8QjB}?pne#u-7jJ^{7oshts$maEW#H#Xr
zpgNb)?sOK!#}-hkhVE4H7^fK0Exzk}w3ph9mmPA4pP$0j)s_1G&#m_1_I7;q@_&id
zFuz!#ReMwus{_?}*2VS_b4QxP!`BlIGG6|8w&$*)G;|QvPsy8hr)w>~E~P=<VmLiX
zXk#Kd<Sk1~Bkw{}9P8<<xiScX$S<><gRivu_8eVL73?KSw@*L2TEo>)!_J!VT7ASq
zVr7i`{2*I5doI?3D+BkX6P5-3FOr4T_uO}#&0<a^^u1|Y?K#l0j7ZT+9?dHZ?QE@7
zmjgL+FA2S_`Y=MK1dGZZ1Ul%WwL>fU<n1K!{kC>;jaqE%L6z34*w}x^>0x``=>DK^
zfTp@S0>Md%&q=vRpsaSQx;xsf_Htqjqs*%aA8qU^`}}T;qw3*%Rm@{lsdBm1mcf}9
z51q`|sVOycvv{&8VrzvmU=gQqr=!sKcyC7nrOMM6vhP%XIxjlAYWSJgLh+gi)^AgX
zDpTfaOGYZCkP_3aCxjaGf228Tv6T3VTi$=ONBGD`cn2QLV$N=Ro9ad7?oU5fL~B%R
zitQW5H&=>GEUTAW4)jBn>unBlXO|Nr7@aL<x*LU|t>__9z*lv^-n>@=T9xTHiWrD0
z$r^GGy}{rDz|D2v6U7P%YwdyBYmm+7<np7ojxUssR}obY#3&QE+FE;~^j2#>(Jk6;
zdk9Twug$TeKyEhQNG$oX1x>)+93Q@?ipI1jxGvE|MMv`*mf0^W@2?LN3kwV5;$@PP
zz}^{FD-tjbUmJ(34~BGIz@VB=toG$!GHQZ0Q!*Xe^&+9{F7?Kzjq}l1bYfBN!Wal|
z^Nf66U2JE<h%Xf*Gk<v)1x9@$A_rM{-m=vC!&U&2`^h6I^$&Xm^Yu<n`DZ&Csag4K
z^4Rggt$auUzu#=FHtqBIVlSwFh=>mbyqL)1Np!|J318NImYI8c3O0}QD4kKO121Jx
zZ${IUs8cC5j(6PQna0b)6O?ZnJ8!lbhESN#)c$>~t|hcjSU8_cy?B15ZjFFq$Rdl@
zF>KM*=n#)WIVP*8r9YfSq%iO6y`XR3XqCR+$6j1qMD4%q)~hnGq`Z;^WVPnz4H{Qo
zUf!P7wVF;kj{N7(pZ8QaTG5NSkbvp)?jG#7J(8BbB5`?UADCw!RUiD}!$Vco-WR9y
z|3`TaAi8laXDDd*_rOv9DDUj}q|jGG|6XMM@kVY}hfCyOxTrb)4(8ZD<1O*Y*vy^z
z-xTGhT?~-e8qiNs^8MrBhNh^i*l|CGwWMyS9i!&i#ba9+y0y!x<-|zs_3qj9NgBJ}
zjC>;<XR%^ayXp~4HKGS|1jW|5E%1u@qF=F}_HSpS0&6D3Jdm2_WK$>0DH$yRcty@B
z(6UfPN*!A#7wT4acA1X7KOc$L2_AXq%;_zJ?xD;T(06b){`~E3y!<Zju46q)d86gf
zFtQM});14k=<!~G#0Na12{Qp+&40E(fuwzLaUmF0_nNZo80@}rai1j!c?lQ49=rz9
zsFC7Vk(~ML?Ckj#-3&_#j{q)MUjAU8zV~&B=J^%JJJV`e*b)^*_$}Vmm{}1^#!6qF
zg@$T!QM@jx`=VB1-0@``kng-+W8eL8Y@a7QoW9dXY&$uIcX@QG>QQw;P$Bm(2@>bl
z)2pb#C>!e2K_@U6of|cbFuK@JAkyr%EYYbFE+v247CPckh#=+``9Kk|)wH?(uZ?#y
z#-Z_3raZ0peI1_Rx$VN=GRr@24xbADw&O>Rui5ULgxc8kicm^v82Gn(DNCzH(`@>R
zqozg4f2i>=VEb?nCpK&iJckm&!(PSNrGo9~IUrACPu9^@f`>F~%WXft2yu{Af}wP3
z{c>P)vVMjj--QA)^+GOpxmNU!j$WiY05XVfi1@)K-H5dS8s!Wa5a|~$qUrlVYISyT
zx{W}D&!al{x@ROWPlz?ZzlvEtd<OJAGM1LCEfI{~VO}9ivS2>uTGEkK%P57>$b~^7
zH(w<oN6o!6TM-FP9$le{eH>)u75?>Im?{?@A78c3Kr^n=-5qW20+u{gzt>_-Fl*#;
z8Z^}^lF;_fp&Cl@WmM~}+c{J+hlE&2Q@dFU@nV#|hhz!W{<XQ_<#(E1lAsx(00EBi
zmZ$hk3o3QYt%Ahx!krSqV<jy%#u^)S?UXW9p-2HcrO)}1uZ6~$BFAUdSA}T%Xoi(M
zkA8(>dY!mBH=qynlvrt2frL2Y*DvYeT>W17>&CR9Ai?oKrWz}E-f5rrPBYccLZr$Z
zEG$cRCy1-Qc;WB3J|vZAk+)F($;JFJr$~THGDO=i8u{{*h`Pz3Pt;(V2JNWy7=}k-
zqra%zp|?!O7y&+bzzdz-X~r=!J~nm4-D#qVtav}~bI1KYs_{_0SxYmXR#Is*Xb8gw
zJ=0&SsvdC@4dMhyZmf`G(o{F;DDhn7stn9JCT>?qd~aM!afLA5QIjru%Ol#|stCNn
zI|^lHT#dlwt>um%Z^W`kN*|nS{^<$v)xzH4v)<bq4SLm&|GRV@2)!-|wy13Y>&2J?
zLKEl+3yH$vjj-_NTU8}S9VTZzQBDdQ&6<}p-+7_;aS7=vlrxtJ>`mS7(Qu^=!sn>N
zF0}gqSousH`@Wf+`K2~L?q1Q@DC-MKj@=2aI{^*^4VPhL8dqw{maqiqyEQ`(kp0H9
z=hf&lxBuitYz+!=@!Qd}nwm@-3+cH#k&GdfRQOl2)ttCB+dchOo62wR)w~70?7!FV
z>u!ff$bdUoZ~+W|i7$&8!IaqH+CdYYX;h#L=EK*jCD!WyHa?cFP-a@IUqds|50<D4
zI~0OqWFhTsicZnb$1(UQH<>LFzCZWcyei^55&D|giO@p?v(x*rJ2_q7Im(SJXk)g_
zS|!0*drLVKs~Zz-1utJ1rT7W9hR<BQZ$T3k*037MYkwLae3U&fdHj;J>7e<vy~U_H
z$0qId@)?$x^Kko01NDz8mQ-r)i@Uf#UU}Z){jK@agcE$Z7t5I6(jdF4Cn*%eeVAGj
z&a`>hVc{Y~zF9k00TeF@`cAko)^~eg5`MF{km;T5!2G+5oR1@IR4{x`FmU^z-G=D{
z-p@M|JW^5B7p=VX?Z!u@U`Z1S?X~9Pl#%Z`$^X4_6(!{8tPBd*eyR;w5z`uD7;l|9
zc;ABN>`0`}`{4@#W7k@hwdRk1ZhctyRneRXPYiQRsi~lpHCbD^Ot!T$8{UJgHg;#;
z3(f_R)3LA2_K14a9@KC!diD@crEBmUp%k~hbfuRs!rtq>oQ$3+9ymIvwJ6}uxxU5q
zO|F^z9zL1YBXMYyBr0uOA+Ej}c)uO>_g}xV;oeH!5Za^&)^i#39T1Bp)-u0YY+w2I
z?%V_$B(XwPJnhuB<R@7gv)?N#lhiU;f`4_y)-d5wm@j&^2D%$h?I!@b8f}dtF}fO(
zSaE51j(&%FlTW6D$9ZdiZH*0-3=q%TB={P~)6-qY1V0(l{-tdhXomUWa!-u6bX|V{
z*2=Tz{L-si2fa70Yf36+KW=O2cIN}_h(%<@t%31qnnYOE=x$au*$&@s+Q4AexqCbR
z!&MmFqk1>rGY)OsTh3o}xXEXbI)_?q;zGAD<(?2GTpsWgJxQ1s^6;>rf)^C6o+IX(
zh<F|OHnJ+vAmpUq{T6^$JNk4wgfrz*RfTITin*7jhB4tITaQ?t|Bm?v<$2cO#(TRE
zH`#1=Hm}TN>SXR$2R`$^Gnf}}j5Dc2pqKDwg!LKHO^dpX%F6e~hW<s^FI=pVWE*03
zAZk-`yl;VeX@GrUn`(r&w?9)#P2FC41BPlSNG4$uDpV1-`HlW4CDEgHKP<}GkDqpK
zmZz8XeCM$ry_r5lICb?#&F@M&SkZxRwpH+ZH}AZ@<Li#<Je;#heKbX0g;V&4&<YLW
ziunHV&V>PtfNo}eYb2Ls1k9&e==Sswqy5$<S4j46`8giJi_!nPmYufGy7?JtHZPFF
z_f-g<>V>iewRx(ezh<tH2rxZEIS(7xJIsnCKLRUx^h*m53!L7LyN`ur=T#q)C`NFJ
zAX1vcF$yqT)?!MPy(0uKg#tRr>KkVDS<u(wk42gE$0|iM*)typ26ZlnUu5z}M~4XG
z8>@E?g^U%>TGv&KnN1fN5q@r!CR?79NyFDTs0=S<M)$5ElFuhm=hc%l$#VsKsaO%*
z5`Q*G=?1t+?6=o3Koty|EJj_kLLG`O1qK8VmMv+N^m}f2Yp)fq>MMHk{2Vr!7#CI8
z;RoBzh<g$~Fq?<c%LpCnHuI_~dMpcOlM+9F)P5cU-OC#Lz5zh5x;Tv*|D=4uJfIlS
zy`^BJT#E1kZRA`Td|&ViI^Pj0v18KVx}A?JyRXAv^R15}SBD?gLRyBC|1yO9t-gh{
z-DZU{b-&LS=8%6ww`o^>yJfqxU@{`q=>h8nCUWkTtlxHbI_{UE=&0#@7}E};fJ1j`
zT9C2q{lD*i>FM?fQmAf_-_VJJsQE_%KGHDJvUzx9Q!L?hk>^5K8&R#{@7nL4td>E=
zcX47!%nX{G1UJH^r|Wo<M*;m}UCaH1=><EFB*53V=6AYizcW4p=43Mm(GAyHAR_fL
z>x?qIw><e+cPq9SZ@*5|L}SgHPQ`RD^GbT2tEsj8e)x_owDV{rx8$`6Q#fwap_J=g
ztg=xIm*=O~H5fX~TgndRb`BP}VCf`VxeML+F}C=Seevd;*IS1hW||{TX}H_gcy+rM
z_WyTHPtF=#)Dyo@ti=suG@f>v>CnRU7{G);<3`szx#n3oqf*kzdG~s!)4>BT*GSCG
z);Ud06oGaqGz=1qXPjb)zzX2UVu~VT)b&6BIUV}Gb*9Rk^dDk~@i-gUoDV<LEf{=)
zOCh;Wqk-pByqhQ5;Hmcs+<9B$_cbx<25Nd^k&$-w9>yoe)}oCz*^F@exmlcjb()Pq
zD^zvSs%q|90GT7F8xJYmPH5Wg>?dlR@w&)X#~%Cd%xrGV-^QI=L(Yb&SPwm%5Z>_a
zNZ^3R-x#BOfrH^)b$WC+ktai+Y0ndsWba3H{Wear@phE5a1fAmg;T{aUPXwBF}1vk
z6oE6xwVCvH)NyT4mtxSP_CPGkUe>9K5@vKKt!n7KJmsBwOH~^l9H#EW`zwCC$we3J
z2p6-LIH6mdBZ6Z4reyHzzV3kk@eTwzP*d$B5S&f7rF1B19I-N<?LKD2a={Hd=#P0h
zA2EA56ta4zMl~>Sop<^R(+7@j|2cM{H`mNVp@mV&9+5fg$^bJl0>wjICp<V3-WTXg
zf8E|Yt>-+GcX;lNd?Y$C%KV-Nc)?Afj7N=@r1w?1!!5V>ollUOA{vZ;{WUsgvnng=
zTc5CfDwlx6@c{_-dDdEnp9VtwaCvh_)D#Ps4_mU5LuxDUTM@rMO&+vCrkk)vwe~Nt
zPa$-@Klz5lGd?~J=h~fU_~NZ-e)zJ4_^>Hh{vSFh1N~a*?1F@ncua@;?#{53kfS;O
zo+ln~QDdJ*6E;QPJdmxDIFSndpmz9s4lV_bKFLjGoK}p>>XeZFj=q?Ff0x<emx#La
zbDddL<VrOezc~kkUO6MI#Wi7-&+a|ZkN@Vo^@OdZ()$Ju)5IeYx_B8qN%%NupJtSC
z)O?$G!4Ott>0Hr2Ot5~PvwQ2G(dHA-mNteCzfzC2w{=F(MqG2Sk1q15Xqq=ZFM!dp
z|DY&6s{Mkq3bk&W_9u9s&*+5Nb78jMxpUID+wDy@m3?d1m!0`<fpHgJK+n0c-1X++
zQL5*<c)H>xu011t2nK;ITc!RVy?Y}dbv(9{wwS0#HDB==P?-6f8VFXl)QKd)!*b3>
zW4!3}<lhMstXI#P_Lxi!B%t1!<smw_vYJgpi0fW2^Oh>IrX7Wtw~!B0!ATjCY)j`|
zbvvzT`rn>VX(G}<`TJB}w1@H6lXl|`6*YzkOvKgrt9$7O(jbh!uJO(8h`92Tu0gv;
zXSpAb2d{Sd_cPG<B<Qy=?2)fzw&q3be=0KL^O}gD8b5!*y;SR8$>YJmUrXLJXmpWy
zWO{b^FQBdl+t8@l6thQoLU+ee<NFP6PL&uwO-7{;txX9V_ord&qeCJ|E@wp_&V2n?
zaaCxi#!E)PVEYOnB%s8=>EFUY0JBAGf8OhQh)l9%MKzyV9qBM5`g)d<FnD8o_z46=
zBU&k0Zl>n9ty&q-O_DZ>T&=e*nXhL&nvaVdhK3aSP((XHK$li+X-lexyr>^k>(H9c
zg_J#8B+ggf%j787b)_U$Fo)&tA#Pwij)9@;^+-%FDchCBSbF{(FjMDvI(H`Ip;MSQ
zWuL=d+Z-%^dfz`3i~!XXiA^AgWHeLyJ_()e^f8L&@iZn26(AB%uHrpSu<3a<V(2ev
zt<v0}|K8_xBNxjd!X)o8y5E)a7&KrNH+yqA*Ini+;N(a4!dl`HOB0BVpzxAbk#;3?
zzxbikjDAsj?=;Yv@l#Hmo--^&6%;*xm*B?f#X|~R=g0ScwJdBq!F;dDqZ7Q|Je&=k
z!C@U;;vSvne-Wlrg|w}4Ty$O-i8yf9RWmB_4s&j39SjLEq$UpW_k>MGJ+U49c~yIZ
z!wl1stDZ0R3igwxP!`9}XzmH1b3f?zOQmbfuCq<X5~6%~Hck?@kA74Q1zS2Z*l%xw
zJ5i%Yr{P~=7nQgt$7_Fxs3{od_MPE-mo5EpykxU1lN_{8PNvm#CkY0alhxuRYpL=I
zs{9OwZ+)~sWBTm~?WG+)RPv#NDPs9ipg3!$x%*3h$m;e&r_lD2@K3km%Myh*Xb|91
z?3c*!*bjU^-1`-HRx2l2Gt|4h0FKXsQ`SrsS=k`VO#Ru*(Gr*PKwpbHcl@)#h_j`{
zX(#BJ0L-XO_=dXhG+DQ!`}lBcOKDb3!?Z<wdi&GUN6X5a_0~Q(XghYLua)wgqpmZv
zL;~fN`OSmqAmTK76D4K`8v&r5D?Ey6sz~{LY&ZD?@tK9m{qY0jx%8Eg@|PgmLY)sJ
zz(9Y*s}$EZ=dDfi%<|TI_`T?zcUXww^}H}p=e;V9`Oq(qsZjb6@6iF0Kls<k*K9E1
zEZ8@mB{~KtfUUS{{8zGr9m5l2cdpk;^x@PeG!#r$mXl2HpQjsioCiuaN1aT@o`Pz!
zlY2c;s&-m_$X(g<@QxDgA*}&zZ^9^XG_0nJT5LC5>_3N*n3hoWm;Tu{3w(CuaGXAC
z#)Blt$Cgw!i7<6_(VE_fvnX`)Ft+Qai@h~Vy0|*JDhOr$v$cBTFa5lX-X+9Cu8{B~
zM-76IBOyjdOawR-9k0GKK=E24g|g_O_)8Qnry<d}I2TJ11W>_8&35Cqqtmz;YEgeT
zV+emFvmDe3%EwOWYPLCDvr}3Jk0gJe2|G?1h>@MRSI085;~$ujHr*ks<zd)fviWrs
zr?`|J%jfx1jrf<EYjiBCQyB!9()s1j?({whSW!1fjcpc4(*KA<DGpeE%<;fAb%Q%w
zhWW&x1-#mHb*4WEPkECX3=&Z@4W5OPL%LxkFPjbs@i^xSX@=OSZG$xk(Af+~trz$C
zVQ!Ld<i=edB=-}NOx&VqeUs2b=f=5H_Xhb^W^meb?wa!7H*wNnADbrRVAu>f=HUjr
zJzm!>n{46F?H*5mq%%l%uY`$K;&*PN|68}6JyfxZNp(3S4v$r)m-e0S;9kksdQCeK
z>-XKYIQLtaWa7rQI_st~Tg#0i=UaIV9{^u*yjg%Y+Wza&*}L&p>7NZ16j&?Nb3uvm
z`;Hh7<&cD1=f=daP_jZhT7LH!0O{!K1yL@{5bB^+BbAbtH%xcqA3oDJKaiKsLS#hv
zP<>$$Y^zC9^b>@7MuuVHY@iz_{tzj9LW5F|Bkc9MiZ)T3i_;g<tz%%l0V1u!KzGx}
zfe!&QCsulls2O()*X|my8a!SJ?>aV;7IQFZJZp$l<H<Yfb3>X6NCx0g9y<K1Bx?%m
zu%$D6Sa#>Y_E|Dtz^(di3r_cPLFp>JuX&edhIi3F9kxYaQe3|)|Bq?l`}w!VuV%6L
zodp4cgC3M7TI@TCgbHUBUyWQIGOJutSzj&2n}QGy-5I;IAJ?Q3xMC%%)BC5m=30Cp
zUwT<3mMq@lgy%olHUCNWiBLkLlQ9mKVb1o}I@&b`EHqFXg)+*^l>aIaiVQ13PErhj
zk29W&n?$$3Ji?^X>*L(rjb1Y*vCM(KW~a?oK31C#wsA5wZ+p2HbEA_-C=DvT+d#GL
zJrpvI&)ms-8y9<ys%5@&!|@=2FY&8?WuT<5Hu>CavT7-J{<v$0j{Ozx+{ZEQN$9uI
zmgP>(rbRH1*_I8geyuPp`X(|c`F(l!=Gr&-Hvif?gT)(V&e<fYAG12HCStP7bcs6<
zy`caoe6QHC{!FdgHuR5;NS_8MG|$e9il#V+a)Z;QQhe?3D?DP7tAgD%WprR+;eBU$
z&Xq-Z!>7ln7Gn0>Rog!2%7S@LQL8i!q|5q{a<VC3K4hqA9g|_wEJMUdV*{=8g{RaL
z27i32cUpOGn@BL&tv}<=g{`-IxAyPK-iGhXN&j?BjsLj4Vp_ud1EqL&F@i|<dNFvH
zgTWx`cEpGqNbo#_e{<~XlqL><U{lF3pK8#Y?qA7HW5cO?y;?V=rt6{{L{Yl0cS=AF
zVDvZi5tiH9*E~|WJ^Dt&zYU@Fqel+%da+b{{7qrlc$~>kki8ka%To-FTpQEdQU=1~
zOxH=WDQXh>2x%z-qXXZf8s0A70<~yhGap$mC|jW)lh!#M@*;3F#RbH0zJkq0Q^ja@
zNWNtC_4%5ytp}J(W<5|)ilhF;hWBLpe_rZNXKc_Ej~Nbe7v2<n?ZaZ@63`U_MpwiG
z?p(JI1RU&j{a&aX%C|mq+E#~;&F0dH1#0a;FuYxkBtvcVXr(`$4{=JL4@xAiGnq$^
z4ENH6xrZs#ug$T8ZW2!6<CB}qcN7sIAT269S!s24G7jIpX`_UGhT)(km6YhgM}KkA
zLvsm?hd)Mwa;`8vX!m9ds}%kimi|R#`|s|6Rl&?f0`;UY7Ug#yj*Y<0Oyy~-XO$1L
zJ*pT@&ahQ-Ma{RH7y}Ex=BZ{1i9tim%RQSLM!>K!)=(^K!Fvbw<!S+(;{}(fE9tGU
zwnDyWw)(-4Izr6R^X5z8Q&I+caZKp3)o0F(di+9|){cdPy)#t#v&%Hqyj<_zFrj6$
zBMx%((!>+-)Im@nnZ__;FhPKNGQBAW$8bZHzFD`p1?N;`xQaj=OqYbyQu^na|GP>}
zzlX%)l;W(%`XD@M7&viPHGWxHjrpGZbXaYz%^!LNGXo9vvMDWJA}dTl9*U@goVyi7
zV|81%F^6Cer&e-`7z#U|UX#{-MdI0<7p-x*=Arm|4TdU*tswJ<R%%zwb-ySNf0glS
z4Q?A~^|OALo!|+LAEr6Kq*mMh?f0I#_}3Ywx40|$-NR5L^B>Si9llIx-p4*gYssYj
z1TWln?>a>68rS4O;s&MbPA02M0__ClB@N^9fJV{?uF{DY<MV4-q-&|IpJ{?%C2p&{
z21eorAZ2vP(;YL?kz8I%X$r%Gvm}@llyEA<w;KT71MP1YyLzvIZ=)u72)QQg`N};F
zDv9!*lXd8|f%xOY7x`<x8MWiz(B)lHONRjO!P~*Pz)bO-k<J_p1jy_lIO+d!nkz5^
zsZ#xBJbVsY=qKagMZuuI_ztH*<H3h8c$5d@)23SyOgiks@I2wTe6{vZ@WCL<wEQp^
zqj7VJXYbvf_}>vAqKM#BXz;$2z)rxqdlcLRft`6IWD@6vfmMC+iTjS#b4sXLw~mE6
ztRJ!Q0$an7UX8h^m{Qg2D!PJvbW#u~i1}Wza$!T_4lh}EFmowx11Y53911Y==d7xw
z0_g3?Hyp|>tEfM;16<GaZsoLqvLsf(o0~oUWgUE!%$U0Kdr$CsGG741ff3Ho#bO+#
zoH^9ohr?sz*Tf*7L8~5l4Xqm?zfz8{cS$!oJMTb*hT;c6P%jFzAbGJvXf7*hz`ga`
zUhx&+S0>Td+bF1%ccfP~XLL;I@y?KOHR5aInACa`F}rXUK}zjNKyAdLOuB~gke^F>
z7CuJ($X>Xuv&r&r6Oaxb8|!q-38yEvWi>@H9wv2kBsu!fdAXLWq?lvdh<u7*@s>c#
zPBteSb`p`um$wyoZoZS%L&A#EOSRtk<zTvdh5t%-S|g5*-lNmc=l);ccWInq)Io7{
zcJ}e3uqY^xkcPIcpE#Y!MG*vBBz}V`lYZ!IVF=f`g)vujwV1f0dlGwkVv;aXMZpJx
z0xTk-_NPC^lJ(>ZW<dl-4XB*Qfj|5Mi;LrBionI~Uy<9)X`4WCE#B(`f>~^tI7OLv
zB{>9E=x#Q1N9@<XWP$6P0VJ3W`He|mF@01!vnMnne)JFD=wOWwlW!ytqm=9+mr~Zi
zzfv~@sjS1N9x+KM3?(X3`0V3|r4aB~vmT*a2geWN|G1%ATY|C~dTWwT3z=fJzEx7m
zc2V5{Jqx#n#1!!x%*js>Y~t;m=JH-1UXytk>wdh>>}lt0a@&RB*lACAVrNr1-JSpj
z7jRdsV}%hZqJe0M1&IHv_9R<zHYI*ho#s_vfhdLiw;|$RP5Nl>XIdIH{C!7f$?zay
z`(yu&cd~{iC(P%lr4eQ2PT_VdPM72K+f{qRNN9Tl=e%Vt-9}p4udLq`y&!wHb2JQA
z4n+LUyxpB|OfQs3+MPufKlzne$?+zsoWeN~<iG?@g6190W$hb+jP}3j`bCY~uF}y-
zP;=eOrC8hA3KOrD>@#=3{uWa@;#zCq=`ZHGut0LM^yet!#IyIYn|oOzgYkH#iOq=#
zBgKKvzkk16f0QwNaUzSjvhkF|Y_<%icZE=Cee-Xn;GvbX#}_6a+<ZTV2ds5p%`X4B
zyT<uXe-pf$6%m2Sv3=uRZ4sd`1!0wQ-+LFn&$0i6$5HF&%+z!?^i3Ca5%OAvHwz{o
zrD<HlH>l?NrebsBgKr74y6NlXWOH8N+j0GlvB|06)G~qv?=s?+_WIzs-K&)6Hb(E)
zbOUI0E}th9E#oDBku~i}bdQT=(j$OB^I12S3yiO;RM&re7ovUCV|f)@sLVY<JTq0v
z)0^cxS*ZSdZiC71DmHvI!(Fmjf~bZymjpdm`mm|GfhmUUa>17DsB5(hZT#Vj)&{z$
zactjl{S6u;O$EHme@lp`BADdN6DQjf7@JP6*QD`x6iD3$X6kBvvnMlCCw^}r9G`CD
zP`}G9&934Oc&y_7y5zpi`R>EYAldrZmf7|b-`^J5NSefMr=LYL>zGl)ug1ik+={8_
z7#KQxm@L*FxG@+aLvg%Cr2T1Hm4kPU_DoH+d2W$>CAbj!rlQx<&bezVid!>%gh_qj
znCR5ahD+68RofwA>ik1?w{id1WvC-@*j!L1>E>O;n}IdgS5M#b3K}>vOXZfHIbGr|
zMc`UHbE>(<2aMNFbPKxkVYoOv7fPHE$(W2H{(O69H2eXBt+Ii~B!aOfPLf)eFQ#zx
zn|f1xJ5gT-KhMpE_|&q}+Pg_iamrOXehh*_Jzs4v4xF8h+Z%puBFoC=0!0H!(gdFU
ze|)`VR94>?H3}jjWq@=kCEeYEbVzr1cb5_>(%m4^-Ca@-4Z=gGba(gN&+k9R9rwe1
z-!U8xKM3cXz1LoAt~ux4JAaJrsrcdEi7bC{jh<nhpF<!f(hmPiZ71H0?uFr9|0npC
zROdB*K^`KsMi$rZxGVQ6%F2R8;{%n176(`RDSqakUmqhTEYDjW%~9=gNlycwj7u*|
zV+Vie;S4v^m0Mr61pLLiB)a~wZ8~;85jAP$-M(soJ$rOI<f?qLk&)zvtAq4ow0yPb
zrTf_=iE%{J{I|R6!z@KJQ$e8w<$hJtLn_Wi?xcrm&p;0kC5>j|U*||6xYHCBCZccP
z+#_FXrW4*KPd=+XF?o08<Bk$OGNW|4V;eY!L58@JDfWd@=auNQ^qa>rLv9T^?lj&0
z;Y`9_m73nAff#RcjG>>LBXi!T(`zkl?+O>w)Zwacy{fIoP@bjW{>(V**YjIQT(qmt
z4Ay}JVs%|#w7m{$m{n4O!bbV@=xy)Nz`^8r&&>$NgF~%yw4PG$ntu~p-!bKMpMciE
zovSYG*x>Kk7H|#oC>_e;J8G^7Fa`^$$C||lw1Hx_<9pY^EuB-ny-r;Q?QVfY;Uj;L
z{c{}-#szY)r&q1=SN9M_JvQdH-FhvhV!EqZlXaeU^iFBRcd*qM2>K_MG7bd4&ruPh
zwF_8Sop_mvQz(r7V7E57O)<Wqzdfn2Jm`wFd(EK!aqEYAxI+i}vAfaDVwWR$QH{^T
z;hB(_W%)-MI2oQ6Z&CJ_a_9*Epv0E2pVM4xe9u2wqR0O8q;<h!9N)uh@&$>OU(F)+
zE4YUTBG@uLB*6-kMWTDT!Fth}Zo{X#a9HWo7{(LmGkbefxxhn<BGVXlkS~4BvZ81<
z_wd*3sdwD(y_Y7tgu>&*VIyJ|or;>tt5*6Hd~KXM&l1iP)sMCM6_*`~^vT4FhwuB~
zsGW)%ZnGC#uGCqzTD#*uynOUAVP7Mk%REq@&spopj5xmE^?;IHbG(drztGjT2n@o6
z4Ue&{HgdG$rZih?+Q?N7vJTC?@F1?ge@`S-W*H*+*M-a#$^u3sL_NYm<dat+2)-2$
zK8<KStzHZ;8e=120?Z&7Y@E1{7AIcj2B%?Aqcz@~Y5Xjn&otULFqUO(^6+|&<AiS=
zv5~rHYLQ#<ZwEiRq=EXIFfJi#5kceH9s=;dyslP~EGWh1=c4;L92suvMXG=v<2Yui
zyQ@uqtg&SF<oR8X91O*ad_ViEg@C{Klaq~NOrd7yyT$YTX3_U3BRx+WP*2et%N2)e
zvpo*03lN$i)<R37N`@FCb<&S~?r@pIgh8R{MT={(sKt$7oJs`rzU1mas@ceI*6Y3=
zFwUSu(zK@O7ojaf5kE7JLJY-g)SG)j3{lTRJwUMIQ8ak|Ahlm4Gebk&l6bDsiHN&z
z*8B5L{MEXZjNV!KXf{v08L{^woPJxoHJ&^tWY$mJw<fh~_U!=)bs}MGOx<($WYdeG
zM-!%Hh*{mdDGJ2V1f<2T&M}cbQ;1z~$dQft&7)0q6J4N=EqEu9doO)-gnMGkzq>aM
z-c+YU?hVs>gPeEE*jH&9%b&NEa&z-x`Jzu1I?unE;>VVtd35}z=ETO!1zp+OJ0)Jl
z*<G53O>m|spKtsxVHi&~rx5SA;ycfJ?-mLvpH}L?Vxc)vFDYU@OtpKTQHMhUVw<Vj
zX`;a`$fyxbq2>EdXvQ+&{^<?^JIGFUo5Yr8EQpF-k7iya3`O8{#5*j(5(TyoQ7H%t
zyxZ#nnqnyP6`-N1YK5YR3@oD9iVvUowkC%&drr>2+EhmnWB(g!`Yz5!GfoUv?bE~S
z(e^eTVMn<;2E!?7w2Wl@o?T?|v0e!|*X)R%_Vj<7OskTNMJ#u>?TcIipmItUG!v_0
zXf4fY1+d=fk{sXv8h&KhBYbSTps5~VLV1ddX^IB9B23@iH?{Y^I?q_rJG5AQ@y`f#
zuk-ZwKR31_1Z;J#(|-yQ4F`k1If+v%cIB&Qo`Kg6hj7(erP5X@4L}-hX`q6abCwRO
zeHp<DK3(44p#N5k<bDSwTnk~%tFdxb@2slY`U2^(brtW)T952889$mngXA4+4Vvyp
zs^l|g-CyAH24rO9qN1YDU=?sc-_~d`>`j-OL&ESsU>|Tr>SJ1^x-48hymQNqGkTYJ
zvRmuha8olhvQ-odGE?M}Q=HIR_}5w6u7{g;&DLRpU$jzhmiLEE`oB@I^CEz72IJ3Z
zEzE!?wBA0O+Rv97145)SYOq0o>Wc(baDD1>e((}m<)((<(NnyvnWg|-nVa+>-t$Zx
zAvcI|o(4Ay<ne@Vmt#DG?!*^LQmQsMeq_HU<JpN%dNrCNFAepuBR(AceUjCX@*4Z=
ziR+WD4$hH{bY7j*cO9hq-sh(?aSqi@=WunDZ_m01jN_)PK5Gtmnwe3YeM3%qyRI@}
z>2aJ-zHcW#>jZ)&BWbR9af%u|rHErsQ+=mD!eq^SIMw-<)jX<P)3lAq_3Cc(qtACe
zi}!z6V^J!+BGl~v3AK}K)pvQq@w3u|eW(8RF1CNJ6f00<b?u<ArJ4s{D&QSB0;tuL
z?9hz<JA9OmN*DQHWXxv+Srad)flx*>ZPB6+AA=L!uBWGM08O8BrRr&><!c?GzUlp3
z4i_(kcH)t>c5UUpQfAECdUZ`!`wE8T_+|I0wTMx^Z?cR8x#bgA!?Qy-O{D#&Y}C`P
zGVLM!4`iE|7h6k}?+zHte41Jdb6aXSzvg^2wzd@#lF)0di_|Q{{c|0-U3(F7-!M8e
zN3>!&>c54_Y)!@|{Lzo&%EvznV7rpHI4!QC`eqjwoO?41RRngA9>|TZtR>ixug6&L
z`R9a=S*f0tlu<vUXA6NVHV5ekOz(|_HZ5E=@@<8Q8@p4#fm%99*{ds=5lYaUu1WcR
zWUiM6CI!Ws({|%Kp7zeDnFq3>F@L7}Q>M+YOjVLRdjnYz&e4k3r07^MXO6b^{!~~0
z#(Oj4mneZ&y7UJWKA#qW@QGC|IF$q^JG||FQjYq}i-yea?XoK6*28Th8=KO8%QXc>
zLq-#%)g!kJpH9iy2U;6#HDE}B^9~tBSlp7hyi~!&Ip9PhD6lqwI`7ix@Uwq)FT;Tx
z!$wGaZ@+a0M~i_NS!jNJW=T!Y&p;mjt6nLBTBQ4Q+iRO8viGe+cRKR)1)CA&SIQcT
zLDi)JPs600!cWfSsUDQC;MJzF;1iO?zPK9tkS6w=6|apEQXnC7pNuW|?a!YiYP!bg
zDGfdd5m6OZASI)dq`ZQNVs#BYzL`nXgRId-Bx^<65$yLu*~o_vPodlB^z*6x$l6K;
zwj*jnJOhC}P;wN<YPLNh1Dp8yG>z`wc_kjVx!;puwJTaSgt8B^wFiryv-&+vJ64xF
zH#Wp9a~+kX4Ntq$nESR+op2D@stgg5{JDSq)yy67nF@!+jfFKTSg>Nni4|Z~+9nA_
z%A)r6hjBc>?WVZ2RI-HF8;AGH_@;w<4{zJTP*{$7Wm?61o!fiQ_EvP@AVJM1%c*y%
z@tn^LB%EG^`f<zJ#$vv-4k0}vmizJDlff>L@3n!ez-xnKsplHFBO~i?a2`C8QpAbd
zBGeWLJ`d_nr>cWHGzFMSBFsIVAy?5^j4l39xP|@UJEKDD@sp{{eAyRh0u!`)&5S7_
z(VOnn*wgH%OPkn!f>GfjtW=EYd=rsi)urlUGS}_)<i(#%W}w$myoH{QT+}2qyz{|Y
zwx~<Ln0fjn^rzzMRg!P1%xwH+8x1{o=enG^{TR__)6tQ8a|cB!erBGS)Ne>Nsq1Gh
z7z6@?Mr=1G-YJ$n!Idj^{CsRN%xukPe`bpA&Wo_X8L9pi3!Dp?`FRp4wKf>S(ux>Y
zPYy|Ot6J-<9spllMWS&u?>&6?)x2LOg^*fz1*SDXYJ>L5+gSC;H~+sel8ZC#v{i**
z5<i(;6?MIx@KyHEcF6<ni>ic^=WTr~yTwJrY_Z4IH@~nK?reA05BMAWji*VL$2TQy
zdH{i-Mq;{@=3q}ALm(87((F`JwTfB}y?w$s5ty8JxE`Tl<Gcw6!|REGJQG~h8ntQ~
z4z{FxQ=A#TX*ho}tf#Zxj`#jvFjA^_-a&p%j~(5?Z!JiqyCHj~=%HgcZPsPAZC7Km
zS?Arj{+=Y%aAZz=Sx2F)Vmow#vuOtlQT*lN2a_xYY3o!EPupkyM8n8oY~PlXjQtXu
zDWvYbxFfgxxZ3;|4^;2n58=KcHz&Eah@1cG;W)Yf%Rgm3BCN01L>th~Y1>kwPfkqv
z|K^gt&f)^7!_gJ;Y@*^<9V7+W@PA8{n;U)bk_?=W&*T|dBg}87`^YlVrUv&NNx@_t
zJ;V<^x#b#1g;`@fdP{Sk89n2RW25FQ4WlG{!?U!oXkK2muAd#y;Or7L%T}%xr#gK$
z5b5vOB5zA@g!p$}d)T2j^7<3+SxF_%ce{vBg{<w(r%DcuZT1vWMweU<QUZftT)*gD
z;1CUYz17Y|oW?j`sat^;^C;p|q2_J<THA|uZ6NcLW~V$dn<G*lbE^qn(5!umQfd{9
zd`q2RND&f)6aEnC>%KK*uVewsoFctJXnUr?;>j~O@!+P@CAo)TyBmg5+ttUTm(@bm
zM4-hK$i)R=B$5x+O(>5(dj|%`+>h_%)9R$UzUg9<E9}OHTqP+}Q`6>NdX0)Nrh^H!
zbDXZbDx7u;Gjh4uO@XncG39oo-MX1J@9Q*12nl1kGqn4)xz5@45cnn*GlX!$S3&;w
z!A<N@_hy|*RU5eDy5h3#(6Y{D3B8+qXz?_gd=asscG8*hT#aO8W70Z%$6Q=V^h?q!
z+(!-e7@@ULkEe2z7*y+PgHT7CK>!UG1mFMN7nZRtHAqYBCWJ~ju!EaKu1qT*P2Qc{
zOm=TAM*t9etvAv==5~YiMP$%e_9-H@8eg05Y+MONpv&Mdo1v!AfL1_CwcHzli{~6j
zxVtSAEgrR`pq>~kcNpmAa~<D}`6SrMa3HEN)=85jy&7QXx*s0+KKZ_|BIW6hJOeBc
zI5E#cPhWX<Uti*3!QQ1BC6cENJVe!SjR8|wiN1pbrx5=G2cNGV+P{p^pZw7}5c6{L
zvVGMY6;)s_2Cagf0E2760Rh<UeQr$W!=}yIZ0Fe99&fFozVQS1l}w#IqLwsUc?Jm3
z?^l}}u2MGKnvzb67yz@&7I@z=umF6h*H-s(jeNnwX~PkW59o9R=reFS0zlFY-vXCr
z{jtA_T<?9DZE0i)iS?Y+xjP}TBUv47&kstC*HEO2WhsrMR{qVe;a~OT>Ph-tZ9_sm
z7v<S(gv(~n^W$<w5wn*c6Z%cS3N-`3b#&TN!<8aZRpOL8TD@npoAsY7QOVmO)MDe>
z%cl{Kh?RDE&WF2Z5rwh#Q3f+z?QN}|9_r)<!^365k<*m((G(G%2R!f-I($Q^gh+SE
z>F-xu2-3fT1f<!-5WeqZjN6bM9?&d~SZQDqHCrkN7k@#pG@mx)?x=}JVO)P<9NX1s
zY(kb`R<<*p13f#;GZ9>lkD$O;7w~w>do+9c0)M?`L84H`FCRN1Tv5!Bxoo$z6-efi
zE5rE53%IG_uYu{9*Ch=c=nGZ8=WQqIGhufBLF((1-tctSl@mYV2>Rs~Us0jF3znlN
zkB>pfutvn+Phey!$4E~r^-o^V$E7srOaH`6Heu~PQ&@ScS;_#bE*gx<wWU9&b>zm`
z-)?5Wx3B~8L5I;;P2WE6>cnWc(noMELE6fZfz)1MZEz8PfxSC2I6Lsf*{)rdA<ZWK
z-dg3=6Tw?CFuO1mc17-qt;TiQ<w$wV8^MWMhB~t5{?KgB-`gT8^Y8B)xM%0Aj|~rG
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
Tw7uG?0Uyu(KKm-%LazM_e)Rvb

literal 0
HcmV?d00001

diff --git a/pendulum_rk2.csv b/pendulum_rk2.csv
new file mode 100644
index 000000000..ef57e1358
--- /dev/null
+++ b/pendulum_rk2.csv
@@ -0,0 +1,2002 @@
+t,alpha,alpha_dot
+0,0.5,0
+0.005,0.499941,-0.0235158
+0.01,0.499765,-0.0470266
+0.015,0.499471,-0.0705272
+0.02,0.49906,-0.0940127
+0.025,0.498531,-0.117478
+0.03,0.497885,-0.140918
+0.035,0.497122,-0.164327
+0.04,0.496242,-0.187701
+0.045,0.495245,-0.211035
+0.05,0.494131,-0.234323
+0.055,0.492901,-0.257561
+0.06,0.491556,-0.280742
+0.065,0.490094,-0.303864
+0.07,0.488517,-0.326919
+0.075,0.486825,-0.349904
+0.08,0.485018,-0.372812
+0.085,0.483097,-0.39564
+0.09,0.481062,-0.418382
+0.095,0.478913,-0.441033
+0.1,0.476651,-0.463588
+0.105,0.474277,-0.486042
+0.11,0.471791,-0.50839
+0.115,0.469193,-0.530627
+0.12,0.466485,-0.552747
+0.125,0.463666,-0.574747
+0.13,0.460737,-0.596621
+0.135,0.457699,-0.618363
+0.14,0.454553,-0.639969
+0.145,0.4513,-0.661435
+0.15,0.447939,-0.682754
+0.155,0.444472,-0.703923
+0.16,0.4409,-0.724935
+0.165,0.437223,-0.745787
+0.17,0.433442,-0.766473
+0.175,0.429558,-0.786989
+0.18,0.425572,-0.807329
+0.185,0.421485,-0.827489
+0.19,0.417297,-0.847463
+0.195,0.41301,-0.867248
+0.2,0.408625,-0.886837
+0.205,0.404142,-0.906227
+0.21,0.399563,-0.925413
+0.215,0.394888,-0.94439
+0.22,0.390119,-0.963152
+0.225,0.385256,-0.981697
+0.23,0.380302,-1.00002
+0.235,0.375256,-1.01811
+0.24,0.370121,-1.03597
+0.245,0.364896,-1.0536
+0.25,0.359585,-1.07098
+0.255,0.354187,-1.08812
+0.26,0.348703,-1.105
+0.265,0.343137,-1.12164
+0.27,0.337487,-1.13801
+0.275,0.331756,-1.15412
+0.28,0.325946,-1.16996
+0.285,0.320057,-1.18553
+0.29,0.314091,-1.20082
+0.295,0.308049,-1.21584
+0.3,0.301932,-1.23057
+0.305,0.295743,-1.24501
+0.31,0.289482,-1.25916
+0.315,0.283151,-1.27301
+0.32,0.276752,-1.28657
+0.325,0.270286,-1.29982
+0.33,0.263754,-1.31276
+0.335,0.257158,-1.32539
+0.34,0.2505,-1.33771
+0.345,0.243781,-1.34971
+0.35,0.237003,-1.36139
+0.355,0.230167,-1.37274
+0.36,0.223275,-1.38377
+0.365,0.216329,-1.39446
+0.37,0.209331,-1.40483
+0.375,0.202281,-1.41485
+0.38,0.195182,-1.42453
+0.385,0.188036,-1.43388
+0.39,0.180844,-1.44287
+0.395,0.173607,-1.45152
+0.4,0.166328,-1.45982
+0.405,0.159009,-1.46776
+0.41,0.151651,-1.47535
+0.415,0.144256,-1.48258
+0.42,0.136825,-1.48945
+0.425,0.129361,-1.49596
+0.43,0.121865,-1.50211
+0.435,0.11434,-1.50789
+0.44,0.106787,-1.5133
+0.445,0.0992069,-1.51834
+0.45,0.0916031,-1.52302
+0.455,0.0839768,-1.52732
+0.46,0.0763299,-1.53124
+0.465,0.0686643,-1.5348
+0.47,0.0609819,-1.53797
+0.475,0.0532846,-1.54078
+0.48,0.0455742,-1.5432
+0.485,0.0378526,-1.54524
+0.49,0.0301217,-1.54691
+0.495,0.0223835,-1.5482
+0.5,0.0146397,-1.54911
+0.505,0.00689241,-1.54964
+0.51,-0.000856612,-1.54978
+0.515,-0.00860542,-1.54955
+0.52,-0.0163521,-1.54894
+0.525,-0.0240948,-1.54795
+0.53,-0.0318316,-1.54658
+0.535,-0.0395606,-1.54483
+0.54,-0.0472799,-1.5427
+0.545,-0.0549875,-1.54019
+0.55,-0.0626817,-1.5373
+0.555,-0.0703606,-1.53404
+0.56,-0.0780222,-1.53041
+0.565,-0.0856647,-1.5264
+0.57,-0.0932862,-1.52201
+0.575,-0.100885,-1.51726
+0.58,-0.108459,-1.51213
+0.585,-0.116006,-1.50664
+0.59,-0.123525,-1.50078
+0.595,-0.131014,-1.49455
+0.6,-0.138471,-1.48796
+0.605,-0.145894,-1.48101
+0.61,-0.153281,-1.4737
+0.615,-0.160631,-1.46604
+0.62,-0.167941,-1.45801
+0.625,-0.175211,-1.44964
+0.63,-0.182438,-1.44091
+0.635,-0.18962,-1.43184
+0.64,-0.196756,-1.42242
+0.645,-0.203844,-1.41266
+0.65,-0.210883,-1.40256
+0.655,-0.21787,-1.39213
+0.66,-0.224804,-1.38136
+0.665,-0.231683,-1.37026
+0.67,-0.238507,-1.35883
+0.675,-0.245272,-1.34708
+0.68,-0.251977,-1.33501
+0.685,-0.258622,-1.32263
+0.69,-0.265204,-1.30993
+0.695,-0.271721,-1.29691
+0.7,-0.278173,-1.2836
+0.705,-0.284557,-1.26998
+0.71,-0.290873,-1.25606
+0.715,-0.297118,-1.24184
+0.72,-0.303291,-1.22734
+0.725,-0.309391,-1.21254
+0.73,-0.315416,-1.19747
+0.735,-0.321366,-1.18211
+0.74,-0.327238,-1.16648
+0.745,-0.333031,-1.15058
+0.75,-0.338743,-1.13441
+0.755,-0.344375,-1.11798
+0.76,-0.349923,-1.10129
+0.765,-0.355388,-1.08435
+0.77,-0.360767,-1.06716
+0.775,-0.366059,-1.04972
+0.78,-0.371264,-1.03204
+0.785,-0.37638,-1.01413
+0.79,-0.381405,-0.995988
+0.795,-0.38634,-0.977617
+0.8,-0.391181,-0.959024
+0.805,-0.39593,-0.940213
+0.81,-0.400584,-0.92119
+0.815,-0.405142,-0.901959
+0.82,-0.409603,-0.882524
+0.825,-0.413967,-0.862891
+0.83,-0.418232,-0.843064
+0.835,-0.422398,-0.823048
+0.84,-0.426463,-0.802848
+0.845,-0.430426,-0.782469
+0.85,-0.434287,-0.761915
+0.855,-0.438045,-0.741192
+0.86,-0.441699,-0.720304
+0.865,-0.445248,-0.699257
+0.87,-0.448692,-0.678054
+0.875,-0.452029,-0.656702
+0.88,-0.455259,-0.635205
+0.885,-0.458381,-0.613568
+0.89,-0.461394,-0.591796
+0.895,-0.464299,-0.569894
+0.9,-0.467093,-0.547868
+0.905,-0.469778,-0.525721
+0.91,-0.472351,-0.503459
+0.915,-0.474812,-0.481087
+0.92,-0.477162,-0.458611
+0.925,-0.479398,-0.436034
+0.93,-0.481522,-0.413362
+0.935,-0.483532,-0.390601
+0.94,-0.485428,-0.367755
+0.945,-0.487209,-0.344829
+0.95,-0.488876,-0.321828
+0.955,-0.490428,-0.298758
+0.96,-0.491864,-0.275623
+0.965,-0.493184,-0.252428
+0.97,-0.494388,-0.229179
+0.975,-0.495476,-0.20588
+0.98,-0.496447,-0.182537
+0.985,-0.497301,-0.159155
+0.99,-0.498038,-0.135738
+0.995,-0.498659,-0.112292
+1,-0.499161,-0.0888221
+1.005,-0.499547,-0.0653329
+1.01,-0.499815,-0.0418295
+1.015,-0.499965,-0.0183172
+1.02,-0.499998,0.00519911
+1.025,-0.499913,0.0287143
+1.03,-0.499711,0.0522233
+1.035,-0.499391,0.075721
+1.04,-0.498954,0.0992025
+1.045,-0.498399,0.122663
+1.05,-0.497727,0.146096
+1.055,-0.496938,0.169498
+1.06,-0.496032,0.192864
+1.065,-0.495009,0.216188
+1.07,-0.49387,0.239465
+1.075,-0.492615,0.262691
+1.08,-0.491243,0.28586
+1.085,-0.489756,0.308967
+1.09,-0.488153,0.332007
+1.095,-0.486436,0.354975
+1.1,-0.484604,0.377867
+1.105,-0.482657,0.400676
+1.11,-0.480597,0.423398
+1.115,-0.478423,0.446029
+1.12,-0.476137,0.468562
+1.125,-0.473738,0.490993
+1.13,-0.471227,0.513316
+1.135,-0.468605,0.535528
+1.14,-0.465871,0.557622
+1.145,-0.463028,0.579595
+1.15,-0.460076,0.60144
+1.155,-0.457014,0.623153
+1.16,-0.453844,0.644728
+1.165,-0.450567,0.666162
+1.17,-0.447182,0.687448
+1.175,-0.443692,0.708583
+1.18,-0.440097,0.72956
+1.185,-0.436397,0.750376
+1.19,-0.432593,0.771025
+1.195,-0.428686,0.791502
+1.2,-0.424678,0.811803
+1.205,-0.420568,0.831922
+1.21,-0.416359,0.851855
+1.215,-0.41205,0.871597
+1.22,-0.407643,0.891143
+1.225,-0.403138,0.910488
+1.23,-0.398538,0.929628
+1.235,-0.393842,0.948558
+1.24,-0.389052,0.967273
+1.245,-0.384169,0.985768
+1.25,-0.379195,1.00404
+1.255,-0.374129,1.02208
+1.26,-0.368974,1.03989
+1.265,-0.36373,1.05746
+1.27,-0.358399,1.07479
+1.275,-0.352982,1.09187
+1.28,-0.34748,1.1087
+1.285,-0.341895,1.12528
+1.29,-0.336228,1.14159
+1.295,-0.330479,1.15764
+1.3,-0.324651,1.17343
+1.305,-0.318745,1.18894
+1.31,-0.312762,1.20417
+1.315,-0.306703,1.21912
+1.32,-0.300571,1.23379
+1.325,-0.294365,1.24816
+1.33,-0.288089,1.26225
+1.335,-0.281743,1.27604
+1.34,-0.275329,1.28952
+1.345,-0.268848,1.30271
+1.35,-0.262302,1.31558
+1.355,-0.255692,1.32814
+1.36,-0.24902,1.34039
+1.365,-0.242288,1.35232
+1.37,-0.235497,1.36393
+1.375,-0.228649,1.37521
+1.38,-0.221745,1.38616
+1.385,-0.214787,1.39679
+1.39,-0.207777,1.40707
+1.395,-0.200716,1.41702
+1.4,-0.193607,1.42663
+1.405,-0.18645,1.4359
+1.41,-0.179248,1.44482
+1.415,-0.172002,1.45339
+1.42,-0.164714,1.46161
+1.425,-0.157386,1.46947
+1.43,-0.150019,1.47698
+1.435,-0.142616,1.48413
+1.44,-0.135178,1.49092
+1.445,-0.127707,1.49735
+1.45,-0.120204,1.50342
+1.455,-0.112673,1.50912
+1.46,-0.105113,1.51445
+1.465,-0.0975281,1.51941
+1.47,-0.0899191,1.524
+1.475,-0.0822881,1.52822
+1.48,-0.0746369,1.53206
+1.485,-0.0669674,1.53553
+1.49,-0.0592815,1.53863
+1.495,-0.0515811,1.54135
+1.5,-0.0438681,1.54369
+1.505,-0.0361443,1.54565
+1.51,-0.0284116,1.54723
+1.515,-0.020672,1.54844
+1.52,-0.0129272,1.54926
+1.525,-0.00517936,1.5497
+1.53,0.00256979,1.54977
+1.535,0.0103183,1.54945
+1.54,0.0180643,1.54876
+1.545,0.0258059,1.54768
+1.55,0.0335411,1.54622
+1.555,0.0412681,1.54439
+1.56,0.048985,1.54218
+1.565,0.0566899,1.53959
+1.57,0.0643808,1.53662
+1.575,0.0720561,1.53327
+1.58,0.0797136,1.52956
+1.585,0.0873516,1.52546
+1.59,0.0949682,1.521
+1.595,0.102562,1.51616
+1.6,0.11013,1.51095
+1.605,0.117671,1.50538
+1.61,0.125184,1.49944
+1.615,0.132666,1.49313
+1.62,0.140115,1.48646
+1.625,0.14753,1.47943
+1.63,0.154909,1.47204
+1.635,0.162251,1.46429
+1.64,0.169552,1.45619
+1.645,0.176812,1.44774
+1.65,0.18403,1.43894
+1.655,0.191202,1.42979
+1.66,0.198328,1.4203
+1.665,0.205405,1.41046
+1.67,0.212432,1.40029
+1.675,0.219408,1.38978
+1.68,0.22633,1.37894
+1.685,0.233197,1.36776
+1.69,0.240008,1.35627
+1.695,0.24676,1.34445
+1.7,0.253452,1.3323
+1.705,0.260083,1.31985
+1.71,0.266651,1.30708
+1.715,0.273154,1.294
+1.72,0.27959,1.28061
+1.725,0.28596,1.26693
+1.73,0.29226,1.25294
+1.735,0.298489,1.23866
+1.74,0.304646,1.22409
+1.745,0.31073,1.20924
+1.75,0.316739,1.1941
+1.755,0.322671,1.17868
+1.76,0.328526,1.16299
+1.765,0.334301,1.14703
+1.77,0.339996,1.1308
+1.775,0.345609,1.11432
+1.78,0.351139,1.09757
+1.785,0.356585,1.08057
+1.79,0.361945,1.06333
+1.795,0.367218,1.04584
+1.8,0.372403,1.02811
+1.805,0.377499,1.01014
+1.81,0.382505,0.991947
+1.815,0.387419,0.973527
+1.82,0.39224,0.954885
+1.825,0.396967,0.936027
+1.83,0.4016,0.916957
+1.835,0.406137,0.897681
+1.84,0.410577,0.878202
+1.845,0.414919,0.858525
+1.85,0.419162,0.838656
+1.855,0.423306,0.818599
+1.86,0.427348,0.798359
+1.865,0.431289,0.777941
+1.87,0.435128,0.757349
+1.875,0.438863,0.736589
+1.88,0.442493,0.715666
+1.885,0.446019,0.694584
+1.89,0.449439,0.673348
+1.895,0.452753,0.651963
+1.9,0.455959,0.630435
+1.905,0.459057,0.608767
+1.91,0.462047,0.586966
+1.915,0.464927,0.565036
+1.92,0.467697,0.542982
+1.925,0.470357,0.52081
+1.93,0.472905,0.498523
+1.935,0.475342,0.476128
+1.94,0.477666,0.453628
+1.945,0.479878,0.43103
+1.95,0.481977,0.408339
+1.955,0.483962,0.385558
+1.96,0.485832,0.362694
+1.965,0.487588,0.339751
+1.97,0.48923,0.316734
+1.975,0.490756,0.293649
+1.98,0.492166,0.2705
+1.985,0.493461,0.247293
+1.99,0.494639,0.224033
+1.995,0.495701,0.200724
+2,0.496646,0.177372
+2.005,0.497475,0.153981
+2.01,0.498186,0.130557
+2.015,0.49878,0.107106
+2.02,0.499257,0.0836309
+2.025,0.499617,0.060138
+2.03,0.499859,0.0366322
+2.035,0.499983,0.0131185
+2.04,0.49999,-0.010398
+2.045,0.499879,-0.0339122
+2.05,0.499651,-0.0574192
+2.055,0.499305,-0.0809138
+2.06,0.498842,-0.104391
+2.065,0.498261,-0.127846
+2.07,0.497563,-0.151273
+2.075,0.496748,-0.174667
+2.08,0.495817,-0.198024
+2.085,0.494768,-0.221339
+2.09,0.493603,-0.244605
+2.095,0.492322,-0.267818
+2.1,0.490925,-0.290974
+2.105,0.489412,-0.314067
+2.11,0.487784,-0.337092
+2.115,0.486041,-0.360043
+2.12,0.484184,-0.382917
+2.125,0.482212,-0.405708
+2.13,0.480127,-0.42841
+2.135,0.477928,-0.451019
+2.14,0.475617,-0.47353
+2.145,0.473193,-0.495938
+2.15,0.470657,-0.518237
+2.155,0.468011,-0.540423
+2.16,0.465253,-0.562491
+2.165,0.462386,-0.584436
+2.17,0.459409,-0.606252
+2.175,0.456323,-0.627935
+2.18,0.453129,-0.64948
+2.185,0.449828,-0.670881
+2.19,0.446421,-0.692135
+2.195,0.442907,-0.713235
+2.2,0.439288,-0.734177
+2.205,0.435565,-0.754956
+2.21,0.431739,-0.775568
+2.215,0.42781,-0.796006
+2.22,0.423779,-0.816267
+2.225,0.419647,-0.836346
+2.23,0.415415,-0.856237
+2.235,0.411084,-0.875936
+2.24,0.406656,-0.895438
+2.245,0.40213,-0.914738
+2.25,0.397508,-0.933832
+2.255,0.392792,-0.952715
+2.26,0.387981,-0.971382
+2.265,0.383078,-0.989828
+2.27,0.378083,-1.00805
+2.275,0.372997,-1.02604
+2.28,0.367823,-1.0438
+2.285,0.36256,-1.06132
+2.29,0.357209,-1.07859
+2.295,0.351774,-1.09562
+2.3,0.346253,-1.11239
+2.305,0.34065,-1.12891
+2.31,0.334964,-1.14517
+2.315,0.329198,-1.16116
+2.32,0.323353,-1.17688
+2.325,0.317429,-1.19233
+2.33,0.311429,-1.2075
+2.335,0.305354,-1.22239
+2.34,0.299205,-1.23699
+2.345,0.292984,-1.25131
+2.35,0.286692,-1.26532
+2.355,0.280331,-1.27905
+2.36,0.273902,-1.29247
+2.365,0.267406,-1.30558
+2.37,0.260846,-1.31839
+2.375,0.254223,-1.33088
+2.38,0.247537,-1.34306
+2.385,0.240792,-1.35492
+2.39,0.233988,-1.36645
+2.395,0.227127,-1.37766
+2.4,0.220212,-1.38854
+2.405,0.213242,-1.39909
+2.41,0.206221,-1.4093
+2.415,0.199149,-1.41918
+2.42,0.192029,-1.42871
+2.425,0.184862,-1.4379
+2.43,0.17765,-1.44674
+2.435,0.170394,-1.45524
+2.44,0.163098,-1.46338
+2.445,0.155761,-1.47116
+2.45,0.148386,-1.4786
+2.455,0.140975,-1.48567
+2.46,0.133529,-1.49238
+2.465,0.126051,-1.49873
+2.47,0.118542,-1.50471
+2.475,0.111004,-1.51033
+2.48,0.103439,-1.51558
+2.485,0.0958481,-1.52046
+2.49,0.088234,-1.52497
+2.495,0.0805984,-1.5291
+2.5,0.072943,-1.53287
+2.505,0.0652697,-1.53625
+2.51,0.0575805,-1.53926
+2.515,0.0498771,-1.5419
+2.52,0.0421615,-1.54415
+2.525,0.0344356,-1.54603
+2.53,0.0267012,-1.54753
+2.535,0.0189602,-1.54865
+2.54,0.0112147,-1.54939
+2.545,0.00346632,-1.54975
+2.55,-0.00428287,-1.54973
+2.555,-0.012031,-1.54933
+2.56,-0.0197762,-1.54855
+2.565,-0.0275165,-1.54739
+2.57,-0.0352501,-1.54585
+2.575,-0.0429751,-1.54394
+2.58,-0.0506895,-1.54164
+2.585,-0.0583914,-1.53896
+2.59,-0.0660791,-1.53591
+2.595,-0.0737506,-1.53249
+2.6,-0.081404,-1.52869
+2.605,-0.0890374,-1.52451
+2.61,-0.0966491,-1.51996
+2.615,-0.104237,-1.51504
+2.62,-0.1118,-1.50976
+2.625,-0.119335,-1.5041
+2.63,-0.126841,-1.49808
+2.635,-0.134315,-1.49169
+2.64,-0.141757,-1.48494
+2.645,-0.149165,-1.47783
+2.65,-0.156536,-1.47036
+2.655,-0.163868,-1.46254
+2.66,-0.171161,-1.45436
+2.665,-0.178412,-1.44583
+2.67,-0.185619,-1.43695
+2.675,-0.192781,-1.42772
+2.68,-0.199897,-1.41815
+2.685,-0.206963,-1.40824
+2.69,-0.213979,-1.398
+2.695,-0.220943,-1.38741
+2.7,-0.227853,-1.3765
+2.705,-0.234708,-1.36525
+2.71,-0.241506,-1.35368
+2.715,-0.248245,-1.34179
+2.72,-0.254924,-1.32958
+2.725,-0.261541,-1.31705
+2.73,-0.268094,-1.30421
+2.735,-0.274583,-1.29107
+2.74,-0.281005,-1.27761
+2.745,-0.287359,-1.26386
+2.75,-0.293643,-1.24981
+2.755,-0.299857,-1.23547
+2.76,-0.305998,-1.22083
+2.765,-0.312065,-1.20592
+2.77,-0.318057,-1.19072
+2.775,-0.323972,-1.17524
+2.78,-0.32981,-1.15949
+2.785,-0.335567,-1.14347
+2.79,-0.341244,-1.12718
+2.795,-0.346839,-1.11064
+2.8,-0.352351,-1.09384
+2.805,-0.357778,-1.07678
+2.81,-0.363119,-1.05948
+2.815,-0.368372,-1.04194
+2.82,-0.373538,-1.02416
+2.825,-0.378614,-1.00614
+2.83,-0.383599,-0.987896
+2.835,-0.388493,-0.969426
+2.84,-0.393294,-0.950736
+2.845,-0.398,-0.931831
+2.85,-0.402612,-0.912715
+2.855,-0.407127,-0.893393
+2.86,-0.411546,-0.87387
+2.865,-0.415866,-0.854151
+2.87,-0.420087,-0.83424
+2.875,-0.424209,-0.814142
+2.88,-0.428229,-0.793862
+2.885,-0.432147,-0.773405
+2.89,-0.435963,-0.752775
+2.895,-0.439675,-0.731979
+2.9,-0.443283,-0.71102
+2.905,-0.446785,-0.689903
+2.91,-0.450182,-0.668634
+2.915,-0.453471,-0.647217
+2.92,-0.456654,-0.625657
+2.925,-0.459728,-0.60396
+2.93,-0.462693,-0.58213
+2.935,-0.465549,-0.560172
+2.94,-0.468295,-0.538092
+2.945,-0.47093,-0.515893
+2.95,-0.473454,-0.493582
+2.955,-0.475866,-0.471163
+2.96,-0.478166,-0.448642
+2.965,-0.480353,-0.426023
+2.97,-0.482426,-0.403311
+2.975,-0.484386,-0.380511
+2.98,-0.486231,-0.357629
+2.985,-0.487962,-0.334669
+2.99,-0.489578,-0.311637
+2.995,-0.491078,-0.288537
+3,-0.492463,-0.265375
+3.005,-0.493732,-0.242156
+3.01,-0.494885,-0.218884
+3.015,-0.495921,-0.195565
+3.02,-0.49684,-0.172204
+3.025,-0.497643,-0.148806
+3.03,-0.498328,-0.125376
+3.035,-0.498897,-0.101918
+3.04,-0.499348,-0.0784389
+3.045,-0.499681,-0.0549428
+3.05,-0.499897,-0.0314348
+3.055,-0.499995,-0.00791998
+3.06,-0.499976,0.0155965
+3.065,-0.49984,0.0391096
+3.07,-0.499585,0.0626143
+3.075,-0.499213,0.0861056
+3.08,-0.498724,0.109578
+3.085,-0.498118,0.133027
+3.09,-0.497394,0.156448
+3.095,-0.496553,0.179834
+3.1,-0.495596,0.203182
+3.105,-0.494521,0.226486
+3.11,-0.493331,0.249742
+3.115,-0.492024,0.272943
+3.12,-0.490601,0.296085
+3.125,-0.489063,0.319163
+3.13,-0.48741,0.342172
+3.135,-0.485641,0.365107
+3.14,-0.483759,0.387963
+3.145,-0.481762,0.410735
+3.15,-0.479651,0.433417
+3.155,-0.477428,0.456005
+3.16,-0.475091,0.478493
+3.165,-0.472643,0.500878
+3.17,-0.470082,0.523152
+3.175,-0.467411,0.545313
+3.18,-0.464629,0.567354
+3.185,-0.461738,0.589271
+3.19,-0.458737,0.611058
+3.195,-0.455627,0.632711
+3.2,-0.45241,0.654224
+3.205,-0.449085,0.675594
+3.21,-0.445654,0.696814
+3.215,-0.442117,0.717879
+3.22,-0.438475,0.738786
+3.225,-0.434729,0.759528
+3.23,-0.43088,0.780102
+3.235,-0.426928,0.800502
+3.24,-0.422874,0.820723
+3.245,-0.418721,0.84076
+3.25,-0.414467,0.860609
+3.255,-0.410114,0.880265
+3.26,-0.405664,0.899723
+3.265,-0.401117,0.918978
+3.27,-0.396474,0.938026
+3.275,-0.391737,0.956861
+3.28,-0.386906,0.97548
+3.285,-0.381982,0.993877
+3.29,-0.376967,1.01205
+3.295,-0.371862,1.02999
+3.3,-0.366667,1.04769
+3.305,-0.361385,1.06516
+3.31,-0.356016,1.08238
+3.315,-0.350561,1.09935
+3.32,-0.345022,1.11607
+3.325,-0.3394,1.13253
+3.33,-0.333697,1.14873
+3.335,-0.327913,1.16466
+3.34,-0.32205,1.18032
+3.345,-0.31611,1.19571
+3.35,-0.310093,1.21082
+3.355,-0.304002,1.22564
+3.36,-0.297837,1.24018
+3.365,-0.2916,1.25443
+3.37,-0.285292,1.26839
+3.375,-0.278916,1.28204
+3.38,-0.272472,1.29539
+3.385,-0.265962,1.30844
+3.39,-0.259388,1.32118
+3.395,-0.25275,1.3336
+3.4,-0.246052,1.34571
+3.405,-0.239293,1.3575
+3.41,-0.232477,1.36896
+3.415,-0.225604,1.3801
+3.42,-0.218676,1.3909
+3.425,-0.211695,1.40138
+3.43,-0.204662,1.41152
+3.435,-0.197579,1.42132
+3.44,-0.190449,1.43077
+3.445,-0.183272,1.43989
+3.45,-0.17605,1.44865
+3.455,-0.168785,1.45707
+3.46,-0.161479,1.46513
+3.465,-0.154134,1.47284
+3.47,-0.146751,1.48019
+3.475,-0.139332,1.48718
+3.48,-0.131879,1.49382
+3.485,-0.124394,1.50008
+3.49,-0.116878,1.50599
+3.495,-0.109334,1.51152
+3.5,-0.101763,1.51669
+3.505,-0.094167,1.52149
+3.51,-0.086548,1.52592
+3.515,-0.0789079,1.52997
+3.52,-0.0712483,1.53365
+3.525,-0.0635714,1.53695
+3.53,-0.0558788,1.53988
+3.535,-0.0481726,1.54243
+3.54,-0.0404545,1.5446
+3.545,-0.0327265,1.5464
+3.55,-0.0249905,1.54781
+3.555,-0.0172484,1.54885
+3.56,-0.009502,1.54951
+3.565,-0.0017533,1.54978
+3.57,0.00599583,1.54968
+3.575,0.0137435,1.54919
+3.58,0.0214878,1.54833
+3.585,0.0292268,1.54709
+3.59,0.0369586,1.54546
+3.595,0.0446814,1.54346
+3.6,0.0523933,1.54108
+3.605,0.0600923,1.53832
+3.61,0.0677765,1.53519
+3.615,0.0754442,1.53168
+3.62,0.0830933,1.5278
+3.625,0.0907221,1.52354
+3.63,0.0983287,1.51891
+3.635,0.105911,1.51391
+3.64,0.113468,1.50854
+3.645,0.120997,1.5028
+3.65,0.128496,1.4967
+3.655,0.135964,1.49023
+3.66,0.143398,1.4834
+3.665,0.150798,1.47621
+3.67,0.15816,1.46866
+3.675,0.165484,1.46076
+3.68,0.172768,1.4525
+3.685,0.180009,1.4439
+3.69,0.187207,1.43494
+3.695,0.194359,1.42564
+3.7,0.201463,1.41599
+3.705,0.208519,1.40601
+3.71,0.215523,1.39569
+3.715,0.222476,1.38503
+3.72,0.229374,1.37404
+3.725,0.236216,1.36272
+3.73,0.243001,1.35108
+3.735,0.249727,1.33912
+3.74,0.256392,1.32684
+3.745,0.262995,1.31424
+3.75,0.269535,1.30134
+3.755,0.276009,1.28812
+3.76,0.282416,1.2746
+3.765,0.288755,1.26078
+3.77,0.295024,1.24667
+3.775,0.301221,1.23226
+3.78,0.307346,1.21756
+3.785,0.313397,1.20258
+3.79,0.319372,1.18732
+3.795,0.32527,1.17178
+3.8,0.33109,1.15597
+3.805,0.33683,1.13989
+3.81,0.342489,1.12355
+3.815,0.348065,1.10695
+3.82,0.353558,1.09009
+3.825,0.358966,1.07298
+3.83,0.364288,1.05563
+3.835,0.369522,1.03803
+3.84,0.374668,1.0202
+3.845,0.379724,1.00213
+3.85,0.38469,0.983833
+3.855,0.389563,0.965314
+3.86,0.394343,0.946577
+3.865,0.399029,0.927624
+3.87,0.403619,0.908463
+3.875,0.408113,0.889096
+3.88,0.41251,0.869529
+3.885,0.416808,0.849767
+3.89,0.421008,0.829814
+3.895,0.425107,0.809675
+3.9,0.429104,0.789356
+3.905,0.433,0.76886
+3.91,0.436793,0.748193
+3.915,0.440482,0.72736
+3.92,0.444067,0.706366
+3.925,0.447546,0.685215
+3.93,0.450919,0.663913
+3.935,0.454185,0.642464
+3.94,0.457343,0.620874
+3.945,0.460394,0.599146
+3.95,0.463335,0.577288
+3.955,0.466167,0.555302
+3.96,0.468888,0.533195
+3.965,0.471498,0.510972
+3.97,0.473998,0.488636
+3.975,0.476385,0.466194
+3.98,0.47866,0.443651
+3.985,0.480821,0.42101
+3.99,0.48287,0.398279
+3.995,0.484804,0.37546
+4,0.486624,0.352561
+4.005,0.48833,0.329584
+4.01,0.48992,0.306537
+4.015,0.491395,0.283423
+4.02,0.492754,0.260248
+4.025,0.493998,0.237016
+4.03,0.495125,0.213734
+4.035,0.496135,0.190405
+4.04,0.497029,0.167035
+4.045,0.497805,0.143629
+4.05,0.498465,0.120193
+4.055,0.499007,0.0967299
+4.06,0.499432,0.0732464
+4.065,0.49974,0.0497471
+4.07,0.49993,0.0262371
+4.075,0.500002,0.00272153
+4.08,0.499957,-0.0207947
+4.085,0.499794,-0.0443064
+4.09,0.499514,-0.0678086
+4.095,0.499116,-0.0912962
+4.1,0.498601,-0.114764
+4.105,0.497968,-0.138207
+4.11,0.497219,-0.161621
+4.115,0.496352,-0.184999
+4.12,0.495369,-0.208338
+4.125,0.494269,-0.231632
+4.13,0.493053,-0.254876
+4.135,0.49172,-0.278064
+4.14,0.490272,-0.301193
+4.145,0.488708,-0.324256
+4.15,0.487029,-0.347249
+4.155,0.485236,-0.370167
+4.16,0.483328,-0.393005
+4.165,0.481306,-0.415757
+4.17,0.47917,-0.438419
+4.175,0.476921,-0.460985
+4.18,0.47456,-0.483451
+4.185,0.472087,-0.505812
+4.19,0.469502,-0.528062
+4.195,0.466806,-0.550196
+4.2,0.464,-0.57221
+4.205,0.461084,-0.594099
+4.21,0.458059,-0.615857
+4.215,0.454926,-0.637479
+4.22,0.451684,-0.658962
+4.225,0.448336,-0.680298
+4.23,0.444881,-0.701485
+4.235,0.441321,-0.722516
+4.24,0.437656,-0.743386
+4.245,0.433887,-0.764092
+4.25,0.430015,-0.784628
+4.255,0.426041,-0.804988
+4.26,0.421965,-0.825169
+4.265,0.417789,-0.845166
+4.27,0.413514,-0.864972
+4.275,0.40914,-0.884585
+4.28,0.404668,-0.903999
+4.285,0.4001,-0.923208
+4.29,0.395436,-0.942209
+4.295,0.390678,-0.960997
+4.3,0.385826,-0.979567
+4.305,0.380882,-0.997915
+4.31,0.375847,-1.01603
+4.315,0.370722,-1.03392
+4.32,0.365508,-1.05158
+4.325,0.360206,-1.06899
+4.33,0.354818,-1.08615
+4.335,0.349344,-1.10307
+4.34,0.343787,-1.11973
+4.345,0.338147,-1.13613
+4.35,0.332426,-1.15227
+4.355,0.326624,-1.16815
+4.36,0.320744,-1.18375
+4.365,0.314787,-1.19907
+4.37,0.308754,-1.21412
+4.375,0.302646,-1.22888
+4.38,0.296465,-1.24336
+4.385,0.290212,-1.25754
+4.39,0.283889,-1.27143
+4.395,0.277498,-1.28502
+4.4,0.271039,-1.29831
+4.405,0.264515,-1.31128
+4.41,0.257926,-1.32395
+4.415,0.251275,-1.33631
+4.42,0.244563,-1.34834
+4.425,0.237792,-1.36006
+4.43,0.230963,-1.37145
+4.435,0.224077,-1.38252
+4.44,0.217137,-1.39325
+4.445,0.210145,-1.40365
+4.45,0.203101,-1.41371
+4.455,0.196008,-1.42344
+4.46,0.188867,-1.43282
+4.465,0.181679,-1.44186
+4.47,0.174448,-1.45054
+4.475,0.167174,-1.45888
+4.48,0.159859,-1.46687
+4.485,0.152505,-1.4745
+4.49,0.145114,-1.48177
+4.495,0.137688,-1.48868
+4.5,0.130227,-1.49524
+4.505,0.122735,-1.50142
+4.51,0.115213,-1.50725
+4.515,0.107663,-1.5127
+4.52,0.100086,-1.51779
+4.525,0.0924849,-1.5225
+4.53,0.0848611,-1.52685
+4.535,0.0772164,-1.53082
+4.54,0.0695529,-1.53441
+4.545,0.0618723,-1.53763
+4.55,0.0541765,-1.54048
+4.555,0.0464675,-1.54295
+4.56,0.0387471,-1.54504
+4.565,0.0310171,-1.54675
+4.57,0.0232796,-1.54808
+4.575,0.0155364,-1.54903
+4.58,0.0077893,-1.5496
+4.585,4.03298e-05,-1.54979
+4.59,-0.00770865,-1.54961
+4.595,-0.0154557,-1.54904
+4.6,-0.023199,-1.54809
+4.605,-0.0309366,-1.54676
+4.61,-0.0386667,-1.54506
+4.615,-0.0463872,-1.54297
+4.62,-0.0540964,-1.54051
+4.625,-0.0617923,-1.53767
+4.63,-0.069473,-1.53445
+4.635,-0.0771368,-1.53086
+4.64,-0.0847816,-1.52689
+4.645,-0.0924057,-1.52255
+4.65,-0.100007,-1.51784
+4.655,-0.107584,-1.51276
+4.66,-0.115135,-1.5073
+4.665,-0.122657,-1.50149
+4.67,-0.13015,-1.4953
+4.675,-0.13761,-1.48875
+4.68,-0.145037,-1.48184
+4.685,-0.152429,-1.47458
+4.69,-0.159783,-1.46695
+4.695,-0.167098,-1.45897
+4.7,-0.174373,-1.45063
+4.705,-0.181604,-1.44195
+4.71,-0.188792,-1.43292
+4.715,-0.195934,-1.42354
+4.72,-0.203027,-1.41382
+4.725,-0.210072,-1.40376
+4.73,-0.217065,-1.39336
+4.735,-0.224005,-1.38263
+4.74,-0.230891,-1.37157
+4.745,-0.237721,-1.36018
+4.75,-0.244493,-1.34847
+4.755,-0.251206,-1.33643
+4.76,-0.257857,-1.32408
+4.765,-0.264447,-1.31142
+4.77,-0.270972,-1.29844
+4.775,-0.277431,-1.28516
+4.78,-0.283823,-1.27158
+4.785,-0.290147,-1.25769
+4.79,-0.2964,-1.24351
+4.795,-0.302582,-1.22904
+4.8,-0.308691,-1.21428
+4.805,-0.314725,-1.19923
+4.81,-0.320683,-1.18391
+4.815,-0.326564,-1.16831
+4.82,-0.332366,-1.15244
+4.825,-0.338088,-1.1363
+4.83,-0.343729,-1.1199
+4.835,-0.349287,-1.10324
+4.84,-0.354761,-1.08633
+4.845,-0.360151,-1.06917
+4.85,-0.365453,-1.05176
+4.855,-0.370668,-1.03411
+4.86,-0.375794,-1.01622
+4.865,-0.38083,-0.998105
+4.87,-0.385775,-0.97976
+4.875,-0.390628,-0.961193
+4.88,-0.395387,-0.942407
+4.885,-0.400052,-0.923408
+4.89,-0.404621,-0.9042
+4.895,-0.409094,-0.884789
+4.9,-0.413469,-0.865178
+4.905,-0.417746,-0.845374
+4.91,-0.421923,-0.825379
+4.915,-0.426,-0.8052
+4.92,-0.429975,-0.784841
+4.925,-0.433848,-0.764307
+4.93,-0.437618,-0.743604
+4.935,-0.441284,-0.722734
+4.94,-0.444845,-0.701705
+4.945,-0.448301,-0.68052
+4.95,-0.451651,-0.659185
+4.955,-0.454893,-0.637704
+4.96,-0.458028,-0.616083
+4.965,-0.461054,-0.594327
+4.97,-0.463971,-0.572439
+4.975,-0.466778,-0.550427
+4.98,-0.469475,-0.528293
+4.985,-0.472061,-0.506045
+4.99,-0.474536,-0.483685
+4.995,-0.476898,-0.46122
+5,-0.479148,-0.438655
+5.005,-0.481285,-0.415994
+5.01,-0.483308,-0.393242
+5.015,-0.485217,-0.370406
+5.02,-0.487012,-0.347489
+5.025,-0.488692,-0.324496
+5.03,-0.490257,-0.301434
+5.035,-0.491706,-0.278306
+5.04,-0.49304,-0.255118
+5.045,-0.494257,-0.231874
+5.05,-0.495359,-0.208581
+5.055,-0.496343,-0.185243
+5.06,-0.497211,-0.161865
+5.065,-0.497962,-0.138451
+5.07,-0.498596,-0.115008
+5.075,-0.499112,-0.0915407
+5.08,-0.499511,-0.0680533
+5.085,-0.499793,-0.0445512
+5.09,-0.499957,-0.0210395
+5.095,-0.500003,0.00247674
+5.1,-0.499932,0.0259924
+5.105,-0.499743,0.0495025
+5.11,-0.499437,0.0730019
+5.115,-0.499013,0.0964857
+5.12,-0.498472,0.119949
+5.125,-0.497814,0.143386
+5.13,-0.497038,0.166792
+5.135,-0.496146,0.190162
+5.14,-0.495136,0.213491
+5.145,-0.494011,0.236775
+5.15,-0.492769,0.260007
+5.155,-0.491411,0.283182
+5.16,-0.489937,0.306297
+5.165,-0.488348,0.329345
+5.17,-0.486643,0.352322
+5.175,-0.484824,0.375223
+5.18,-0.482891,0.398042
+5.185,-0.480844,0.420775
+5.19,-0.478683,0.443416
+5.195,-0.47641,0.465961
+5.2,-0.474024,0.488404
+5.205,-0.471526,0.51074
+5.21,-0.468916,0.532965
+5.215,-0.466196,0.555074
+5.22,-0.463366,0.57706
+5.225,-0.460426,0.598921
+5.23,-0.457377,0.620649
+5.235,-0.454219,0.642241
+5.24,-0.450954,0.663692
+5.245,-0.447582,0.684995
+5.25,-0.444104,0.706148
+5.255,-0.440521,0.727144
+5.26,-0.436833,0.747979
+5.265,-0.433041,0.768647
+5.27,-0.429146,0.789145
+5.275,-0.42515,0.809466
+5.28,-0.421052,0.829607
+5.285,-0.416853,0.849561
+5.29,-0.412556,0.869326
+5.295,-0.40816,0.888895
+5.3,-0.403667,0.908264
+5.305,-0.399078,0.927428
+5.31,-0.394393,0.946382
+5.315,-0.389614,0.965122
+5.32,-0.384742,0.983644
+5.325,-0.379777,1.00194
+5.33,-0.374722,1.02001
+5.335,-0.369577,1.03785
+5.34,-0.364344,1.05545
+5.345,-0.359023,1.0728
+5.35,-0.353616,1.08991
+5.355,-0.348124,1.10677
+5.36,-0.342548,1.12338
+5.365,-0.33689,1.13973
+5.37,-0.331151,1.15581
+5.375,-0.325332,1.17162
+5.38,-0.319435,1.18716
+5.385,-0.31346,1.20243
+5.39,-0.30741,1.21741
+5.395,-0.301286,1.23211
+5.4,-0.295089,1.24652
+5.405,-0.288821,1.26064
+5.41,-0.282483,1.27446
+5.415,-0.276076,1.28798
+5.42,-0.269603,1.3012
+5.425,-0.263064,1.31411
+5.43,-0.256462,1.32671
+5.435,-0.249797,1.339
+5.44,-0.243072,1.35096
+5.445,-0.236287,1.36261
+5.45,-0.229446,1.37393
+5.455,-0.222548,1.38492
+5.46,-0.215597,1.39558
+5.465,-0.208592,1.40591
+5.47,-0.201537,1.4159
+5.475,-0.194433,1.42554
+5.48,-0.187282,1.43485
+5.485,-0.180085,1.44381
+5.49,-0.172844,1.45242
+5.495,-0.165561,1.46068
+5.5,-0.158237,1.46859
+5.505,-0.150875,1.47614
+5.51,-0.143476,1.48333
+5.515,-0.136042,1.49017
+5.52,-0.128574,1.49664
+5.525,-0.121075,1.50274
+5.53,-0.113547,1.50848
+5.535,-0.10599,1.51386
+5.54,-0.0984081,1.51886
+5.545,-0.0908017,1.5235
+5.55,-0.0831731,1.52776
+5.555,-0.0755241,1.53165
+5.56,-0.0678567,1.53516
+5.565,-0.0601725,1.5383
+5.57,-0.0524737,1.54106
+5.575,-0.044762,1.54344
+5.58,-0.0370392,1.54545
+5.585,-0.0293075,1.54708
+5.59,-0.0215685,1.54832
+5.595,-0.0138242,1.54919
+5.6,-0.00607657,1.54968
+5.605,0.00167258,1.54979
+5.61,0.00942131,1.54952
+5.615,0.0171677,1.54886
+5.62,0.0249099,1.54783
+5.625,0.0326461,1.54642
+5.63,0.0403742,1.54463
+5.635,0.0480924,1.54246
+5.64,0.0557988,1.53991
+5.645,0.0634915,1.53699
+5.65,0.0711687,1.53369
+5.655,0.0788284,1.53001
+5.66,0.0864688,1.52596
+5.665,0.094088,1.52154
+5.67,0.101684,1.51675
+5.675,0.109256,1.51158
+5.68,0.1168,1.50605
+5.685,0.124316,1.50015
+5.69,0.131802,1.49389
+5.695,0.139255,1.48726
+5.7,0.146674,1.48027
+5.705,0.154058,1.47292
+5.71,0.161403,1.46522
+5.715,0.16871,1.45716
+5.72,0.175975,1.44875
+5.725,0.183197,1.43998
+5.73,0.190375,1.43087
+5.735,0.197506,1.42142
+5.74,0.204589,1.41163
+5.745,0.211622,1.40149
+5.75,0.218604,1.39102
+5.755,0.225533,1.38022
+5.76,0.232406,1.36908
+5.765,0.239223,1.35762
+5.77,0.245982,1.34584
+5.775,0.252682,1.33373
+5.78,0.25932,1.32131
+5.785,0.265895,1.30858
+5.79,0.272406,1.29554
+5.795,0.27885,1.28219
+5.8,0.285227,1.26853
+5.805,0.291536,1.25458
+5.81,0.297773,1.24034
+5.815,0.303939,1.2258
+5.82,0.310031,1.21098
+5.825,0.316049,1.19587
+5.83,0.32199,1.18049
+5.835,0.327854,1.16483
+5.84,0.333638,1.1489
+5.845,0.339343,1.1327
+5.85,0.344965,1.11624
+5.855,0.350505,1.09953
+5.86,0.355961,1.08256
+5.865,0.361331,1.06534
+5.87,0.366614,1.04788
+5.875,0.371809,1.03018
+5.88,0.376916,1.01224
+5.885,0.381932,0.994071
+5.89,0.386856,0.975676
+5.895,0.391689,0.95706
+5.9,0.396427,0.938227
+5.905,0.401071,0.919181
+5.91,0.405619,0.899928
+5.915,0.41007,0.880472
+5.92,0.414424,0.860819
+5.925,0.418678,0.840971
+5.93,0.422833,0.820936
+5.935,0.426888,0.800717
+5.94,0.430841,0.780319
+5.945,0.434691,0.759747
+5.95,0.438438,0.739006
+5.955,0.442081,0.718101
+5.96,0.445619,0.697037
+5.965,0.449051,0.675818
+5.97,0.452377,0.65445
+5.975,0.455596,0.632938
+5.98,0.458707,0.611287
+5.985,0.461709,0.589501
+5.99,0.464602,0.567585
+5.995,0.467385,0.545545
+6,0.470057,0.523386
+6.005,0.472618,0.501112
+6.01,0.475068,0.478729
+6.015,0.477406,0.456241
+6.02,0.479631,0.433654
+6.025,0.481742,0.410973
+6.03,0.48374,0.388202
+6.035,0.485624,0.365347
+6.04,0.487394,0.342413
+6.045,0.489048,0.319405
+6.05,0.490588,0.296327
+6.055,0.492012,0.273186
+6.06,0.49332,0.249985
+6.065,0.494512,0.22673
+6.07,0.495587,0.203426
+6.075,0.496546,0.180079
+6.08,0.497388,0.156692
+6.085,0.498113,0.133272
+6.09,0.498721,0.109823
+6.095,0.499211,0.0863508
+6.1,0.499584,0.0628596
+6.105,0.49984,0.0393549
+6.11,0.499978,0.0158418
+6.115,0.499998,-0.00767478
+6.12,0.499901,-0.0311897
+6.125,0.499686,-0.0546979
+6.13,0.499354,-0.0781943
+6.135,0.498904,-0.101674
+6.14,0.498337,-0.125132
+6.145,0.497653,-0.148562
+6.15,0.496852,-0.171961
+6.155,0.495933,-0.195323
+6.16,0.494898,-0.218642
+6.165,0.493747,-0.241915
+6.17,0.492479,-0.265135
+6.175,0.491096,-0.288297
+6.18,0.489596,-0.311398
+6.185,0.487982,-0.334431
+6.19,0.486252,-0.357391
+6.195,0.484408,-0.380274
+6.2,0.482449,-0.403075
+6.205,0.480377,-0.425788
+6.21,0.478191,-0.448408
+6.215,0.475893,-0.470931
+6.22,0.473482,-0.493351
+6.225,0.470959,-0.515663
+6.23,0.468325,-0.537863
+6.235,0.465581,-0.559945
+6.24,0.462726,-0.581904
+6.245,0.459762,-0.603736
+6.25,0.456689,-0.625435
+6.255,0.453507,-0.646996
+6.26,0.450219,-0.668414
+6.265,0.446823,-0.689685
+6.27,0.443322,-0.710803
+6.275,0.439715,-0.731764
+6.28,0.436004,-0.752563
+6.285,0.43219,-0.773194
+6.29,0.428272,-0.793653
+6.295,0.424253,-0.813935
+6.3,0.420133,-0.834035
+6.305,0.415913,-0.853948
+6.31,0.411593,-0.873669
+6.315,0.407176,-0.893195
+6.32,0.402661,-0.912519
+6.325,0.398051,-0.931637
+6.33,0.393345,-0.950544
+6.335,0.388545,-0.969236
+6.34,0.383653,-0.987709
+6.345,0.378668,-1.00596
+6.35,0.373593,-1.02397
+6.355,0.368429,-1.04176
+6.36,0.363176,-1.05931
+6.365,0.357836,-1.07661
+6.37,0.35241,-1.09366
+6.375,0.346899,-1.11047
+6.38,0.341305,-1.12702
+6.385,0.335629,-1.1433
+6.39,0.329872,-1.15933
+6.395,0.324035,-1.17508
+6.4,0.318121,-1.19056
+6.405,0.31213,-1.20576
+6.41,0.306063,-1.22069
+6.415,0.299923,-1.23532
+6.42,0.29371,-1.24967
+6.425,0.287426,-1.26372
+6.43,0.281073,-1.27748
+6.435,0.274652,-1.29093
+6.44,0.268164,-1.30409
+6.445,0.261611,-1.31693
+6.45,0.254994,-1.32946
+6.455,0.248316,-1.34167
+6.46,0.241578,-1.35357
+6.465,0.23478,-1.36514
+6.47,0.227926,-1.37639
+6.475,0.221017,-1.38731
+6.48,0.214053,-1.39789
+6.485,0.207038,-1.40815
+6.49,0.199972,-1.41806
+6.495,0.192857,-1.42763
+6.5,0.185695,-1.43686
+6.505,0.178488,-1.44574
+6.51,0.171238,-1.45428
+6.515,0.163946,-1.46246
+6.52,0.156613,-1.47029
+6.525,0.149243,-1.47776
+6.53,0.141836,-1.48488
+6.535,0.134394,-1.49163
+6.54,0.126919,-1.49802
+6.545,0.119414,-1.50405
+6.55,0.111879,-1.50971
+6.555,0.104317,-1.515
+6.56,0.096729,-1.51992
+6.565,0.0891175,-1.52447
+6.57,0.0814843,-1.52865
+6.575,0.073831,-1.53246
+6.58,0.0661597,-1.53589
+6.585,0.0584721,-1.53894
+6.59,0.0507703,-1.54162
+6.595,0.0430559,-1.54392
+6.6,0.035331,-1.54584
+6.605,0.0275975,-1.54739
+6.61,0.0198572,-1.54855
+6.615,0.012112,-1.54933
+6.62,0.00436383,-1.54974
+6.625,-0.00338539,-1.54976
+6.63,-0.0111338,-1.54941
+6.635,-0.0188795,-1.54867
+6.64,-0.0266205,-1.54755
+6.645,-0.034355,-1.54606
+6.65,-0.0420811,-1.54419
+6.655,-0.0497969,-1.54193
+6.66,-0.0575004,-1.5393
+6.665,-0.0651899,-1.53629
+6.67,-0.0728634,-1.53291
+6.675,-0.080519,-1.52915
+6.68,-0.0881549,-1.52502
+6.685,-0.0957692,-1.52052
+6.69,-0.10336,-1.51564
+6.695,-0.110926,-1.5104
+6.7,-0.118464,-1.50478
+6.705,-0.125973,-1.4988
+6.71,-0.133452,-1.49246
+6.715,-0.140898,-1.48575
+6.72,-0.14831,-1.47868
+6.725,-0.155685,-1.47125
+6.73,-0.163022,-1.46347
+6.735,-0.17032,-1.45533
+6.74,-0.177575,-1.44684
+6.745,-0.184788,-1.438
+6.75,-0.191955,-1.42882
+6.755,-0.199076,-1.41929
+6.76,-0.206148,-1.40942
+6.765,-0.21317,-1.39921
+6.77,-0.22014,-1.38866
+6.775,-0.227057,-1.37779
+6.78,-0.233918,-1.36658
+6.785,-0.240723,-1.35505
+6.79,-0.247469,-1.34319
+6.795,-0.254155,-1.33102
+6.8,-0.260779,-1.31853
+6.805,-0.26734,-1.30572
+6.81,-0.273836,-1.29261
+6.815,-0.280266,-1.2792
+6.82,-0.286628,-1.26548
+6.825,-0.292921,-1.25146
+6.83,-0.299143,-1.23715
+6.835,-0.305292,-1.22255
+6.84,-0.311368,-1.20767
+6.845,-0.317369,-1.1925
+6.85,-0.323293,-1.17705
+6.855,-0.329139,-1.16133
+6.86,-0.334907,-1.14534
+6.865,-0.340593,-1.12909
+6.87,-0.346197,-1.11257
+6.875,-0.351719,-1.0958
+6.88,-0.357155,-1.07878
+6.885,-0.362506,-1.0615
+6.89,-0.36777,-1.04399
+6.895,-0.372946,-1.02623
+6.9,-0.378033,-1.00824
+6.905,-0.383029,-0.990026
+6.91,-0.387933,-0.971582
+6.915,-0.392745,-0.952917
+6.92,-0.397462,-0.934037
+6.925,-0.402085,-0.914945
+6.93,-0.406612,-0.895647
+6.935,-0.411041,-0.876146
+6.94,-0.415373,-0.856449
+6.945,-0.419606,-0.83656
+6.95,-0.423739,-0.816483
+6.955,-0.427771,-0.796224
+6.96,-0.431701,-0.775787
+6.965,-0.435529,-0.755178
+6.97,-0.439253,-0.7344
+6.975,-0.442873,-0.713459
+6.98,-0.446387,-0.692361
+6.985,-0.449796,-0.671109
+6.99,-0.453098,-0.649709
+6.995,-0.456293,-0.628165
+7,-0.45938,-0.606484
+7.005,-0.462358,-0.584669
+7.01,-0.465227,-0.562725
+7.015,-0.467985,-0.540658
+7.02,-0.470633,-0.518473
+7.025,-0.47317,-0.496175
+7.03,-0.475595,-0.473768
+7.035,-0.477908,-0.451258
+7.04,-0.480108,-0.42865
+7.045,-0.482194,-0.405948
+7.05,-0.484167,-0.383158
+7.055,-0.486026,-0.360286
+7.06,-0.48777,-0.337334
+7.065,-0.489399,-0.31431
+7.07,-0.490913,-0.291218
+7.075,-0.492312,-0.268063
+7.08,-0.493594,-0.24485
+7.085,-0.49476,-0.221584
+7.09,-0.49581,-0.19827
+7.095,-0.496743,-0.174913
+7.1,-0.497559,-0.151519
+7.105,-0.498258,-0.128092
+7.11,-0.49884,-0.104637
+7.115,-0.499304,-0.0811601
+7.12,-0.499651,-0.0576655
+7.125,-0.499881,-0.0341585
+7.13,-0.499993,-0.0106441
+7.135,-0.499987,0.0128725
+7.14,-0.499864,0.0363864
+7.145,-0.499624,0.0598925
+7.15,-0.499265,0.0833857
+7.155,-0.49879,0.106861
+7.16,-0.498197,0.130313
+7.165,-0.497487,0.153737
+7.17,-0.496659,0.177128
+7.175,-0.495715,0.200481
+7.18,-0.494655,0.223791
+7.185,-0.493477,0.247052
+7.19,-0.492184,0.27026
+7.195,-0.490775,0.293409
+7.2,-0.48925,0.316495
+7.205,-0.48761,0.339513
+7.21,-0.485855,0.362456
+7.215,-0.483985,0.385322
+7.22,-0.482002,0.408103
+7.225,-0.479904,0.430796
+7.23,-0.477694,0.453396
+7.235,-0.47537,0.475896
+7.24,-0.472935,0.498293
+7.245,-0.470387,0.520581
+7.25,-0.467729,0.542755
+7.255,-0.46496,0.56481
+7.26,-0.462081,0.586741
+7.265,-0.459092,0.608544
+7.27,-0.455995,0.630213
+7.275,-0.45279,0.651743
+7.28,-0.449478,0.673129
+7.285,-0.446059,0.694367
+7.29,-0.442534,0.715451
+7.295,-0.438905,0.736376
+7.3,-0.435171,0.757138
+7.305,-0.431333,0.777732
+7.31,-0.427393,0.798152
+7.315,-0.423352,0.818394
+7.32,-0.419209,0.838453
+7.325,-0.414967,0.858325
+7.33,-0.410626,0.878003
+7.335,-0.406187,0.897484
+7.34,-0.401651,0.916763
+7.345,-0.397019,0.935835
+7.35,-0.392293,0.954696
+7.355,-0.387473,0.97334
+7.36,-0.382559,0.991763
+7.365,-0.377555,1.00996
+7.37,-0.37246,1.02793
+7.375,-0.367276,1.04566
+7.38,-0.362003,1.06315
+7.385,-0.356644,1.0804
+7.39,-0.351199,1.0974
+7.395,-0.34567,1.11415
+7.4,-0.340058,1.13064
+7.405,-0.334364,1.14687
+7.41,-0.328589,1.16283
+7.415,-0.322735,1.17853
+7.42,-0.316804,1.19395
+7.425,-0.310796,1.20909
+7.43,-0.304713,1.22395
+7.435,-0.298556,1.23852
+7.44,-0.292328,1.2528
+7.445,-0.286028,1.26679
+7.45,-0.27966,1.28048
+7.455,-0.273224,1.29387
+7.46,-0.266721,1.30695
+7.465,-0.260154,1.31973
+7.47,-0.253524,1.33219
+7.475,-0.246832,1.34433
+7.48,-0.240081,1.35616
+7.485,-0.233271,1.36766
+7.49,-0.226404,1.37883
+7.495,-0.219482,1.38968
+7.5,-0.212507,1.40019
+7.505,-0.20548,1.41037
+7.51,-0.198404,1.42021
+7.515,-0.191278,1.4297
+7.52,-0.184107,1.43886
+7.525,-0.17689,1.44766
+7.53,-0.16963,1.45612
+7.535,-0.162329,1.46422
+7.54,-0.154988,1.47197
+7.545,-0.147609,1.47937
+7.55,-0.140194,1.4864
+7.555,-0.132745,1.49307
+7.56,-0.125263,1.49939
+7.565,-0.117751,1.50533
+7.57,-0.11021,1.51091
+7.575,-0.102642,1.51612
+7.58,-0.0950488,1.52096
+7.585,-0.0874324,1.52543
+7.59,-0.0797945,1.52953
+7.595,-0.0721371,1.53325
+7.6,-0.064462,1.5366
+7.605,-0.0567711,1.53957
+7.61,-0.0490663,1.54216
+7.615,-0.0413495,1.54438
+7.62,-0.0336225,1.54622
+7.625,-0.0258873,1.54768
+7.63,-0.0181457,1.54876
+7.635,-0.0103997,1.54946
+7.64,-0.00265112,1.54978
+7.645,0.0050981,1.54972
+7.65,0.0128461,1.54928
+7.655,0.0205909,1.54846
+7.66,0.0283307,1.54726
+7.665,0.0360635,1.54568
+7.67,0.0437875,1.54372
+7.675,0.0515007,1.54139
+7.68,0.0592013,1.53867
+7.685,0.0668874,1.53558
+7.69,0.0745571,1.53212
+7.695,0.0822086,1.52827
+7.7,0.0898399,1.52406
+7.705,0.0974492,1.51947
+7.71,0.105035,1.51452
+7.715,0.112594,1.50919
+7.72,0.120127,1.50349
+7.725,0.127629,1.49743
+7.73,0.135101,1.49101
+7.735,0.142539,1.48422
+7.74,0.149943,1.47707
+7.745,0.15731,1.46957
+7.75,0.164639,1.4617
+7.755,0.171927,1.45349
+7.76,0.179174,1.44492
+7.765,0.186376,1.436
+7.77,0.193534,1.42674
+7.775,0.200644,1.41714
+7.78,0.207705,1.40719
+7.785,0.214716,1.39691
+7.79,0.221674,1.38629
+7.795,0.228579,1.37534
+7.8,0.235427,1.36406
+7.805,0.242219,1.35246
+7.81,0.248952,1.34053
+7.815,0.255624,1.32829
+7.82,0.262235,1.31573
+7.825,0.268782,1.30285
+7.83,0.275263,1.28968
+7.835,0.281678,1.27619
+7.84,0.288025,1.26241
+7.845,0.294303,1.24833
+7.85,0.300509,1.23395
+7.855,0.306642,1.21929
+7.86,0.312701,1.20434
+7.865,0.318685,1.18911
+7.87,0.324593,1.1736
+7.875,0.330421,1.15782
+7.88,0.336171,1.14177
+7.885,0.341839,1.12546
+7.89,0.347425,1.10889
+7.895,0.352928,1.09206
+7.9,0.358346,1.07498
+7.905,0.363678,1.05766
+7.91,0.368923,1.04009
+7.915,0.374079,1.02228
+7.92,0.379145,1.00424
+7.925,0.384121,0.98597
+7.93,0.389005,0.967477
+7.935,0.393796,0.948764
+7.94,0.398493,0.929836
+7.945,0.403094,0.910698
+7.95,0.4076,0.891355
+7.955,0.412008,0.871811
+7.96,0.416318,0.852071
+7.965,0.420529,0.83214
+7.97,0.424639,0.812022
+7.975,0.428649,0.791724
+7.98,0.432556,0.771248
+7.985,0.436361,0.750601
+7.99,0.440063,0.729787
+7.995,0.443659,0.708811
+8,0.447151,0.687678
+8.005,0.450536,0.666392
+8.01,0.453815,0.64496
+8.015,0.456986,0.623386
+8.02,0.460048,0.601674
+8.025,0.463002,0.57983
+8.03,0.465847,0.557859
+8.035,0.468581,0.535766
+8.04,0.471204,0.513555
+8.045,0.473716,0.491232
+8.05,0.476117,0.468802
+8.055,0.478405,0.44627
+8.06,0.480579,0.423641
+8.065,0.482641,0.400919
+8.07,0.484589,0.378111
+8.075,0.486422,0.35522
+8.08,0.488141,0.332252
+8.085,0.489745,0.309213
+8.09,0.491233,0.286106
+8.095,0.492606,0.262937
+8.1,0.493862,0.239712
+8.105,0.495003,0.216435
+8.11,0.496027,0.193111
+8.115,0.496934,0.169746
+8.12,0.497724,0.146344
+8.125,0.498397,0.12291
+8.13,0.498953,0.0994503
+8.135,0.499392,0.0759688
+8.14,0.499713,0.052471
+8.145,0.499917,0.0289619
+8.15,0.500003,0.00544657
+8.155,0.499971,-0.01807
+8.16,0.499822,-0.0415826
+8.165,0.499555,-0.0650863
+8.17,0.499171,-0.0885759
+8.175,0.498669,-0.112047
+8.18,0.498051,-0.135493
+8.185,0.497315,-0.15891
+8.19,0.496461,-0.182293
+8.195,0.495492,-0.205637
+8.2,0.494405,-0.228936
+8.205,0.493202,-0.252186
+8.21,0.491883,-0.275382
+8.215,0.490448,-0.298518
+8.22,0.488898,-0.321589
+8.225,0.487233,-0.344591
+8.23,0.485452,-0.367518
+8.235,0.483557,-0.390365
+8.24,0.481549,-0.413127
+8.245,0.479426,-0.4358
+8.25,0.477191,-0.458378
+8.255,0.474842,-0.480856
+8.26,0.472382,-0.503229
+8.265,0.46981,-0.525492
+8.27,0.467127,-0.54764
+8.275,0.464334,-0.569669
+8.28,0.46143,-0.591572
+8.285,0.458418,-0.613346
+8.29,0.455297,-0.634984
+8.295,0.452068,-0.656483
+8.3,0.448732,-0.677837
+8.305,0.44529,-0.699041
+8.31,0.441742,-0.720091
+8.315,0.438089,-0.74098
+8.32,0.434332,-0.761705
+8.325,0.430472,-0.782261
+8.33,0.426509,-0.802643
+8.335,0.422445,-0.822845
+8.34,0.418281,-0.842863
+8.345,0.414017,-0.862692
+8.35,0.409654,-0.882327
+8.355,0.405193,-0.901764
+8.36,0.400636,-0.920998
+8.365,0.395984,-0.940024
+8.37,0.391236,-0.958836
+8.375,0.386395,-0.977432
+8.38,0.381462,-0.995806
+8.385,0.376437,-1.01395
+8.39,0.371322,-1.03187
+8.395,0.366118,-1.04955
+8.4,0.360827,-1.06699
+8.405,0.355449,-1.08418
+8.41,0.349985,-1.10113
+8.415,0.344437,-1.11782
+8.42,0.338807,-1.13425
+8.425,0.333095,-1.15042
+8.43,0.327303,-1.16633
+8.435,0.321432,-1.18196
+8.44,0.315483,-1.19732
+8.445,0.309458,-1.2124
+8.45,0.303359,-1.2272
+8.455,0.297186,-1.2417
+8.46,0.290942,-1.25592
+8.465,0.284627,-1.26984
+8.47,0.278244,-1.28347
+8.475,0.271793,-1.29679
+8.48,0.265276,-1.3098
+8.485,0.258694,-1.32251
+8.49,0.252051,-1.3349
+8.495,0.245345,-1.34697
+8.5,0.238581,-1.35873
+8.505,0.231758,-1.37016
+8.51,0.224879,-1.38126
+8.515,0.217946,-1.39203
+8.52,0.210959,-1.40247
+8.525,0.203921,-1.41257
+8.53,0.196833,-1.42234
+8.535,0.189698,-1.43176
+8.54,0.182516,-1.44083
+8.545,0.175289,-1.44956
+8.55,0.16802,-1.45794
+8.555,0.16071,-1.46597
+8.56,0.15336,-1.47364
+8.565,0.145973,-1.48095
+8.57,0.138551,-1.48791
+8.575,0.131094,-1.4945
+8.58,0.123606,-1.50073
+8.585,0.116087,-1.5066
+8.59,0.10854,-1.5121
+8.595,0.100966,-1.51722
+8.6,0.0933675,-1.52198
+8.605,0.0857462,-1.52637
+8.61,0.0781038,-1.53038
+8.615,0.0704424,-1.53402
+8.62,0.0627636,-1.53729
+8.625,0.0550695,-1.54018
+8.63,0.0473618,-1.54269
+8.635,0.0396426,-1.54482
+8.64,0.0319136,-1.54658
+8.645,0.0241768,-1.54795
+8.65,0.0164341,-1.54895
+8.655,0.00868732,-1.54956
+8.66,0.000938431,-1.5498
+8.665,-0.00681069,-1.54966
+8.67,-0.0145581,-1.54913
+8.675,-0.022302,-1.54823
+8.68,-0.0300404,-1.54694
+8.685,-0.0377715,-1.54528
+8.69,-0.0454932,-1.54324
+8.695,-0.0532039,-1.54082
+8.7,-0.0609015,-1.53802
+8.705,-0.0685841,-1.53485
+8.71,-0.07625,-1.5313
+8.715,-0.0838971,-1.52738
+8.72,-0.0915237,-1.52308
+8.725,-0.0991279,-1.51841
+8.73,-0.106708,-1.51337
+8.735,-0.114262,-1.50796
+8.74,-0.121787,-1.50219
+8.745,-0.129284,-1.49605
+8.75,-0.136748,-1.48954
+8.755,-0.144179,-1.48267
+8.76,-0.151575,-1.47545
+8.765,-0.158933,-1.46786
+8.77,-0.166253,-1.45992
+8.775,-0.173533,-1.45163
+8.78,-0.18077,-1.44298
+8.785,-0.187962,-1.43399
+8.79,-0.195109,-1.42465
+8.795,-0.202209,-1.41497
+8.8,-0.209259,-1.40495
+8.805,-0.216258,-1.39459
+8.81,-0.223205,-1.3839
+8.815,-0.230097,-1.37288
+8.82,-0.236934,-1.36153
+8.825,-0.243713,-1.34985
+8.83,-0.250432,-1.33785
+8.835,-0.257091,-1.32554
+8.84,-0.263688,-1.31291
+8.845,-0.27022,-1.29997
+8.85,-0.276687,-1.28672
+8.855,-0.283088,-1.27317
+8.86,-0.289419,-1.25932
+8.865,-0.295681,-1.24517
+8.87,-0.301871,-1.23074
+8.875,-0.307988,-1.21601
+8.88,-0.314031,-1.201
+8.885,-0.319998,-1.18571
+8.89,-0.325888,-1.17014
+8.895,-0.331699,-1.1543
+8.9,-0.337431,-1.13819
+8.905,-0.343081,-1.12182
+8.91,-0.348649,-1.10519
+8.915,-0.354133,-1.08831
+8.92,-0.359532,-1.07117
+8.925,-0.364845,-1.05379
+8.93,-0.37007,-1.03617
+8.935,-0.375207,-1.01831
+8.94,-0.380253,-1.00022
+8.945,-0.385209,-0.981903
+8.95,-0.390073,-0.963361
+8.955,-0.394843,-0.9446
+8.96,-0.399519,-0.925626
+8.965,-0.404099,-0.906442
+8.97,-0.408583,-0.887054
+8.975,-0.41297,-0.867466
+8.98,-0.417258,-0.847683
+8.985,-0.421446,-0.827711
+8.99,-0.425535,-0.807553
+8.995,-0.429522,-0.787214
+9,-0.433407,-0.7667
+9.005,-0.437189,-0.746016
+9.01,-0.440867,-0.725166
+9.015,-0.444441,-0.704154
+9.02,-0.447909,-0.682987
+9.025,-0.45127,-0.661669
+9.03,-0.454525,-0.640205
+9.035,-0.457672,-0.6186
+9.04,-0.460711,-0.596858
+9.045,-0.463641,-0.574986
+9.05,-0.466461,-0.552987
+9.055,-0.469171,-0.530868
+9.06,-0.47177,-0.508632
+9.065,-0.474257,-0.486285
+9.07,-0.476633,-0.463832
+9.075,-0.478896,-0.441278
+9.08,-0.481046,-0.418627
+9.085,-0.483082,-0.395886
+9.09,-0.485004,-0.373059
+9.095,-0.486812,-0.350151
+9.1,-0.488506,-0.327167
+9.105,-0.490084,-0.304112
+9.11,-0.491547,-0.280991
+9.115,-0.492894,-0.25781
+9.12,-0.494125,-0.234572
+9.125,-0.49524,-0.211285
+9.13,-0.496238,-0.187951
+9.135,-0.497119,-0.164577
+9.14,-0.497884,-0.141168
+9.145,-0.498531,-0.117728
+9.15,-0.499061,-0.0942625
+9.155,-0.499474,-0.070777
+9.16,-0.499769,-0.0472762
+9.165,-0.499946,-0.0237652
+9.17,-0.500006,-0.000249153
+9.175,-0.499949,0.023267
+9.18,-0.499774,0.0467781
+9.185,-0.499481,0.0702791
+9.19,-0.499071,0.0937651
+9.195,-0.498543,0.117231
+9.2,-0.497899,0.140671
+9.205,-0.497137,0.164081
+9.21,-0.496258,0.187456
+9.215,-0.495262,0.210791
+9.22,-0.49415,0.234079
+9.225,-0.492921,0.257318
+9.23,-0.491577,0.280501
+9.235,-0.490116,0.303623
+9.24,-0.488541,0.326679
+9.245,-0.48685,0.349665
+9.25,-0.485044,0.372574
+9.255,-0.483124,0.395403
+9.26,-0.48109,0.418147
+9.265,-0.478942,0.440799
+9.27,-0.476682,0.463355
+9.275,-0.474309,0.48581
+9.28,-0.471824,0.50816
+9.285,-0.469227,0.530398
+9.29,-0.46652,0.55252
+9.295,-0.463702,0.574521
+9.3,-0.460775,0.596397
+9.305,-0.457738,0.618141
+9.31,-0.454593,0.639749
+9.315,-0.451341,0.661216
+9.32,-0.447981,0.682537
+9.325,-0.444515,0.703708
+9.33,-0.440944,0.724722
+9.335,-0.437268,0.745576
+9.34,-0.433488,0.766264
+9.345,-0.429605,0.786782
+9.35,-0.42562,0.807124
+9.355,-0.421534,0.827286
+9.36,-0.417348,0.847263
+9.365,-0.413062,0.867049
+9.37,-0.408677,0.886641
+9.375,-0.404195,0.906034
+9.38,-0.399617,0.925222
+9.385,-0.394943,0.944201
+9.39,-0.390175,0.962966
+9.395,-0.385313,0.981513
+9.4,-0.38036,0.999837
+9.405,-0.375315,1.01793
+9.41,-0.37018,1.0358
+9.415,-0.364957,1.05342
+9.42,-0.359646,1.07081
+9.425,-0.354249,1.08795
+9.43,-0.348767,1.10484
+9.435,-0.343201,1.12147
+9.44,-0.337552,1.13785
+9.445,-0.331822,1.15396
+9.45,-0.326012,1.16981
+9.455,-0.320124,1.18538
+9.46,-0.314158,1.20068
+9.465,-0.308117,1.2157
+9.47,-0.302002,1.23043
+9.475,-0.295813,1.24487
+9.48,-0.289553,1.25903
+9.485,-0.283223,1.27288
+9.49,-0.276824,1.28644
+9.495,-0.270358,1.29969
+9.5,-0.263827,1.31264
+9.505,-0.257232,1.32528
+9.51,-0.250574,1.3376
+9.515,-0.243856,1.3496
+9.52,-0.237078,1.36128
+9.525,-0.230243,1.37264
+9.53,-0.223352,1.38367
+9.535,-0.216406,1.39437
+9.54,-0.209408,1.40473
+9.545,-0.202359,1.41476
+9.55,-0.195261,1.42445
+9.555,-0.188115,1.4338
+9.56,-0.180923,1.4428
+9.565,-0.173687,1.45145
+9.57,-0.166408,1.45975
+9.575,-0.159089,1.4677
+9.58,-0.151731,1.47529
+9.585,-0.144336,1.48252
+9.59,-0.136906,1.4894
+9.595,-0.129442,1.49591
+9.6,-0.121947,1.50206
+9.605,-0.114422,1.50785
+9.61,-0.106868,1.51326
+9.615,-0.0992889,1.51831
+9.62,-0.0916852,1.52299
+9.625,-0.0840591,1.52729
+9.63,-0.0764123,1.53122
+9.635,-0.0687468,1.53478
+9.64,-0.0610645,1.53796
+9.645,-0.0533672,1.54077
+9.65,-0.0456568,1.5432
+9.655,-0.0379353,1.54524
+9.66,-0.0302044,1.54692
+9.665,-0.0224661,1.54821
+9.67,-0.0147223,1.54912
+9.675,-0.00697492,1.54965
+9.68,0.000774198,1.5498
+9.685,0.00852312,1.54958
+9.69,0.01627,1.54897
+9.695,0.0240128,1.54798
+9.7,0.0317498,1.54661
+9.705,0.0394789,1.54487
+9.71,0.0471984,1.54274
+9.715,0.0549063,1.54024
+9.72,0.0626008,1.53736
+9.725,0.0702799,1.5341
+9.73,0.0779418,1.53047
+9.735,0.0855846,1.52646
+9.74,0.0932064,1.52208
+9.745,0.100805,1.51733
+9.75,0.10838,1.51221
+9.755,0.115928,1.50672
+9.76,0.123447,1.50086
+9.765,0.130936,1.49464
+9.77,0.138393,1.48806
+9.775,0.145817,1.48111
+9.78,0.153204,1.4738
+9.785,0.160555,1.46614
+9.79,0.167866,1.45812
+9.795,0.175136,1.44975
+9.8,0.182363,1.44103
+9.805,0.189546,1.43196
+9.81,0.196683,1.42254
+9.815,0.203772,1.41279
+9.82,0.210811,1.40269
+9.825,0.217799,1.39226
+9.83,0.224733,1.38149
+9.835,0.231613,1.3704
+9.84,0.238437,1.35897
+9.845,0.245203,1.34723
+9.85,0.25191,1.33516
+9.855,0.258555,1.32278
+9.86,0.265137,1.31008
+9.865,0.271656,1.29707
+9.87,0.278108,1.28376
+9.875,0.284493,1.27014
+9.88,0.290809,1.25622
+9.885,0.297055,1.24201
+9.89,0.30323,1.22751
+9.895,0.30933,1.21272
+9.9,0.315357,1.19764
+9.905,0.321307,1.18229
+9.91,0.32718,1.16666
+9.915,0.332974,1.15077
+9.92,0.338687,1.1346
+9.925,0.34432,1.11817
+9.93,0.349869,1.10149
+9.935,0.355334,1.08455
+9.94,0.360715,1.06736
+9.945,0.366008,1.04992
+9.95,0.371214,1.03225
+9.955,0.37633,1.01434
+9.96,0.381357,0.996195
+9.965,0.386292,0.977826
+9.97,0.391135,0.959235
+9.975,0.395885,0.940427
+9.98,0.40054,0.921405
+9.985,0.405099,0.902176
+9.99,0.409561,0.882743
+9.995,0.413926,0.863112
+10,0.418193,0.843287
diff --git a/pendulum_rk4.csv b/pendulum_rk4.csv
new file mode 100644
index 000000000..92d8d9d17
--- /dev/null
+++ b/pendulum_rk4.csv
@@ -0,0 +1,2002 @@
+t,alpha,alpha_dot
+0,0.5,0
+0.005,0.499941,-0.023515
+0.01,0.499765,-0.0470249
+0.015,0.499471,-0.0705247
+0.02,0.49906,-0.0940093
+0.025,0.498531,-0.117474
+0.03,0.497885,-0.140913
+0.035,0.497122,-0.164321
+0.04,0.496242,-0.187695
+0.045,0.495245,-0.211028
+0.05,0.494132,-0.234315
+0.055,0.492902,-0.257551
+0.06,0.491556,-0.280732
+0.065,0.490095,-0.303853
+0.07,0.488518,-0.326907
+0.075,0.486826,-0.349891
+0.08,0.485019,-0.372799
+0.085,0.483098,-0.395626
+0.09,0.481063,-0.418367
+0.095,0.478914,-0.441018
+0.1,0.476653,-0.463572
+0.105,0.474279,-0.486025
+0.11,0.471793,-0.508372
+0.115,0.469195,-0.530608
+0.12,0.466487,-0.552728
+0.125,0.463668,-0.574727
+0.13,0.46074,-0.5966
+0.135,0.457702,-0.618342
+0.14,0.454557,-0.639947
+0.145,0.451303,-0.661412
+0.15,0.447943,-0.682731
+0.155,0.444476,-0.703899
+0.16,0.440904,-0.724911
+0.165,0.437227,-0.745762
+0.17,0.433447,-0.766448
+0.175,0.429563,-0.786963
+0.18,0.425577,-0.807302
+0.185,0.42149,-0.827461
+0.19,0.417303,-0.847435
+0.195,0.413016,-0.867219
+0.2,0.408631,-0.886808
+0.205,0.404149,-0.906198
+0.21,0.39957,-0.925383
+0.215,0.394895,-0.944359
+0.22,0.390126,-0.963122
+0.225,0.385264,-0.981666
+0.23,0.38031,-0.999987
+0.235,0.375265,-1.01808
+0.24,0.37013,-1.03594
+0.245,0.364906,-1.05356
+0.25,0.359594,-1.07095
+0.255,0.354197,-1.08808
+0.26,0.348714,-1.10497
+0.265,0.343147,-1.1216
+0.27,0.337498,-1.13798
+0.275,0.331768,-1.15408
+0.28,0.325958,-1.16993
+0.285,0.320069,-1.1855
+0.29,0.314103,-1.20079
+0.295,0.308062,-1.2158
+0.3,0.301946,-1.23053
+0.305,0.295757,-1.24498
+0.31,0.289497,-1.25913
+0.315,0.283166,-1.27298
+0.32,0.276767,-1.28653
+0.325,0.270301,-1.29978
+0.33,0.26377,-1.31273
+0.335,0.257175,-1.32536
+0.34,0.250517,-1.33768
+0.345,0.243798,-1.34968
+0.35,0.237021,-1.36136
+0.355,0.230185,-1.37271
+0.36,0.223294,-1.38374
+0.365,0.216349,-1.39443
+0.37,0.20935,-1.4048
+0.375,0.202301,-1.41482
+0.38,0.195203,-1.4245
+0.385,0.188057,-1.43385
+0.39,0.180865,-1.44284
+0.395,0.173629,-1.45149
+0.4,0.16635,-1.45979
+0.405,0.159031,-1.46774
+0.41,0.151674,-1.47533
+0.415,0.144279,-1.48256
+0.42,0.136849,-1.48943
+0.425,0.129385,-1.49594
+0.43,0.12189,-1.50209
+0.435,0.114365,-1.50787
+0.44,0.106812,-1.51328
+0.445,0.0992327,-1.51832
+0.45,0.0916293,-1.523
+0.455,0.0840033,-1.5273
+0.46,0.0763569,-1.53123
+0.465,0.0686917,-1.53478
+0.47,0.0610097,-1.53796
+0.475,0.0533127,-1.54076
+0.48,0.0456027,-1.54319
+0.485,0.0378814,-1.54524
+0.49,0.0301509,-1.5469
+0.495,0.022413,-1.54819
+0.5,0.0146696,-1.5491
+0.505,0.00692263,-1.54963
+0.51,-0.000826067,-1.54978
+0.515,-0.00857456,-1.54955
+0.52,-0.0163209,-1.54894
+0.525,-0.0240633,-1.54795
+0.53,-0.0317998,-1.54658
+0.535,-0.0395285,-1.54483
+0.54,-0.0472475,-1.5427
+0.545,-0.0549549,-1.5402
+0.55,-0.0626489,-1.53732
+0.555,-0.0703274,-1.53406
+0.56,-0.0779888,-1.53042
+0.565,-0.085631,-1.52641
+0.57,-0.0932523,-1.52203
+0.575,-0.100851,-1.51728
+0.58,-0.108424,-1.51216
+0.585,-0.115972,-1.50666
+0.59,-0.123491,-1.50081
+0.595,-0.130979,-1.49458
+0.6,-0.138436,-1.48799
+0.605,-0.145858,-1.48105
+0.61,-0.153246,-1.47374
+0.615,-0.160595,-1.46607
+0.62,-0.167906,-1.45805
+0.625,-0.175175,-1.44968
+0.63,-0.182402,-1.44095
+0.635,-0.189584,-1.43188
+0.64,-0.19672,-1.42247
+0.645,-0.203808,-1.41271
+0.65,-0.210847,-1.40261
+0.655,-0.217834,-1.39218
+0.66,-0.224768,-1.38141
+0.665,-0.231647,-1.37032
+0.67,-0.238471,-1.35889
+0.675,-0.245236,-1.34715
+0.68,-0.251942,-1.33508
+0.685,-0.258586,-1.32269
+0.69,-0.265168,-1.30999
+0.695,-0.271686,-1.29698
+0.7,-0.278137,-1.28367
+0.705,-0.284522,-1.27005
+0.71,-0.290837,-1.25613
+0.715,-0.297083,-1.24192
+0.72,-0.303256,-1.22742
+0.725,-0.309356,-1.21263
+0.73,-0.315382,-1.19755
+0.735,-0.321331,-1.1822
+0.74,-0.327203,-1.16657
+0.745,-0.332997,-1.15067
+0.75,-0.33871,-1.13451
+0.755,-0.344341,-1.11808
+0.76,-0.34989,-1.10139
+0.765,-0.355355,-1.08445
+0.77,-0.360734,-1.06726
+0.775,-0.366027,-1.04983
+0.78,-0.371232,-1.03215
+0.785,-0.376348,-1.01424
+0.79,-0.381374,-0.996099
+0.795,-0.386309,-0.977731
+0.8,-0.391151,-0.95914
+0.805,-0.3959,-0.940331
+0.81,-0.400554,-0.92131
+0.815,-0.405112,-0.902081
+0.82,-0.409574,-0.882648
+0.825,-0.413939,-0.863017
+0.83,-0.418204,-0.843192
+0.835,-0.42237,-0.823178
+0.84,-0.426436,-0.80298
+0.845,-0.4304,-0.782603
+0.85,-0.434261,-0.762051
+0.855,-0.43802,-0.74133
+0.86,-0.441674,-0.720444
+0.865,-0.445224,-0.699399
+0.87,-0.448668,-0.678198
+0.875,-0.452006,-0.656848
+0.88,-0.455236,-0.635353
+0.885,-0.458359,-0.613717
+0.89,-0.461373,-0.591947
+0.895,-0.464278,-0.570047
+0.9,-0.467074,-0.548022
+0.905,-0.469758,-0.525877
+0.91,-0.472332,-0.503617
+0.915,-0.474794,-0.481246
+0.92,-0.477144,-0.458771
+0.925,-0.479382,-0.436196
+0.93,-0.481506,-0.413526
+0.935,-0.483517,-0.390766
+0.94,-0.485414,-0.367922
+0.945,-0.487196,-0.344997
+0.95,-0.488864,-0.321998
+0.955,-0.490416,-0.298929
+0.96,-0.491853,-0.275795
+0.965,-0.493174,-0.252602
+0.97,-0.494379,-0.229354
+0.975,-0.495467,-0.206056
+0.98,-0.496439,-0.182715
+0.985,-0.497294,-0.159333
+0.99,-0.498032,-0.135918
+0.995,-0.498653,-0.112473
+1,-0.499157,-0.0890037
+1.005,-0.499543,-0.0655154
+1.01,-0.499812,-0.0420131
+1.015,-0.499964,-0.0185016
+1.02,-0.499997,0.00501376
+1.025,-0.499913,0.0285281
+1.03,-0.499712,0.0520363
+1.035,-0.499393,0.0755333
+1.04,-0.498957,0.099014
+1.045,-0.498403,0.122473
+1.05,-0.497732,0.145906
+1.055,-0.496944,0.169308
+1.06,-0.496039,0.192673
+1.065,-0.495017,0.215997
+1.07,-0.493879,0.239273
+1.075,-0.492625,0.262499
+1.08,-0.491254,0.285667
+1.085,-0.489768,0.308774
+1.09,-0.488167,0.331814
+1.095,-0.48645,0.354782
+1.1,-0.484619,0.377673
+1.105,-0.482674,0.400482
+1.11,-0.480614,0.423204
+1.115,-0.478442,0.445834
+1.12,-0.476156,0.468368
+1.125,-0.473758,0.490799
+1.13,-0.471248,0.513122
+1.135,-0.468627,0.535334
+1.14,-0.465895,0.557429
+1.145,-0.463053,0.579401
+1.15,-0.460101,0.601247
+1.155,-0.457041,0.62296
+1.16,-0.453872,0.644536
+1.165,-0.450596,0.66597
+1.17,-0.447213,0.687257
+1.175,-0.443723,0.708392
+1.18,-0.440129,0.72937
+1.185,-0.43643,0.750186
+1.19,-0.432627,0.770836
+1.195,-0.428722,0.791314
+1.2,-0.424714,0.811615
+1.205,-0.420606,0.831736
+1.21,-0.416397,0.851669
+1.215,-0.41209,0.871412
+1.22,-0.407684,0.890959
+1.225,-0.40318,0.910306
+1.23,-0.398581,0.929447
+1.235,-0.393886,0.948378
+1.24,-0.389097,0.967094
+1.245,-0.384216,0.985591
+1.25,-0.379242,1.00386
+1.255,-0.374177,1.02191
+1.26,-0.369023,1.03972
+1.265,-0.363781,1.05729
+1.27,-0.358451,1.07462
+1.275,-0.353035,1.09171
+1.28,-0.347534,1.10854
+1.285,-0.34195,1.12511
+1.29,-0.336283,1.14143
+1.295,-0.330536,1.15748
+1.3,-0.324709,1.17327
+1.305,-0.318804,1.18878
+1.31,-0.312822,1.20402
+1.315,-0.306764,1.21897
+1.32,-0.300632,1.23364
+1.325,-0.294428,1.24802
+1.33,-0.288153,1.2621
+1.335,-0.281808,1.27589
+1.34,-0.275394,1.28938
+1.345,-0.268914,1.30257
+1.35,-0.262369,1.31545
+1.355,-0.25576,1.32801
+1.36,-0.24909,1.34026
+1.365,-0.242358,1.35219
+1.37,-0.235568,1.3638
+1.375,-0.228721,1.37509
+1.38,-0.221818,1.38605
+1.385,-0.214861,1.39667
+1.39,-0.207852,1.40696
+1.395,-0.200792,1.41691
+1.4,-0.193683,1.42653
+1.405,-0.186527,1.43579
+1.41,-0.179326,1.44472
+1.415,-0.17208,1.45329
+1.42,-0.164793,1.46151
+1.425,-0.157466,1.46938
+1.43,-0.1501,1.4769
+1.435,-0.142698,1.48405
+1.44,-0.13526,1.49085
+1.445,-0.12779,1.49728
+1.45,-0.120288,1.50335
+1.455,-0.112757,1.50905
+1.46,-0.105198,1.51439
+1.465,-0.0976136,1.51935
+1.47,-0.0900052,1.52395
+1.475,-0.0823747,1.52817
+1.48,-0.0747241,1.53202
+1.485,-0.0670552,1.53549
+1.49,-0.0593698,1.53859
+1.495,-0.0516699,1.54131
+1.5,-0.0439573,1.54366
+1.505,-0.0362339,1.54562
+1.51,-0.0285017,1.54721
+1.515,-0.0207625,1.54842
+1.52,-0.0130181,1.54925
+1.525,-0.00527062,1.5497
+1.53,0.00247819,1.54976
+1.535,0.0102264,1.54945
+1.54,0.0179721,1.54876
+1.545,0.0257134,1.54769
+1.55,0.0334484,1.54624
+1.555,0.0411751,1.54441
+1.56,0.0488918,1.5422
+1.565,0.0565965,1.53962
+1.57,0.0642873,1.53665
+1.575,0.0719624,1.53331
+1.58,0.0796199,1.5296
+1.585,0.0872578,1.52551
+1.59,0.0948743,1.52105
+1.595,0.102468,1.51622
+1.6,0.110036,1.51102
+1.605,0.117577,1.50545
+1.61,0.12509,1.49951
+1.615,0.132572,1.49321
+1.62,0.140021,1.48654
+1.625,0.147437,1.47952
+1.63,0.154816,1.47213
+1.635,0.162157,1.46439
+1.64,0.169459,1.4563
+1.645,0.17672,1.44785
+1.65,0.183937,1.43905
+1.655,0.19111,1.42991
+1.66,0.198236,1.42042
+1.665,0.205313,1.41059
+1.67,0.212341,1.40042
+1.675,0.219317,1.38991
+1.68,0.226239,1.37908
+1.685,0.233107,1.36791
+1.69,0.239918,1.35642
+1.695,0.246671,1.3446
+1.7,0.253363,1.33246
+1.705,0.259995,1.32001
+1.71,0.266563,1.30725
+1.715,0.273067,1.29417
+1.72,0.279504,1.28079
+1.725,0.285874,1.26711
+1.73,0.292175,1.25313
+1.735,0.298405,1.23885
+1.74,0.304563,1.22429
+1.745,0.310647,1.20944
+1.75,0.316657,1.1943
+1.755,0.32259,1.17889
+1.76,0.328445,1.1632
+1.765,0.334221,1.14725
+1.77,0.339917,1.13103
+1.775,0.345531,1.11454
+1.78,0.351062,1.0978
+1.785,0.356509,1.08081
+1.79,0.36187,1.06356
+1.795,0.367144,1.04608
+1.8,0.37233,1.02835
+1.805,0.377427,1.01039
+1.81,0.382434,0.992202
+1.815,0.387349,0.973785
+1.82,0.392171,0.955148
+1.825,0.3969,0.936294
+1.83,0.401534,0.917228
+1.835,0.406072,0.897955
+1.84,0.410513,0.878479
+1.845,0.414856,0.858807
+1.85,0.419101,0.838941
+1.855,0.423245,0.818887
+1.86,0.427289,0.798651
+1.865,0.431232,0.778236
+1.87,0.435071,0.757648
+1.875,0.438808,0.736891
+1.88,0.44244,0.71597
+1.885,0.445967,0.694891
+1.89,0.449389,0.673658
+1.895,0.452704,0.652277
+1.9,0.455911,0.630751
+1.905,0.459011,0.609087
+1.91,0.462002,0.587289
+1.915,0.464884,0.565361
+1.92,0.467655,0.54331
+1.925,0.470316,0.52114
+1.93,0.472867,0.498856
+1.935,0.475305,0.476463
+1.94,0.477631,0.453966
+1.945,0.479844,0.431371
+1.95,0.481945,0.408681
+1.955,0.483931,0.385903
+1.96,0.485803,0.36304
+1.965,0.487561,0.340099
+1.97,0.489204,0.317085
+1.975,0.490732,0.294002
+1.98,0.492144,0.270855
+1.985,0.49344,0.247649
+1.99,0.494621,0.224391
+1.995,0.495684,0.201083
+2,0.496631,0.177733
+2.005,0.497462,0.154344
+2.01,0.498175,0.130921
+2.015,0.498771,0.107471
+2.02,0.499249,0.0839973
+2.025,0.499611,0.0605055
+2.03,0.499854,0.0370008
+2.035,0.499981,0.0134881
+2.04,0.499989,-0.0100275
+2.045,0.49988,-0.0335409
+2.05,0.499654,-0.0570471
+2.055,0.49931,-0.0805411
+2.06,0.498849,-0.104018
+2.065,0.49827,-0.127472
+2.07,0.497574,-0.150899
+2.075,0.496761,-0.174293
+2.08,0.495831,-0.197649
+2.085,0.494784,-0.220963
+2.09,0.493621,-0.24423
+2.095,0.492342,-0.267443
+2.1,0.490947,-0.290599
+2.105,0.489436,-0.313692
+2.11,0.48781,-0.336717
+2.115,0.486069,-0.359669
+2.12,0.484214,-0.382543
+2.125,0.482244,-0.405334
+2.13,0.480161,-0.428037
+2.135,0.477964,-0.450647
+2.14,0.475654,-0.473159
+2.145,0.473232,-0.495567
+2.15,0.470699,-0.517868
+2.155,0.468054,-0.540055
+2.16,0.465298,-0.562124
+2.165,0.462433,-0.58407
+2.17,0.459458,-0.605887
+2.175,0.456374,-0.627572
+2.18,0.453182,-0.649118
+2.185,0.449883,-0.670521
+2.19,0.446477,-0.691776
+2.195,0.442966,-0.712878
+2.2,0.439349,-0.733822
+2.205,0.435628,-0.754603
+2.21,0.431803,-0.775217
+2.215,0.427876,-0.795657
+2.22,0.423847,-0.815921
+2.225,0.419717,-0.836001
+2.23,0.415487,-0.855895
+2.235,0.411158,-0.875596
+2.24,0.406732,-0.895101
+2.245,0.402208,-0.914404
+2.25,0.397588,-0.933501
+2.255,0.392873,-0.952386
+2.26,0.388064,-0.971056
+2.265,0.383163,-0.989506
+2.27,0.37817,-1.00773
+2.275,0.373086,-1.02572
+2.28,0.367913,-1.04349
+2.285,0.362651,-1.06101
+2.29,0.357303,-1.07828
+2.295,0.351869,-1.09532
+2.3,0.34635,-1.11209
+2.305,0.340749,-1.12862
+2.31,0.335065,-1.14488
+2.315,0.3293,-1.16087
+2.32,0.323456,-1.1766
+2.325,0.317535,-1.19205
+2.33,0.311536,-1.20723
+2.335,0.305463,-1.22212
+2.34,0.299316,-1.23673
+2.345,0.293096,-1.25105
+2.35,0.286806,-1.26507
+2.355,0.280446,-1.2788
+2.36,0.274018,-1.29222
+2.365,0.267524,-1.30534
+2.37,0.260965,-1.31815
+2.375,0.254343,-1.33065
+2.38,0.247659,-1.34283
+2.385,0.240915,-1.3547
+2.39,0.234113,-1.36624
+2.395,0.227254,-1.37745
+2.4,0.220339,-1.38834
+2.405,0.213371,-1.39889
+2.41,0.206351,-1.40911
+2.415,0.19928,-1.41899
+2.42,0.192161,-1.42853
+2.425,0.184995,-1.43773
+2.43,0.177785,-1.44657
+2.435,0.17053,-1.45507
+2.44,0.163234,-1.46322
+2.445,0.155899,-1.47102
+2.45,0.148525,-1.47845
+2.455,0.141115,-1.48553
+2.46,0.13367,-1.49225
+2.465,0.126193,-1.4986
+2.47,0.118685,-1.5046
+2.475,0.111147,-1.51022
+2.48,0.103583,-1.51548
+2.485,0.0959933,-1.52036
+2.49,0.0883801,-1.52488
+2.495,0.0807452,-1.52902
+2.5,0.0730905,-1.53279
+2.505,0.0654179,-1.53618
+2.51,0.0577293,-1.5392
+2.515,0.0500265,-1.54184
+2.52,0.0423115,-1.54411
+2.525,0.034586,-1.54599
+2.53,0.0268521,-1.5475
+2.535,0.0191117,-1.54863
+2.54,0.0113665,-1.54937
+2.545,0.00361855,-1.54974
+2.55,-0.00413029,-1.54973
+2.555,-0.0118781,-1.54934
+2.56,-0.019623,-1.54856
+2.565,-0.0273631,-1.54741
+2.57,-0.0350965,-1.54588
+2.575,-0.0428213,-1.54397
+2.58,-0.0505356,-1.54168
+2.585,-0.0582375,-1.53902
+2.59,-0.0659251,-1.53597
+2.595,-0.0735966,-1.53255
+2.6,-0.08125,-1.52876
+2.605,-0.0888836,-1.52459
+2.61,-0.0964953,-1.52005
+2.615,-0.104083,-1.51514
+2.62,-0.111646,-1.50986
+2.625,-0.119181,-1.50421
+2.63,-0.126688,-1.4982
+2.635,-0.134163,-1.49182
+2.64,-0.141605,-1.48508
+2.645,-0.149013,-1.47797
+2.65,-0.156384,-1.47051
+2.655,-0.163717,-1.46269
+2.66,-0.171011,-1.45452
+2.665,-0.178262,-1.446
+2.67,-0.18547,-1.43713
+2.675,-0.192633,-1.42791
+2.68,-0.199749,-1.41835
+2.685,-0.206816,-1.40845
+2.69,-0.213833,-1.39821
+2.695,-0.220797,-1.38763
+2.7,-0.227708,-1.37672
+2.705,-0.234564,-1.36549
+2.71,-0.241363,-1.35392
+2.715,-0.248103,-1.34204
+2.72,-0.254782,-1.32983
+2.725,-0.2614,-1.31732
+2.73,-0.267955,-1.30448
+2.735,-0.274445,-1.29134
+2.74,-0.280868,-1.2779
+2.745,-0.287223,-1.26415
+2.75,-0.293509,-1.25011
+2.755,-0.299724,-1.23577
+2.76,-0.305866,-1.22115
+2.765,-0.311935,-1.20623
+2.77,-0.317928,-1.19104
+2.775,-0.323845,-1.17557
+2.78,-0.329683,-1.15982
+2.785,-0.335443,-1.14381
+2.79,-0.341121,-1.12753
+2.795,-0.346717,-1.11099
+2.8,-0.352231,-1.0942
+2.805,-0.357659,-1.07715
+2.81,-0.363002,-1.05986
+2.815,-0.368257,-1.04232
+2.82,-0.373424,-1.02454
+2.825,-0.378502,-1.00653
+2.83,-0.383489,-0.988294
+2.835,-0.388385,-0.96983
+2.84,-0.393187,-0.951146
+2.845,-0.397896,-0.932246
+2.85,-0.402509,-0.913136
+2.855,-0.407027,-0.893819
+2.86,-0.411447,-0.874301
+2.865,-0.41577,-0.854587
+2.87,-0.419993,-0.834681
+2.875,-0.424116,-0.814588
+2.88,-0.428138,-0.794313
+2.885,-0.432059,-0.773861
+2.89,-0.435877,-0.753236
+2.895,-0.439591,-0.732444
+2.9,-0.443201,-0.711489
+2.905,-0.446706,-0.690377
+2.91,-0.450104,-0.669112
+2.915,-0.453397,-0.647699
+2.92,-0.456581,-0.626144
+2.925,-0.459658,-0.60445
+2.93,-0.462625,-0.582624
+2.935,-0.465484,-0.56067
+2.94,-0.468232,-0.538593
+2.945,-0.47087,-0.516398
+2.95,-0.473396,-0.494091
+2.955,-0.47581,-0.471675
+2.96,-0.478112,-0.449157
+2.965,-0.480302,-0.426541
+2.97,-0.482378,-0.403832
+2.975,-0.48434,-0.381035
+2.98,-0.486188,-0.358156
+2.985,-0.487921,-0.335199
+2.99,-0.48954,-0.312169
+2.995,-0.491043,-0.289072
+3,-0.49243,-0.265912
+3.005,-0.493702,-0.242695
+3.01,-0.494857,-0.219425
+3.015,-0.495896,-0.196108
+3.02,-0.496818,-0.172749
+3.025,-0.497623,-0.149352
+3.03,-0.498312,-0.125924
+3.035,-0.498883,-0.102468
+3.04,-0.499336,-0.07899
+3.045,-0.499672,-0.0554951
+3.05,-0.499891,-0.0319882
+3.055,-0.499992,-0.00847447
+3.06,-0.499976,0.0150411
+3.065,-0.499842,0.0385534
+3.07,-0.49959,0.0620574
+3.075,-0.499221,0.0855481
+3.08,-0.498735,0.10902
+3.085,-0.498131,0.132469
+3.09,-0.49741,0.155889
+3.095,-0.496572,0.179276
+3.1,-0.495618,0.202624
+3.105,-0.494546,0.225928
+3.11,-0.493358,0.249184
+3.115,-0.492054,0.272385
+3.12,-0.490635,0.295528
+3.125,-0.489099,0.318607
+3.13,-0.487449,0.341617
+3.135,-0.485683,0.364553
+3.14,-0.483803,0.38741
+3.145,-0.481809,0.410182
+3.15,-0.479702,0.432866
+3.155,-0.477481,0.455455
+3.16,-0.475147,0.477945
+3.165,-0.472702,0.500331
+3.17,-0.470144,0.522608
+3.175,-0.467476,0.54477
+3.18,-0.464697,0.566813
+3.185,-0.461808,0.588732
+3.19,-0.45881,0.610522
+3.195,-0.455703,0.632177
+3.2,-0.452488,0.653693
+3.205,-0.449166,0.675065
+3.21,-0.445738,0.696288
+3.215,-0.442203,0.717357
+3.22,-0.438564,0.738267
+3.225,-0.434821,0.759012
+3.23,-0.430974,0.779589
+3.235,-0.427025,0.799993
+3.24,-0.422975,0.820217
+3.245,-0.418824,0.840259
+3.25,-0.414573,0.860112
+3.255,-0.410223,0.879772
+3.26,-0.405775,0.899234
+3.265,-0.401231,0.918493
+3.27,-0.396591,0.937545
+3.275,-0.391856,0.956385
+3.28,-0.387027,0.975009
+3.285,-0.382106,0.99341
+3.29,-0.377093,1.01159
+3.295,-0.37199,1.02953
+3.3,-0.366798,1.04724
+3.305,-0.361518,1.06471
+3.31,-0.356152,1.08194
+3.315,-0.350699,1.09891
+3.32,-0.345163,1.11564
+3.325,-0.339544,1.1321
+3.33,-0.333842,1.14831
+3.335,-0.328061,1.16425
+3.34,-0.3222,1.17992
+3.345,-0.316262,1.19531
+3.35,-0.310248,1.21043
+3.355,-0.304158,1.22526
+3.36,-0.297996,1.2398
+3.365,-0.291761,1.25406
+3.37,-0.285455,1.26802
+3.375,-0.279081,1.28168
+3.38,-0.272639,1.29504
+3.385,-0.266131,1.3081
+3.39,-0.259559,1.32084
+3.395,-0.252923,1.33327
+3.4,-0.246226,1.34539
+3.405,-0.23947,1.35718
+3.41,-0.232655,1.36866
+3.415,-0.225784,1.3798
+3.42,-0.218858,1.39062
+3.425,-0.211878,1.4011
+3.43,-0.204847,1.41125
+3.435,-0.197766,1.42105
+3.44,-0.190637,1.43052
+3.445,-0.183462,1.43964
+3.45,-0.176241,1.44842
+3.455,-0.168978,1.45684
+3.46,-0.161674,1.46491
+3.465,-0.15433,1.47263
+3.47,-0.146948,1.47999
+3.475,-0.13953,1.48699
+3.48,-0.132079,1.49364
+3.485,-0.124595,1.49991
+3.49,-0.11708,1.50583
+3.495,-0.109537,1.51137
+3.5,-0.101967,1.51655
+3.505,-0.094372,1.52136
+3.51,-0.086754,1.52579
+3.515,-0.0791147,1.52986
+3.52,-0.0714561,1.53355
+3.525,-0.0637799,1.53686
+3.53,-0.0560881,1.5398
+3.535,-0.0483825,1.54236
+3.54,-0.0406651,1.54454
+3.545,-0.0329378,1.54635
+3.55,-0.0252023,1.54777
+3.555,-0.0174607,1.54882
+3.56,-0.00971474,1.54949
+3.565,-0.00196644,1.54977
+3.57,0.00578234,1.54968
+3.575,0.0135297,1.5492
+3.58,0.0212738,1.54835
+3.585,0.0290126,1.54712
+3.59,0.0367443,1.54551
+3.595,0.044467,1.54351
+3.6,0.0521788,1.54114
+3.605,0.0598778,1.5384
+3.61,0.0675622,1.53527
+3.615,0.0752299,1.53178
+3.62,0.0828793,1.5279
+3.625,0.0905083,1.52365
+3.63,0.0981152,1.51904
+3.635,0.105698,1.51405
+3.64,0.113255,1.50869
+3.645,0.120784,1.50296
+3.65,0.128284,1.49687
+3.655,0.135752,1.49041
+3.66,0.143188,1.48359
+3.665,0.150588,1.47641
+3.67,0.157951,1.46887
+3.675,0.165276,1.46098
+3.68,0.17256,1.45274
+3.685,0.179803,1.44414
+3.69,0.187001,1.43519
+3.695,0.194154,1.4259
+3.7,0.20126,1.41627
+3.705,0.208316,1.40629
+3.71,0.215322,1.39598
+3.715,0.222275,1.38533
+3.72,0.229175,1.37435
+3.725,0.236018,1.36305
+3.73,0.242805,1.35142
+3.735,0.249532,1.33946
+3.74,0.256199,1.32719
+3.745,0.262803,1.31461
+3.75,0.269344,1.30171
+3.755,0.27582,1.2885
+3.76,0.282229,1.27499
+3.765,0.288569,1.26118
+3.77,0.29484,1.24708
+3.775,0.30104,1.23268
+3.78,0.307166,1.21799
+3.785,0.313219,1.20302
+3.79,0.319196,1.18776
+3.795,0.325096,1.17223
+3.8,0.330918,1.15643
+3.805,0.33666,1.14036
+3.81,0.342321,1.12403
+3.815,0.3479,1.10743
+3.82,0.353395,1.09058
+3.825,0.358805,1.07348
+3.83,0.36413,1.05614
+3.835,0.369366,1.03855
+3.84,0.374515,1.02072
+3.845,0.379573,1.00266
+3.85,0.384541,0.984376
+3.855,0.389417,0.965865
+3.86,0.394199,0.947134
+3.865,0.398888,0.928189
+3.87,0.403481,0.909034
+3.875,0.407978,0.889675
+3.88,0.412377,0.870114
+3.885,0.416678,0.850359
+3.89,0.42088,0.830412
+3.895,0.424982,0.81028
+3.9,0.428983,0.789967
+3.905,0.432882,0.769478
+3.91,0.436677,0.748817
+3.915,0.440369,0.72799
+3.92,0.443957,0.707001
+3.925,0.447439,0.685856
+3.93,0.450815,0.664559
+3.935,0.454085,0.643115
+3.94,0.457246,0.62153
+3.945,0.4603,0.599808
+3.95,0.463244,0.577954
+3.955,0.466079,0.555973
+3.96,0.468804,0.533871
+3.965,0.471417,0.511651
+3.97,0.47392,0.48932
+3.975,0.47631,0.466883
+3.98,0.478589,0.444343
+3.985,0.480754,0.421706
+3.99,0.482806,0.398978
+3.995,0.484743,0.376164
+4,0.486567,0.353267
+4.005,0.488276,0.330294
+4.01,0.48987,0.30725
+4.015,0.491348,0.284139
+4.02,0.492711,0.260967
+4.025,0.493958,0.237738
+4.03,0.495088,0.214458
+4.035,0.496102,0.191131
+4.04,0.497,0.167764
+4.045,0.49778,0.14436
+4.05,0.498443,0.120925
+4.055,0.498989,0.0974639
+4.06,0.499418,0.0739819
+4.065,0.499729,0.050484
+4.07,0.499923,0.0269753
+4.075,0.499999,0.00346074
+4.08,0.499957,-0.0200546
+4.085,0.499798,-0.0435655
+4.09,0.499522,-0.0670671
+4.095,0.499128,-0.0905543
+4.1,0.498616,-0.114022
+4.105,0.497987,-0.137465
+4.11,0.497241,-0.160879
+4.115,0.496379,-0.184257
+4.12,0.495399,-0.207596
+4.125,0.494303,-0.230891
+4.13,0.49309,-0.254135
+4.135,0.491761,-0.277325
+4.14,0.490317,-0.300454
+4.145,0.488757,-0.323519
+4.15,0.487082,-0.346513
+4.155,0.485292,-0.369433
+4.16,0.483388,-0.392272
+4.165,0.481369,-0.415026
+4.17,0.479238,-0.43769
+4.175,0.476993,-0.460259
+4.18,0.474635,-0.482727
+4.185,0.472166,-0.50509
+4.19,0.469584,-0.527343
+4.195,0.466892,-0.54948
+4.2,0.46409,-0.571497
+4.205,0.461178,-0.593389
+4.21,0.458156,-0.61515
+4.215,0.455026,-0.636777
+4.22,0.451789,-0.658262
+4.225,0.448444,-0.679603
+4.23,0.444993,-0.700793
+4.235,0.441436,-0.721829
+4.24,0.437775,-0.742704
+4.245,0.43401,-0.763414
+4.25,0.430141,-0.783954
+4.255,0.42617,-0.80432
+4.26,0.422098,-0.824506
+4.265,0.417926,-0.844508
+4.27,0.413653,-0.86432
+4.275,0.409283,-0.883938
+4.28,0.404814,-0.903357
+4.285,0.400249,-0.922573
+4.29,0.395589,-0.94158
+4.295,0.390834,-0.960374
+4.3,0.385986,-0.978951
+4.305,0.381045,-0.997305
+4.31,0.376013,-1.01543
+4.315,0.370891,-1.03333
+4.32,0.36568,-1.05099
+4.325,0.360381,-1.0684
+4.33,0.354996,-1.08558
+4.335,0.349526,-1.1025
+4.34,0.343972,-1.11917
+4.345,0.338335,-1.13558
+4.35,0.332616,-1.15173
+4.355,0.326818,-1.16761
+4.36,0.320941,-1.18322
+4.365,0.314986,-1.19856
+4.37,0.308956,-1.21361
+4.375,0.302851,-1.22838
+4.38,0.296672,-1.24287
+4.385,0.290422,-1.25706
+4.39,0.284102,-1.27096
+4.395,0.277713,-1.28456
+4.4,0.271257,-1.29785
+4.405,0.264735,-1.31084
+4.41,0.258149,-1.32352
+4.415,0.251501,-1.33588
+4.42,0.244791,-1.34793
+4.425,0.238022,-1.35966
+4.43,0.231195,-1.37106
+4.435,0.224312,-1.38214
+4.44,0.217374,-1.39288
+4.445,0.210383,-1.40329
+4.45,0.203342,-1.41337
+4.455,0.19625,-1.4231
+4.46,0.189111,-1.43249
+4.465,0.181926,-1.44154
+4.47,0.174696,-1.45024
+4.475,0.167424,-1.45859
+4.48,0.160111,-1.46659
+4.485,0.152759,-1.47423
+4.49,0.145369,-1.48152
+4.495,0.137944,-1.48844
+4.5,0.130486,-1.495
+4.505,0.122995,-1.5012
+4.51,0.115474,-1.50704
+4.515,0.107925,-1.51251
+4.52,0.10035,-1.51761
+4.525,0.0927497,-1.52233
+4.53,0.085127,-1.52669
+4.535,0.0774834,-1.53067
+4.54,0.0698208,-1.53428
+4.545,0.0621412,-1.53752
+4.55,0.0544463,-1.54038
+4.555,0.0467381,-1.54286
+4.56,0.0390184,-1.54496
+4.565,0.0312891,-1.54668
+4.57,0.0235522,-1.54803
+4.575,0.0158095,-1.54899
+4.58,0.00806288,-1.54958
+4.585,0.000314313,-1.54978
+4.59,-0.00743433,-1.54961
+4.595,-0.0151811,-1.54905
+4.6,-0.0229242,-1.54812
+4.605,-0.0306617,-1.54681
+4.61,-0.0383917,-1.54511
+4.615,-0.0461122,-1.54304
+4.62,-0.0538214,-1.54059
+4.625,-0.0615175,-1.53776
+4.63,-0.0691984,-1.53456
+4.635,-0.0768625,-1.53098
+4.64,-0.0845076,-1.52703
+4.645,-0.0921321,-1.5227
+4.65,-0.099734,-1.518
+4.655,-0.107312,-1.51293
+4.66,-0.114863,-1.5075
+4.665,-0.122386,-1.50169
+4.67,-0.129879,-1.49552
+4.675,-0.13734,-1.48899
+4.68,-0.144768,-1.48209
+4.685,-0.152161,-1.47483
+4.69,-0.159516,-1.46722
+4.695,-0.166832,-1.45925
+4.7,-0.174108,-1.45093
+4.705,-0.181341,-1.44226
+4.71,-0.18853,-1.43324
+4.715,-0.195673,-1.42388
+4.72,-0.202768,-1.41417
+4.725,-0.209814,-1.40412
+4.73,-0.216809,-1.39374
+4.735,-0.223751,-1.38302
+4.74,-0.230639,-1.37197
+4.745,-0.23747,-1.3606
+4.75,-0.244244,-1.34889
+4.755,-0.250958,-1.33687
+4.76,-0.257612,-1.32453
+4.765,-0.264203,-1.31188
+4.77,-0.27073,-1.29892
+4.775,-0.277192,-1.28565
+4.78,-0.283586,-1.27207
+4.785,-0.289912,-1.2582
+4.79,-0.296168,-1.24403
+4.795,-0.302352,-1.22957
+4.8,-0.308463,-1.21482
+4.805,-0.3145,-1.19979
+4.81,-0.320461,-1.18448
+4.815,-0.326344,-1.16889
+4.82,-0.332149,-1.15303
+4.825,-0.337874,-1.1369
+4.83,-0.343518,-1.12051
+4.835,-0.349079,-1.10386
+4.84,-0.354556,-1.08696
+4.845,-0.359948,-1.06981
+4.85,-0.365253,-1.05241
+4.855,-0.370471,-1.03477
+4.86,-0.375601,-1.01689
+4.865,-0.38064,-0.998784
+4.87,-0.385588,-0.980448
+4.875,-0.390444,-0.961889
+4.88,-0.395207,-0.943113
+4.885,-0.399875,-0.924123
+4.89,-0.404448,-0.904924
+4.895,-0.408924,-0.885521
+4.9,-0.413302,-0.865919
+4.905,-0.417583,-0.846122
+4.91,-0.421763,-0.826136
+4.915,-0.425844,-0.805964
+4.92,-0.429823,-0.785613
+4.925,-0.4337,-0.765087
+4.93,-0.437473,-0.74439
+4.935,-0.441143,-0.723528
+4.94,-0.444708,-0.702506
+4.945,-0.448168,-0.681328
+4.95,-0.451521,-0.659999
+4.955,-0.454768,-0.638525
+4.96,-0.457906,-0.61691
+4.965,-0.460937,-0.595159
+4.97,-0.463858,-0.573278
+4.975,-0.466669,-0.551271
+4.98,-0.46937,-0.529143
+4.985,-0.47196,-0.5069
+4.99,-0.474439,-0.484545
+4.995,-0.476806,-0.462085
+5,-0.47906,-0.439525
+5.005,-0.481201,-0.416868
+5.01,-0.483228,-0.394121
+5.015,-0.485142,-0.371289
+5.02,-0.486941,-0.348376
+5.025,-0.488625,-0.325387
+5.03,-0.490195,-0.302328
+5.035,-0.491649,-0.279203
+5.04,-0.492987,-0.256019
+5.045,-0.494209,-0.232778
+5.05,-0.495314,-0.209488
+5.055,-0.496304,-0.186152
+5.06,-0.497176,-0.162777
+5.065,-0.497931,-0.139366
+5.07,-0.498569,-0.115925
+5.075,-0.49909,-0.0924589
+5.08,-0.499494,-0.0689731
+5.085,-0.49978,-0.0454725
+5.09,-0.499949,-0.0219621
+5.095,-0.5,0.00155303
+5.1,-0.499933,0.0250678
+5.105,-0.499749,0.0485772
+5.11,-0.499447,0.0720762
+5.115,-0.499028,0.0955596
+5.12,-0.498492,0.119022
+5.125,-0.497838,0.14246
+5.13,-0.497067,0.165866
+5.135,-0.49618,0.189237
+5.14,-0.495175,0.212567
+5.145,-0.494054,0.235851
+5.15,-0.492817,0.259084
+5.155,-0.491463,0.282261
+5.16,-0.489994,0.305377
+5.165,-0.48841,0.328428
+5.17,-0.48671,0.351406
+5.175,-0.484896,0.374309
+5.18,-0.482967,0.397131
+5.185,-0.480924,0.419866
+5.19,-0.478768,0.44251
+5.195,-0.4765,0.465058
+5.2,-0.474118,0.487504
+5.205,-0.471625,0.509844
+5.21,-0.46902,0.532073
+5.215,-0.466304,0.554185
+5.22,-0.463478,0.576175
+5.225,-0.460543,0.59804
+5.23,-0.457498,0.619773
+5.235,-0.454345,0.641369
+5.24,-0.451085,0.662825
+5.245,-0.447717,0.684134
+5.25,-0.444243,0.705291
+5.255,-0.440664,0.726293
+5.26,-0.436981,0.747133
+5.265,-0.433193,0.767808
+5.27,-0.429303,0.788311
+5.275,-0.425311,0.808639
+5.28,-0.421217,0.828786
+5.285,-0.417023,0.848748
+5.29,-0.41273,0.868519
+5.295,-0.408338,0.888095
+5.3,-0.403849,0.907471
+5.305,-0.399264,0.926643
+5.31,-0.394583,0.945605
+5.315,-0.389808,0.964353
+5.32,-0.38494,0.982883
+5.325,-0.37998,1.00119
+5.33,-0.374928,1.01927
+5.335,-0.369787,1.03711
+5.34,-0.364558,1.05472
+5.345,-0.359241,1.07209
+5.35,-0.353837,1.08921
+5.355,-0.348349,1.10608
+5.36,-0.342777,1.12269
+5.365,-0.337122,1.13905
+5.37,-0.331387,1.15514
+5.375,-0.325571,1.17096
+5.38,-0.319678,1.18651
+5.385,-0.313707,1.20179
+5.39,-0.30766,1.21679
+5.395,-0.301539,1.2315
+5.4,-0.295346,1.24592
+5.405,-0.289081,1.26005
+5.41,-0.282746,1.27388
+5.415,-0.276342,1.28742
+5.42,-0.269872,1.30065
+5.425,-0.263336,1.31357
+5.43,-0.256737,1.32618
+5.435,-0.250075,1.33848
+5.44,-0.243353,1.35046
+5.445,-0.236571,1.36212
+5.45,-0.229732,1.37345
+5.455,-0.222837,1.38445
+5.46,-0.215888,1.39513
+5.465,-0.208886,1.40547
+5.47,-0.201834,1.41547
+5.475,-0.194732,1.42513
+5.48,-0.187583,1.43445
+5.485,-0.180388,1.44343
+5.49,-0.173149,1.45205
+5.495,-0.165868,1.46033
+5.5,-0.158547,1.46825
+5.505,-0.151186,1.47581
+5.51,-0.143789,1.48302
+5.515,-0.136357,1.48987
+5.52,-0.128891,1.49636
+5.525,-0.121394,1.50248
+5.53,-0.113867,1.50824
+5.535,-0.106312,1.51362
+5.54,-0.0987313,1.51864
+5.545,-0.0911263,1.52329
+5.55,-0.083499,1.52757
+5.555,-0.0758512,1.53148
+5.56,-0.0681848,1.535
+5.565,-0.0605018,1.53816
+5.57,-0.0528039,1.54094
+5.575,-0.0450931,1.54334
+5.58,-0.0373712,1.54536
+5.585,-0.0296401,1.547
+5.59,-0.0219018,1.54827
+5.595,-0.0141581,1.54915
+5.6,-0.00641092,1.54965
+5.605,0.00133782,1.54978
+5.61,0.00908623,1.54952
+5.615,0.0168324,1.54889
+5.62,0.0245745,1.54787
+5.625,0.0323105,1.54648
+5.63,0.0400386,1.5447
+5.635,0.0477569,1.54255
+5.64,0.0554635,1.54002
+5.645,0.0631565,1.53711
+5.65,0.070834,1.53383
+5.655,0.0784941,1.53017
+5.66,0.086135,1.52614
+5.665,0.0937549,1.52173
+5.67,0.101352,1.51695
+5.675,0.108924,1.51181
+5.68,0.116469,1.50629
+5.685,0.123986,1.50041
+5.69,0.131473,1.49416
+5.695,0.138927,1.48755
+5.7,0.146347,1.48057
+5.705,0.153732,1.47324
+5.71,0.161079,1.46555
+5.715,0.168387,1.45751
+5.72,0.175654,1.44911
+5.725,0.182878,1.44037
+5.73,0.190057,1.43127
+5.735,0.19719,1.42183
+5.74,0.204275,1.41205
+5.745,0.21131,1.40194
+5.75,0.218293,1.39148
+5.755,0.225224,1.38069
+5.76,0.2321,1.36957
+5.765,0.238919,1.35813
+5.77,0.245681,1.34636
+5.775,0.252382,1.33427
+5.78,0.259023,1.32186
+5.785,0.2656,1.30914
+5.79,0.272114,1.29611
+5.795,0.278561,1.28278
+5.8,0.284941,1.26914
+5.805,0.291252,1.2552
+5.81,0.297492,1.24097
+5.815,0.303661,1.22645
+5.82,0.309756,1.21164
+5.825,0.315777,1.19655
+5.83,0.321721,1.18118
+5.835,0.327588,1.16553
+5.84,0.333376,1.14961
+5.845,0.339084,1.13343
+5.85,0.34471,1.11698
+5.855,0.350253,1.10028
+5.86,0.355713,1.08332
+5.865,0.361086,1.06612
+5.87,0.366373,1.04867
+5.875,0.371573,1.03098
+5.88,0.376683,1.01305
+5.885,0.381703,0.994893
+5.89,0.386631,0.97651
+5.895,0.391467,0.957904
+5.9,0.39621,0.939082
+5.905,0.400858,0.920047
+5.91,0.40541,0.900804
+5.915,0.409866,0.881358
+5.92,0.414223,0.861714
+5.925,0.418482,0.841876
+5.93,0.422642,0.82185
+5.935,0.426701,0.80164
+5.94,0.430658,0.781251
+5.945,0.434513,0.760688
+5.95,0.438264,0.739956
+5.955,0.441912,0.719059
+5.96,0.445455,0.698003
+5.965,0.448892,0.676793
+5.97,0.452222,0.655433
+5.975,0.455446,0.633928
+5.98,0.458562,0.612284
+5.985,0.461569,0.590505
+5.99,0.464466,0.568596
+5.995,0.467254,0.546563
+6,0.469932,0.52441
+6.005,0.472498,0.502143
+6.01,0.474953,0.479765
+6.015,0.477296,0.457283
+6.02,0.479526,0.434702
+6.025,0.481643,0.412026
+6.03,0.483646,0.38926
+6.035,0.485535,0.36641
+6.04,0.48731,0.34348
+6.045,0.48897,0.320476
+6.05,0.490514,0.297403
+6.055,0.491944,0.274265
+6.06,0.493257,0.251068
+6.065,0.494454,0.227817
+6.07,0.495535,0.204516
+6.075,0.496499,0.181172
+6.08,0.497347,0.157788
+6.085,0.498077,0.13437
+6.09,0.49869,0.110924
+6.095,0.499186,0.087453
+6.1,0.499565,0.0639637
+6.105,0.499826,0.0404605
+6.11,0.499969,0.0169487
+6.115,0.499995,-0.00656678
+6.12,0.499904,-0.0300809
+6.125,0.499695,-0.0535885
+6.13,0.499368,-0.0770845
+6.135,0.498924,-0.100564
+6.14,0.498362,-0.124022
+6.145,0.497684,-0.147453
+6.15,0.496888,-0.170852
+6.155,0.495975,-0.194215
+6.16,0.494946,-0.217535
+6.165,0.4938,-0.240809
+6.17,0.492538,-0.264031
+6.175,0.49116,-0.287195
+6.18,0.489666,-0.310298
+6.185,0.488057,-0.333333
+6.19,0.486333,-0.356296
+6.195,0.484494,-0.379182
+6.2,0.482541,-0.401986
+6.205,0.480474,-0.424702
+6.21,0.478294,-0.447326
+6.215,0.476001,-0.469852
+6.22,0.473596,-0.492276
+6.225,0.471079,-0.514593
+6.23,0.46845,-0.536797
+6.235,0.465711,-0.558884
+6.24,0.462861,-0.580848
+6.245,0.459903,-0.602685
+6.25,0.456835,-0.624389
+6.255,0.453659,-0.645956
+6.26,0.450375,-0.66738
+6.265,0.446985,-0.688658
+6.27,0.443489,-0.709782
+6.275,0.439888,-0.73075
+6.28,0.436182,-0.751555
+6.285,0.432373,-0.772194
+6.29,0.42846,-0.79266
+6.295,0.424446,-0.81295
+6.3,0.420331,-0.833058
+6.305,0.416116,-0.852979
+6.31,0.411802,-0.872709
+6.315,0.407389,-0.892243
+6.32,0.40288,-0.911576
+6.325,0.398274,-0.930704
+6.33,0.393573,-0.949621
+6.335,0.388778,-0.968322
+6.34,0.38389,-0.986805
+6.345,0.37891,-1.00506
+6.35,0.37384,-1.02309
+6.355,0.36868,-1.04089
+6.36,0.363431,-1.05844
+6.365,0.358096,-1.07576
+6.37,0.352674,-1.09282
+6.375,0.347168,-1.10964
+6.38,0.341578,-1.1262
+6.385,0.335906,-1.1425
+6.39,0.330154,-1.15854
+6.395,0.324321,-1.1743
+6.4,0.318411,-1.1898
+6.405,0.312424,-1.20501
+6.41,0.306361,-1.21995
+6.415,0.300225,-1.2346
+6.42,0.294016,-1.24896
+6.425,0.287736,-1.26302
+6.43,0.281386,-1.27679
+6.435,0.274968,-1.29026
+6.44,0.268484,-1.30343
+6.445,0.261935,-1.31629
+6.45,0.255322,-1.32883
+6.455,0.248647,-1.34106
+6.46,0.241912,-1.35297
+6.465,0.235118,-1.36456
+6.47,0.228267,-1.37582
+6.475,0.22136,-1.38676
+6.48,0.2144,-1.39736
+6.485,0.207387,-1.40763
+6.49,0.200324,-1.41756
+6.495,0.193212,-1.42715
+6.5,0.186053,-1.43639
+6.505,0.178849,-1.44529
+6.51,0.171601,-1.45385
+6.515,0.164311,-1.46204
+6.52,0.156981,-1.46989
+6.525,0.149612,-1.47738
+6.53,0.142207,-1.48451
+6.535,0.134768,-1.49128
+6.54,0.127295,-1.49769
+6.545,0.119791,-1.50374
+6.55,0.112258,-1.50942
+6.555,0.104698,-1.51473
+6.56,0.0971118,-1.51967
+6.565,0.0895019,-1.52424
+6.57,0.0818701,-1.52843
+6.575,0.0742182,-1.53226
+6.58,0.0665481,-1.53571
+6.585,0.0588617,-1.53878
+6.59,0.0511609,-1.54148
+6.595,0.0434475,-1.5438
+6.6,0.0357235,-1.54574
+6.605,0.0279908,-1.5473
+6.61,0.0202511,-1.54849
+6.615,0.0125066,-1.54929
+6.62,0.00475889,-1.54971
+6.625,-0.00298994,-1.54976
+6.63,-0.010738,-1.54942
+6.635,-0.0184835,-1.5487
+6.64,-0.0262244,-1.54761
+6.645,-0.0339589,-1.54613
+6.65,-0.0416851,-1.54428
+6.655,-0.049401,-1.54204
+6.66,-0.0571049,-1.53943
+6.665,-0.0647947,-1.53644
+6.67,-0.0724687,-1.53308
+6.675,-0.0801249,-1.52934
+6.68,-0.0877615,-1.52523
+6.685,-0.0953766,-1.52074
+6.69,-0.102968,-1.51589
+6.695,-0.110535,-1.51066
+6.7,-0.118074,-1.50507
+6.705,-0.125585,-1.4991
+6.71,-0.133065,-1.49278
+6.715,-0.140512,-1.48609
+6.72,-0.147925,-1.47904
+6.725,-0.155302,-1.47163
+6.73,-0.162641,-1.46387
+6.735,-0.16994,-1.45575
+6.74,-0.177198,-1.44728
+6.745,-0.184412,-1.43846
+6.75,-0.191582,-1.42929
+6.755,-0.198704,-1.41978
+6.76,-0.205779,-1.40993
+6.765,-0.212803,-1.39973
+6.77,-0.219776,-1.38921
+6.775,-0.226695,-1.37835
+6.78,-0.233559,-1.36716
+6.785,-0.240366,-1.35565
+6.79,-0.247114,-1.34381
+6.795,-0.253803,-1.33165
+6.8,-0.26043,-1.31918
+6.805,-0.266995,-1.30639
+6.81,-0.273494,-1.2933
+6.815,-0.279927,-1.2799
+6.82,-0.286292,-1.26619
+6.825,-0.292588,-1.25219
+6.83,-0.298814,-1.2379
+6.835,-0.304967,-1.22332
+6.84,-0.311046,-1.20845
+6.845,-0.317051,-1.19329
+6.85,-0.322979,-1.17786
+6.855,-0.328829,-1.16216
+6.86,-0.3346,-1.14618
+6.865,-0.34029,-1.12994
+6.87,-0.345899,-1.11344
+6.875,-0.351424,-1.09669
+6.88,-0.356866,-1.07968
+6.885,-0.362221,-1.06242
+6.89,-0.367489,-1.04492
+6.895,-0.37267,-1.02717
+6.9,-0.377761,-1.0092
+6.905,-0.382761,-0.990993
+6.91,-0.38767,-0.972561
+6.915,-0.392486,-0.953909
+6.92,-0.397209,-0.935041
+6.925,-0.401836,-0.915961
+6.93,-0.406368,-0.896675
+6.935,-0.410803,-0.877186
+6.94,-0.41514,-0.8575
+6.945,-0.419378,-0.837622
+6.95,-0.423516,-0.817557
+6.955,-0.427553,-0.797308
+6.96,-0.431488,-0.776881
+6.965,-0.435321,-0.756282
+6.97,-0.439051,-0.735514
+6.975,-0.442676,-0.714583
+6.98,-0.446197,-0.693494
+6.985,-0.449611,-0.672251
+6.99,-0.452919,-0.65086
+6.995,-0.456119,-0.629325
+7,-0.459212,-0.607651
+7.005,-0.462196,-0.585844
+7.01,-0.46507,-0.563909
+7.015,-0.467834,-0.54185
+7.02,-0.470488,-0.519672
+7.025,-0.473031,-0.497381
+7.03,-0.475462,-0.474981
+7.035,-0.477781,-0.452477
+7.04,-0.479987,-0.429875
+7.045,-0.482079,-0.407179
+7.05,-0.484058,-0.384395
+7.055,-0.485923,-0.361528
+7.06,-0.487673,-0.338582
+7.065,-0.489309,-0.315562
+7.07,-0.490829,-0.292475
+7.075,-0.492233,-0.269324
+7.08,-0.493522,-0.246115
+7.085,-0.494694,-0.222853
+7.09,-0.49575,-0.199542
+7.095,-0.49669,-0.176189
+7.1,-0.497512,-0.152798
+7.105,-0.498218,-0.129373
+7.11,-0.498806,-0.105921
+7.115,-0.499277,-0.0824463
+7.12,-0.49963,-0.0589536
+7.125,-0.499866,-0.0354482
+7.13,-0.499985,-0.0119351
+7.135,-0.499986,0.0115805
+7.14,-0.499869,0.0350936
+7.145,-0.499635,0.0585992
+7.15,-0.499283,0.0820921
+7.155,-0.498814,0.105567
+7.16,-0.498227,0.12902
+7.165,-0.497524,0.152445
+7.17,-0.496703,0.175837
+7.175,-0.495765,0.199191
+7.18,-0.494711,0.222502
+7.185,-0.493541,0.245765
+7.19,-0.492254,0.268974
+7.195,-0.490851,0.292126
+7.2,-0.489333,0.315215
+7.205,-0.487699,0.338235
+7.21,-0.48595,0.361182
+7.215,-0.484087,0.384051
+7.22,-0.48211,0.406836
+7.225,-0.480019,0.429533
+7.23,-0.477815,0.452137
+7.235,-0.475498,0.474642
+7.24,-0.473068,0.497043
+7.245,-0.470527,0.519337
+7.25,-0.467875,0.541516
+7.255,-0.465113,0.563577
+7.26,-0.46224,0.585515
+7.265,-0.459258,0.607323
+7.27,-0.456167,0.628999
+7.275,-0.452968,0.650536
+7.28,-0.449662,0.671929
+7.285,-0.446249,0.693174
+7.29,-0.44273,0.714266
+7.295,-0.439106,0.7352
+7.3,-0.435378,0.75597
+7.305,-0.431547,0.776572
+7.31,-0.427613,0.797001
+7.315,-0.423577,0.817252
+7.32,-0.419441,0.837321
+7.325,-0.415204,0.857202
+7.33,-0.410869,0.876891
+7.335,-0.406436,0.896382
+7.34,-0.401906,0.915672
+7.345,-0.397279,0.934755
+7.35,-0.392558,0.953626
+7.355,-0.387744,0.972282
+7.36,-0.382836,0.990716
+7.365,-0.377837,1.00893
+7.37,-0.372747,1.0269
+7.375,-0.367568,1.04465
+7.38,-0.362301,1.06216
+7.385,-0.356947,1.07942
+7.39,-0.351507,1.09643
+7.395,-0.345983,1.11319
+7.4,-0.340376,1.1297
+7.405,-0.334686,1.14594
+7.41,-0.328917,1.16192
+7.415,-0.323068,1.17763
+7.42,-0.317141,1.19306
+7.425,-0.311138,1.20822
+7.43,-0.305059,1.22309
+7.435,-0.298907,1.23768
+7.44,-0.292683,1.25198
+7.445,-0.286388,1.26599
+7.45,-0.280023,1.27969
+7.455,-0.273591,1.2931
+7.46,-0.267093,1.3062
+7.465,-0.26053,1.31899
+7.47,-0.253904,1.33146
+7.475,-0.247216,1.34363
+7.48,-0.240468,1.35547
+7.485,-0.233662,1.36699
+7.49,-0.226799,1.37818
+7.495,-0.21988,1.38905
+7.5,-0.212909,1.39958
+7.505,-0.205885,1.40977
+7.51,-0.198812,1.41963
+7.515,-0.191689,1.42915
+7.52,-0.184521,1.43832
+7.525,-0.177307,1.44715
+7.53,-0.17005,1.45562
+7.535,-0.162751,1.46375
+7.54,-0.155413,1.47152
+7.545,-0.148037,1.47893
+7.55,-0.140624,1.48599
+7.555,-0.133177,1.49268
+7.56,-0.125698,1.49901
+7.565,-0.118188,1.50498
+7.57,-0.110649,1.51058
+7.575,-0.103083,1.51581
+7.58,-0.0954912,1.52067
+7.585,-0.0878765,1.52516
+7.59,-0.0802402,1.52928
+7.595,-0.0725843,1.53303
+7.6,-0.0649106,1.5364
+7.605,-0.057221,1.53939
+7.61,-0.0495173,1.54201
+7.615,-0.0418015,1.54424
+7.62,-0.0340755,1.5461
+7.625,-0.0263411,1.54759
+7.63,-0.0186003,1.54869
+7.635,-0.0108549,1.54941
+7.64,-0.00310681,1.54975
+7.645,0.00464202,1.54972
+7.65,0.0123897,1.5493
+7.655,0.0201344,1.5485
+7.66,0.0278741,1.54732
+7.665,0.035607,1.54577
+7.67,0.0433311,1.54383
+7.675,0.0510446,1.54152
+7.68,0.0587457,1.53883
+7.685,0.0664323,1.53576
+7.69,0.0741026,1.53231
+7.695,0.0817548,1.5285
+7.7,0.0893869,1.5243
+7.705,0.0969972,1.51974
+7.71,0.104584,1.5148
+7.715,0.112145,1.5095
+7.72,0.119678,1.50383
+7.725,0.127182,1.49779
+7.73,0.134655,1.49138
+7.735,0.142095,1.48462
+7.74,0.149501,1.47749
+7.745,0.15687,1.47001
+7.75,0.1642,1.46217
+7.755,0.171491,1.45397
+7.76,0.17874,1.44543
+7.765,0.185945,1.43653
+7.77,0.193104,1.42729
+7.775,0.200217,1.41771
+7.78,0.207281,1.40778
+7.785,0.214294,1.39752
+7.79,0.221255,1.38692
+7.795,0.228163,1.37599
+7.8,0.235015,1.36473
+7.805,0.24181,1.35315
+7.81,0.248546,1.34124
+7.815,0.255221,1.32902
+7.82,0.261835,1.31648
+7.825,0.268386,1.30363
+7.83,0.274871,1.29046
+7.835,0.28129,1.277
+7.84,0.287641,1.26323
+7.845,0.293922,1.24917
+7.85,0.300132,1.23481
+7.855,0.306269,1.22017
+7.86,0.312333,1.20524
+7.865,0.318321,1.19003
+7.87,0.324233,1.17454
+7.875,0.330066,1.15878
+7.88,0.33582,1.14274
+7.885,0.341493,1.12645
+7.89,0.347084,1.10989
+7.895,0.352592,1.09308
+7.9,0.358015,1.07602
+7.905,0.363351,1.05871
+7.91,0.368601,1.04115
+7.915,0.373763,1.02336
+7.92,0.378834,1.00534
+7.925,0.383816,0.987082
+7.93,0.388705,0.968603
+7.935,0.393501,0.949904
+7.94,0.398204,0.93099
+7.945,0.402811,0.911866
+7.95,0.407322,0.892536
+7.955,0.411736,0.873005
+7.96,0.416052,0.853278
+7.965,0.420268,0.83336
+7.97,0.424385,0.813255
+7.975,0.428401,0.792968
+7.98,0.432314,0.772504
+7.985,0.436125,0.751868
+7.99,0.439833,0.731065
+7.995,0.443436,0.7101
+8,0.446933,0.688977
+8.005,0.450325,0.667702
+8.01,0.45361,0.64628
+8.015,0.456788,0.624715
+8.02,0.459857,0.603013
+8.025,0.462818,0.581178
+8.03,0.465669,0.559216
+8.035,0.46841,0.537131
+8.04,0.47104,0.514929
+8.045,0.473559,0.492614
+8.05,0.475966,0.470191
+8.055,0.47826,0.447666
+8.06,0.480442,0.425044
+8.065,0.482511,0.402329
+8.07,0.484465,0.379527
+8.075,0.486306,0.356642
+8.08,0.488032,0.33368
+8.085,0.489643,0.310646
+8.09,0.491138,0.287544
+8.095,0.492518,0.26438
+8.1,0.493782,0.24116
+8.105,0.494929,0.217887
+8.11,0.495961,0.194567
+8.115,0.496875,0.171205
+8.12,0.497672,0.147806
+8.125,0.498353,0.124375
+8.13,0.498916,0.100918
+8.135,0.499362,0.0774388
+8.14,0.499691,0.0539429
+8.145,0.499902,0.0304355
+8.15,0.499995,0.00692146
+8.155,0.499971,-0.016594
+8.16,0.499829,-0.040106
+8.165,0.49957,-0.0636093
+8.17,0.499193,-0.0870989
+8.175,0.498699,-0.11057
+8.18,0.498087,-0.134017
+8.185,0.497359,-0.157435
+8.19,0.496513,-0.180819
+8.195,0.49555,-0.204164
+8.2,0.494471,-0.227466
+8.205,0.493276,-0.250718
+8.21,0.491964,-0.273916
+8.215,0.490537,-0.297054
+8.22,0.488994,-0.320129
+8.225,0.487336,-0.343134
+8.23,0.485563,-0.366065
+8.235,0.483675,-0.388916
+8.24,0.481674,-0.411683
+8.245,0.479558,-0.434361
+8.25,0.47733,-0.456944
+8.255,0.474989,-0.479427
+8.26,0.472536,-0.501806
+8.265,0.469971,-0.524075
+8.27,0.467296,-0.54623
+8.275,0.464509,-0.568265
+8.28,0.461613,-0.590175
+8.285,0.458608,-0.611956
+8.29,0.455494,-0.633603
+8.295,0.452272,-0.655109
+8.3,0.448943,-0.676472
+8.305,0.445507,-0.697684
+8.31,0.441966,-0.718743
+8.315,0.43832,-0.739642
+8.32,0.43457,-0.760377
+8.325,0.430717,-0.780942
+8.33,0.426761,-0.801334
+8.335,0.422704,-0.821547
+8.34,0.418546,-0.841576
+8.345,0.414288,-0.861416
+8.35,0.409932,-0.881063
+8.355,0.405478,-0.900512
+8.36,0.400927,-0.919758
+8.365,0.396281,-0.938796
+8.37,0.39154,-0.957622
+8.375,0.386705,-0.976231
+8.38,0.381778,-0.994618
+8.385,0.376759,-1.01278
+8.39,0.37165,-1.03071
+8.395,0.366452,-1.0484
+8.4,0.361167,-1.06586
+8.405,0.355794,-1.08307
+8.41,0.350336,-1.10003
+8.415,0.344794,-1.11673
+8.42,0.33917,-1.13318
+8.425,0.333463,-1.14937
+8.43,0.327676,-1.16529
+8.435,0.321811,-1.18094
+8.44,0.315867,-1.19632
+8.445,0.309848,-1.21141
+8.45,0.303754,-1.22623
+8.455,0.297586,-1.24076
+8.46,0.291347,-1.25499
+8.465,0.285037,-1.26893
+8.47,0.278658,-1.28258
+8.475,0.272211,-1.29592
+8.48,0.265699,-1.30895
+8.485,0.259122,-1.32167
+8.49,0.252483,-1.33408
+8.495,0.245782,-1.34618
+8.5,0.239022,-1.35795
+8.505,0.232203,-1.3694
+8.51,0.225328,-1.38053
+8.515,0.218398,-1.39132
+8.52,0.211415,-1.40178
+8.525,0.204381,-1.4119
+8.53,0.197297,-1.42169
+8.535,0.190165,-1.43113
+8.54,0.182986,-1.44023
+8.545,0.175763,-1.44898
+8.55,0.168497,-1.45738
+8.555,0.16119,-1.46543
+8.56,0.153843,-1.47313
+8.565,0.146459,-1.48047
+8.57,0.139039,-1.48744
+8.575,0.131585,-1.49406
+8.58,0.124099,-1.50031
+8.585,0.116583,-1.5062
+8.59,0.109038,-1.51172
+8.595,0.101466,-1.51688
+8.6,0.0938696,-1.52166
+8.605,0.0862501,-1.52607
+8.61,0.0786095,-1.53011
+8.615,0.0709496,-1.53378
+8.62,0.0632724,-1.53707
+8.625,0.0555796,-1.53998
+8.63,0.0478732,-1.54251
+8.635,0.0401551,-1.54467
+8.64,0.0324271,-1.54645
+8.645,0.0246912,-1.54785
+8.65,0.0169492,-1.54887
+8.655,0.00920308,-1.54952
+8.66,0.00145469,-1.54978
+8.665,-0.00629406,-1.54966
+8.67,-0.0140413,-1.54916
+8.675,-0.021785,-1.54828
+8.68,-0.0295234,-1.54702
+8.685,-0.0372546,-1.54539
+8.69,-0.0449767,-1.54337
+8.695,-0.0526877,-1.54098
+8.7,-0.0603858,-1.5382
+8.705,-0.0680691,-1.53506
+8.71,-0.0757357,-1.53153
+8.715,-0.0833838,-1.52763
+8.72,-0.0910114,-1.52336
+8.725,-0.0986168,-1.51872
+8.73,-0.106198,-1.5137
+8.735,-0.113753,-1.50832
+8.74,-0.121281,-1.50257
+8.745,-0.128778,-1.49645
+8.75,-0.136244,-1.48997
+8.755,-0.143677,-1.48313
+8.76,-0.151075,-1.47593
+8.765,-0.158436,-1.46836
+8.77,-0.165758,-1.46045
+8.775,-0.17304,-1.45218
+8.78,-0.180279,-1.44356
+8.785,-0.187475,-1.43459
+8.79,-0.194625,-1.42528
+8.795,-0.201727,-1.41562
+8.8,-0.20878,-1.40562
+8.805,-0.215783,-1.39529
+8.81,-0.222733,-1.38462
+8.815,-0.229628,-1.37362
+8.82,-0.236468,-1.36229
+8.825,-0.243251,-1.35064
+8.83,-0.249974,-1.33866
+8.835,-0.256637,-1.32637
+8.84,-0.263237,-1.31376
+8.845,-0.269774,-1.30084
+8.85,-0.276245,-1.28762
+8.855,-0.28265,-1.27409
+8.86,-0.288986,-1.26026
+8.865,-0.295252,-1.24613
+8.87,-0.301446,-1.23172
+8.875,-0.307568,-1.21701
+8.88,-0.313616,-1.20202
+8.885,-0.319588,-1.18675
+8.89,-0.325483,-1.1712
+8.895,-0.3313,-1.15538
+8.9,-0.337036,-1.13929
+8.905,-0.342692,-1.12294
+8.91,-0.348265,-1.10633
+8.915,-0.353755,-1.08946
+8.92,-0.35916,-1.07235
+8.925,-0.364478,-1.05498
+8.93,-0.369709,-1.03738
+8.935,-0.374851,-1.01954
+8.94,-0.379904,-1.00146
+8.945,-0.384866,-0.98316
+8.95,-0.389735,-0.964634
+8.955,-0.394512,-0.94589
+8.96,-0.399194,-0.926931
+8.965,-0.403781,-0.907762
+8.97,-0.408271,-0.888389
+8.975,-0.412664,-0.868816
+8.98,-0.416959,-0.849047
+8.985,-0.421154,-0.829089
+8.99,-0.42525,-0.808944
+8.995,-0.429244,-0.788619
+9,-0.433135,-0.768118
+9.005,-0.436924,-0.747446
+9.01,-0.44061,-0.726608
+9.015,-0.44419,-0.705609
+9.02,-0.447665,-0.684454
+9.025,-0.451035,-0.663147
+9.03,-0.454297,-0.641694
+9.035,-0.457451,-0.6201
+9.04,-0.460497,-0.598369
+9.045,-0.463435,-0.576506
+9.05,-0.466262,-0.554517
+9.055,-0.46898,-0.532407
+9.06,-0.471586,-0.51018
+9.065,-0.474081,-0.487842
+9.07,-0.476464,-0.465397
+9.075,-0.478735,-0.442851
+9.08,-0.480893,-0.420208
+9.085,-0.482937,-0.397474
+9.09,-0.484867,-0.374654
+9.095,-0.486683,-0.351752
+9.1,-0.488385,-0.328775
+9.105,-0.489971,-0.305726
+9.11,-0.491442,-0.28261
+9.115,-0.492797,-0.259434
+9.12,-0.494036,-0.236202
+9.125,-0.495159,-0.212918
+9.13,-0.496165,-0.189589
+9.135,-0.497055,-0.166219
+9.14,-0.497827,-0.142813
+9.145,-0.498483,-0.119376
+9.15,-0.499021,-0.0959137
+9.155,-0.499442,-0.0724305
+9.16,-0.499745,-0.0489318
+9.165,-0.499931,-0.0254225
+9.17,-0.5,-0.00190771
+9.175,-0.49995,0.0216075
+9.18,-0.499784,0.045118
+9.185,-0.499499,0.0686188
+9.19,-0.499097,0.0921048
+9.195,-0.498578,0.115571
+9.2,-0.497942,0.139012
+9.205,-0.497188,0.162424
+9.21,-0.496318,0.1858
+9.215,-0.49533,0.209136
+9.22,-0.494226,0.232427
+9.225,-0.493006,0.255668
+9.23,-0.49167,0.278854
+9.235,-0.490218,0.30198
+9.24,-0.48865,0.32504
+9.245,-0.486967,0.348029
+9.25,-0.48517,0.370944
+9.255,-0.483258,0.393777
+9.26,-0.481232,0.416526
+9.265,-0.479093,0.439184
+9.27,-0.47684,0.461746
+9.275,-0.474476,0.484207
+9.28,-0.471999,0.506563
+9.285,-0.46941,0.528808
+9.29,-0.466711,0.550938
+9.295,-0.463901,0.572947
+9.3,-0.460981,0.59483
+9.305,-0.457953,0.616583
+9.31,-0.454816,0.6382
+9.315,-0.451571,0.659676
+9.32,-0.448219,0.681007
+9.325,-0.444761,0.702187
+9.33,-0.441198,0.723212
+9.335,-0.437529,0.744077
+9.34,-0.433757,0.764776
+9.345,-0.429882,0.785305
+9.35,-0.425904,0.805659
+9.355,-0.421826,0.825833
+9.36,-0.417646,0.845822
+9.365,-0.413368,0.865621
+9.37,-0.408991,0.885227
+9.375,-0.404516,0.904633
+9.38,-0.399945,0.923835
+9.385,-0.395278,0.942828
+9.39,-0.390517,0.961608
+9.395,-0.385662,0.98017
+9.4,-0.380715,0.998509
+9.405,-0.375677,1.01662
+9.41,-0.370549,1.0345
+9.415,-0.365333,1.05214
+9.42,-0.360028,1.06955
+9.425,-0.354638,1.0867
+9.43,-0.349162,1.10361
+9.435,-0.343602,1.12026
+9.44,-0.33796,1.13666
+9.445,-0.332236,1.15279
+9.45,-0.326432,1.16865
+9.455,-0.32055,1.18424
+9.46,-0.31459,1.19956
+9.465,-0.308555,1.2146
+9.47,-0.302445,1.22935
+9.475,-0.296262,1.24382
+9.48,-0.290007,1.25799
+9.485,-0.283682,1.27187
+9.49,-0.277289,1.28544
+9.495,-0.270828,1.29872
+9.5,-0.264302,1.31169
+9.505,-0.257712,1.32435
+9.51,-0.251059,1.33669
+9.515,-0.244346,1.34872
+9.52,-0.237573,1.36042
+9.525,-0.230742,1.3718
+9.53,-0.223855,1.38286
+9.535,-0.216914,1.39358
+9.54,-0.20992,1.40397
+9.545,-0.202875,1.41402
+9.55,-0.19578,1.42373
+9.555,-0.188638,1.4331
+9.56,-0.18145,1.44213
+9.565,-0.174217,1.4508
+9.57,-0.166942,1.45913
+9.575,-0.159627,1.4671
+9.58,-0.152272,1.47472
+9.585,-0.14488,1.48198
+9.59,-0.137453,1.48889
+9.595,-0.129992,1.49542
+9.6,-0.122499,1.5016
+9.605,-0.114976,1.50741
+9.61,-0.107426,1.51285
+9.615,-0.0998485,1.51793
+9.62,-0.0922469,1.52263
+9.625,-0.0846228,1.52697
+9.63,-0.0769779,1.53092
+9.635,-0.0693142,1.53451
+9.64,-0.0616334,1.53772
+9.645,-0.0539376,1.54055
+9.65,-0.0462286,1.54301
+9.655,-0.0385082,1.54508
+9.66,-0.0307784,1.54678
+9.665,-0.023041,1.5481
+9.67,-0.015298,1.54904
+9.675,-0.00755119,1.5496
+9.68,0.00019744,1.54978
+9.685,0.00794602,1.54958
+9.69,0.0156926,1.549
+9.695,0.0234354,1.54804
+9.7,0.0311725,1.54671
+9.705,0.0389019,1.54499
+9.71,0.0466217,1.54289
+9.715,0.0543301,1.54042
+9.72,0.0620252,1.53756
+9.725,0.0697051,1.53434
+9.73,0.077368,1.53073
+9.735,0.0850118,1.52675
+9.74,0.0926349,1.5224
+9.745,0.100235,1.51768
+9.75,0.107811,1.51259
+9.755,0.11536,1.50712
+9.76,0.122882,1.50129
+9.765,0.130373,1.4951
+9.77,0.137832,1.48854
+9.775,0.145258,1.48162
+9.78,0.152648,1.47434
+9.785,0.16,1.46671
+9.79,0.167314,1.45871
+9.795,0.174587,1.45037
+9.8,0.181817,1.44168
+9.805,0.189003,1.43263
+9.81,0.196143,1.42325
+9.815,0.203235,1.41352
+9.82,0.210278,1.40345
+9.825,0.217269,1.39304
+9.83,0.224207,1.3823
+9.835,0.231091,1.37123
+9.84,0.237919,1.35983
+9.845,0.244689,1.34811
+9.85,0.2514,1.33607
+9.855,0.258049,1.32371
+9.86,0.264636,1.31103
+9.865,0.271159,1.29805
+9.87,0.277616,1.28476
+9.875,0.284006,1.27117
+9.88,0.290328,1.25727
+9.885,0.296579,1.24308
+9.89,0.302758,1.22861
+9.895,0.308864,1.21384
+9.9,0.314896,1.19879
+9.905,0.320852,1.18346
+9.91,0.32673,1.16785
+9.915,0.33253,1.15197
+9.92,0.338249,1.13583
+9.925,0.343887,1.11942
+9.93,0.349443,1.10275
+9.935,0.354915,1.08583
+9.94,0.360301,1.06867
+9.945,0.365601,1.05125
+9.95,0.370813,1.0336
+9.955,0.375936,1.0157
+9.96,0.38097,0.99758
+9.965,0.385912,0.979229
+9.97,0.390762,0.960656
+9.975,0.395518,0.941865
+9.98,0.40018,0.922861
+9.985,0.404746,0.903649
+9.99,0.409216,0.884232
+9.995,0.413588,0.864617
+10,0.417862,0.844808
diff --git a/src/.ipynb_checkpoints/explicit_rk-checkpoint.hpp b/src/.ipynb_checkpoints/explicit_rk-checkpoint.hpp
new file mode 100644
index 000000000..4ff25ede7
--- /dev/null
+++ b/src/.ipynb_checkpoints/explicit_rk-checkpoint.hpp
@@ -0,0 +1,50 @@
+// src/explicit_rk.hpp
+#pragma once
+#include <vector>
+#include <functional>
+#include <cassert>
+#include <cmath>
+
+// An explicit Runge-Kutta integrator for autonomous ODE y' = f(t,y) or f(y).
+// f: (double t, const std::vector<double>& y, std::vector<double>& out)
+class ExplicitRungeKutta {
+public:
+    ExplicitRungeKutta(const std::vector<std::vector<double>>& a_,
+                       const std::vector<double>& b_,
+                       const std::vector<double>& c_)
+      : a(a_), b(b_), c(c_), s((int)b_.size()) {
+        assert((int)c_.size() == s);
+        assert((int)a.size() == s);
+    }
+
+    void step(const std::function<void(double,const std::vector<double>&,std::vector<double>&)>& f,
+              double t, double tau,
+              const std::vector<double>& y, std::vector<double>& out) const
+    {
+        int n = (int)y.size();
+        out.assign(n, 0.0);
+        std::vector<std::vector<double>> k(s, std::vector<double>(n, 0.0));
+        std::vector<double> ytemp(n,0.0);
+        for (int j=0;j<s;++j) {
+            for (int i=0;i<n;++i) {
+                double sum = 0.0;
+                for (int l=0;l<j;++l) sum += a[j][l] * k[l][i];
+                ytemp[i] = y[i] + tau * sum;
+            }
+            f(t + c[j]*tau, ytemp, k[j]);
+        }
+        for (int i=0;i<n;++i) {
+            double sum = 0.0;
+            for (int j=0;j<s;++j) sum += b[j] * k[j][i];
+            out[i] = y[i] + tau * sum;
+        }
+    }
+
+    int stages() const { return s; }
+
+private:
+    std::vector<std::vector<double>> a;
+    std::vector<double> b;
+    std::vector<double> c;
+    int s;
+};

From 46abbf6bb9c21414c7ffb3cf7d23f3f1aa0035ab Mon Sep 17 00:00:00 2001
From: Farooq Mian Azan <e12433773@student.tuwien.ac.at>
Date: Sun, 30 Nov 2025 21:00:28 +0000
Subject: [PATCH 17/20] Add README and finalize test_ode + updated steppers

---
 README.md                 |  36 ++++++++++--
 demos/test_ode.cpp        |   8 ++-
 include/ExplicitEuler.hpp |   2 +-
 include/timestepper.hpp   | 118 +-------------------------------------
 src/matrix.hpp            |  14 ++++-
 src/nonlinfunc.hpp        |  21 ++++++-
 src/timestepper.hpp       |   4 +-
 src/vector.hpp            |  17 +++++-
 8 files changed, 93 insertions(+), 127 deletions(-)

diff --git a/README.md b/README.md
index 9572d8104..77ae08931 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,35 @@
-# ASC-ODE
-A package for solving ordinary differential equations
+# ASC-ODE — Quick Build & Run Guide
 
-Read the [documentation](https://tuwien-asc.github.io/ASC-ODE/intro.html)
+This repository contains ODE solvers and demos for the ASC course, including explicit/implicit Euler, Runge–Kutta, and automatic differentiation examples.
 
-Find theory behind here: https://jschoeberl.github.io/IntroSC/ODEs/ODEs.html
+## Requirements
+- g++ with C++20 support  
+- No external libraries needed (nanoblas included)
 
+## Build & Run
+
+### 1. Mass–Spring ODE (Explicit Euler)
+```bash
+g++ -std=c++20 -O2 -I. -Isrc -Iinclude -Inanoblas/src \
+    demos/test_ode.cpp -o build/demos/test_ode
+./build/demos/test_ode
+2. Runge–Kutta Demo
+bash
+Copy code
+
+g++ -std=c++20 -O2 -I. -Isrc -Iinclude -Inanoblas/src \
+    demos/demo_rk.cpp -o build/demos/demo_rk
+./build/demos/demo_rk
+3. Automatic Differentiation Demo
+bash
+Copy code
+
+g++ -std=c++20 -O2 -I. -Isrc -Iinclude -Inanoblas/src \
+    demos/demo_autodiff.cpp -o build/demos/demo_autodiff
+./build/demos/demo_autodiff
+Notes
+Some demos write output files such as .txt or .csv.
+
+All demos share the same headers in src/ and include/.
+
+Compilation with -O2 is recommended.
diff --git a/demos/test_ode.cpp b/demos/test_ode.cpp
index 97f635e40..01fa20ce6 100644
--- a/demos/test_ode.cpp
+++ b/demos/test_ode.cpp
@@ -1,10 +1,12 @@
 #include <iostream>
-#include <fstream> 
+#include <fstream>
+#include <memory> 
 
 #include <nonlinfunc.hpp>
 #include <timestepper.hpp>
+#include "ExplicitEuler.hpp"
+
 
-using namespace ASC_ode;
 
 
 class MassSpring : public NonlinearFunction
@@ -52,7 +54,7 @@ int main()
 
   for (int i = 0; i < steps; i++)
   {
-     stepper.DoStep(tau, y);
+     stepper.doStep(tau, y);
 
      std::cout << (i+1) * tau << "  " << y(0) << " " << y(1) << std::endl;
      outfile << (i+1) * tau << "  " << y(0) << " " << y(1) << std::endl;
diff --git a/include/ExplicitEuler.hpp b/include/ExplicitEuler.hpp
index 326c3a2da..e6f24b7d3 100644
--- a/include/ExplicitEuler.hpp
+++ b/include/ExplicitEuler.hpp
@@ -9,7 +9,7 @@ class ExplicitEuler : public TimeStepper {
         : TimeStepper(rhs) {}
 
     void doStep(double tau, VectorView<double> y) override {
-        Vector<> k1; 
+        Vector<> k1(y.size());
         m_rhs->evaluate(y, k1); // Evaluate f(y)
         y += tau * k1;          // Update y
     }
diff --git a/include/timestepper.hpp b/include/timestepper.hpp
index d67a282e3..69157f81f 100644
--- a/include/timestepper.hpp
+++ b/include/timestepper.hpp
@@ -5,13 +5,10 @@
 #include <iostream>
 #include <cmath>
 
-// forward declarations from repo's linear algebra
-// Replace these with the repo's real Vector / Matrix types.
-// Here I show pseudo-types to be adapted to the project's actual types.
-#include "nonlinear_function.hpp" // assume this exists in repo (NonlinearFunction)
-
-// The repo uses Vector<> and VectorView<> types; adapt includes if necessary.
+// include the project's canonical NonlinearFunction and Vector types
+#include "../src/nonlinfunc.hpp"
 
+// Base TimeStepper used by the steppers in include/
 class TimeStepper
 {
 protected:
@@ -21,112 +18,3 @@ class TimeStepper
   virtual ~TimeStepper() = default;
   virtual void doStep(double tau, VectorView<double> y) = 0;
 };
-
-/// ExplicitEuler is likely already implemented in the repo; shown for reference
-class ExplicitEuler : public TimeStepper
-{
-  Vector<> m_vecf;
-public:
-  ExplicitEuler(std::shared_ptr<NonlinearFunction> rhs)
-    : TimeStepper(rhs), m_vecf(rhs->dimF()) {}
-
-  void doStep(double tau, VectorView<double> y) override
-  {
-    this->m_rhs->evaluate(y, m_vecf);
-    y += tau * m_vecf;
-  }
-};
-
-/// Improved Euler (Heun / explicit midpoint-like two-stage as defined in exercise)
-/// \tilde y = y_n + tau/2 * f(y_n)
-/// y_{n+1} = y_n + tau * f( \tilde y )
-class ImprovedEuler : public TimeStepper
-{
-  Vector<> m_vecf;     // f(y)
-  Vector<> m_vecft;    // f(tilde y)
-  Vector<> m_ytemp;    // temporary vector for tilde y
-public:
-  ImprovedEuler(std::shared_ptr<NonlinearFunction> rhs)
-    : TimeStepper(rhs),
-      m_vecf(rhs->dimF()),
-      m_vecft(rhs->dimF()),
-      m_ytemp(rhs->dimX()) {}
-
-  void doStep(double tau, VectorView<double> y) override
-  {
-    // evaluate f(y)
-    this->m_rhs->evaluate(y, m_vecf);
-
-    // tilde y = y + tau/2 * f(y)
-    m_ytemp = y;               // copy current y to temp
-    m_ytemp += (tau/2.0) * m_vecf;
-
-    // evaluate f(tilde y)
-    this->m_rhs->evaluate(m_ytemp, m_vecft);
-
-    // y_{n+1} = y_n + tau * f(tilde y)
-    y += tau * m_vecft;
-  }
-};
-
-/// CrankNicolson (semi-implicit): we implement a Picard (fixed-point) iteration:
-/// y^{k+1} = y_old + 0.5*tau*( f(y_old) + f(y^k) )
-/// start from predictor (Improved Euler or Explicit Euler)
-class CrankNicolson : public TimeStepper
-{
-  Vector<> m_fold;     // f(y_old)
-  Vector<> m_fk;       // f(y_k)
-  Vector<> m_yk;       // current iterate y^k
-  int m_max_iter;
-  double m_tol;
-public:
-  CrankNicolson(std::shared_ptr<NonlinearFunction> rhs,
-                int max_iter = 20, double tol = 1e-10)
-    : TimeStepper(rhs),
-      m_fold(rhs->dimF()),
-      m_fk(rhs->dimF()),
-      m_yk(rhs->dimX()),
-      m_max_iter(max_iter),
-      m_tol(tol) {}
-
-  void doStep(double tau, VectorView<double> y) override
-  {
-    // store old
-    Vector<> yold = y; // copy (Vector supports copy)
-
-    // evaluate f(yold)
-    this->m_rhs->evaluate(yold, m_fold);
-
-    // predictor: one ImprovedEuler step -> starting guess
-    // yk = yold + tau * f(yold)  (explicit Euler predictor)
-    m_yk = yold;
-    m_yk += tau * m_fold;
-
-    // Picard iteration (fixed-point)
-    for (int iter = 0; iter < m_max_iter; ++iter)
-    {
-      // evaluate f(y_k)
-      this->m_rhs->evaluate(m_yk, m_fk);
-
-      // compute new iterate
-      Vector<> ynew = yold;
-      ynew += 0.5 * tau * (m_fold + m_fk);
-
-      // check convergence (norm of difference)
-      double diffnorm = 0.0;
-      for (size_t i = 0; i < ynew.size(); ++i)
-      {
-        double d = ynew[i] - m_yk[i];
-        diffnorm += d*d;
-      }
-      diffnorm = std::sqrt(diffnorm);
-
-      m_yk = ynew;
-
-      if (diffnorm < m_tol) break;
-    }
-
-    // copy result back to y (view)
-    y = m_yk;
-  }
-};
diff --git a/src/matrix.hpp b/src/matrix.hpp
index 1becba2bb..fcfb71eba 100644
--- a/src/matrix.hpp
+++ b/src/matrix.hpp
@@ -1 +1,13 @@
-404: Not Found
\ No newline at end of file
+#pragma once
+// Lightweight wrapper typedefs that expose nanoblas matrix types in ASC_ode.
+#include "../nanoblas/src/matrix.hpp"
+
+namespace ASC_ode {
+
+template<typename T = double>
+using Matrix = nanoblas::Matrix<T>;
+
+template<typename T = double>
+using MatrixView = nanoblas::MatrixView<T>;
+
+} // namespace ASC_ode
diff --git a/src/nonlinfunc.hpp b/src/nonlinfunc.hpp
index 1becba2bb..8d215e7ab 100644
--- a/src/nonlinfunc.hpp
+++ b/src/nonlinfunc.hpp
@@ -1 +1,20 @@
-404: Not Found
\ No newline at end of file
+#pragma once
+// NonlinearFunction interface using the canonical global Vector/VectorView.
+#include "vector.hpp"   // provides Vector, VectorView, MatrixView
+
+class NonlinearFunction
+{
+public:
+    virtual ~NonlinearFunction() = default;
+
+    // dimension of input
+    virtual std::size_t dimX() const = 0;
+    // dimension of output
+    virtual std::size_t dimF() const = 0;
+
+    // evaluate f(x)
+    virtual void evaluate(VectorView<double> x, VectorView<double> f) const = 0;
+
+    // evaluate derivative df/dx
+    virtual void evaluateDeriv(VectorView<double> x, MatrixView<double> df) const = 0;
+};
diff --git a/src/timestepper.hpp b/src/timestepper.hpp
index 1becba2bb..4daf88256 100644
--- a/src/timestepper.hpp
+++ b/src/timestepper.hpp
@@ -1 +1,3 @@
-404: Not Found
\ No newline at end of file
+#pragma once
+// Forwarding shim to the canonical timestepper header in include/
+#include "../include/timestepper.hpp"
diff --git a/src/vector.hpp b/src/vector.hpp
index 1becba2bb..840a0acb6 100644
--- a/src/vector.hpp
+++ b/src/vector.hpp
@@ -1 +1,16 @@
-404: Not Found
\ No newline at end of file
+#pragma once
+// Single canonical global aliases for the project's linear algebra types.
+#include "../nanoblas/src/vector.hpp"
+#include "../nanoblas/src/matrix.hpp"
+
+template<typename T = double>
+using Vector = nanoblas::Vector<T>;
+
+template<typename T = double>
+using VectorView = nanoblas::VectorView<T>;
+
+template<typename T = double>
+using Matrix = nanoblas::Matrix<T>;
+
+template<typename T = double>
+using MatrixView = nanoblas::MatrixView<T>;

From 62f18e0114da45539540e6fdfad2b3851984f61a Mon Sep 17 00:00:00 2001
From: Joachim Schoeberl <joachim.schoeberl@tuwien.ac.at>
Date: Wed, 3 Dec 2025 07:11:03 +0100
Subject: [PATCH 18/20] doStep

---
 demos/test_ode.cpp | 6 +++---
 src/implicitRK.hpp | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/demos/test_ode.cpp b/demos/test_ode.cpp
index 8a4405141..df7e04f50 100644
--- a/demos/test_ode.cpp
+++ b/demos/test_ode.cpp
@@ -61,7 +61,7 @@ int main()
   // RungeKutta stepper(rhs, Gauss2a, Gauss2b, Gauss2c);
 
   // Gauss3c .. points tabulated, compute a,b:
-  auto [Gauss3a,Gauss3b] = ComputeABfromC (Gauss3c);
+  auto [Gauss3a,Gauss3b] = computeABfromC (Gauss3c);
   ImplicitRungeKutta stepper(rhs, Gauss3a, Gauss3b, Gauss3c);
 
 
@@ -71,7 +71,7 @@ int main()
   Vector<> c(stages), b1(stages);
   GaussLegendre(c, b1);
 
-  auto [a, b] = ComputeABfromC(c);
+  auto [a, b] = computeABfromC(c);
   ImplicitRungeKutta stepper(rhs, a, b, c);
   */
 
@@ -81,7 +81,7 @@ int main()
   Vector<> c(stages), b1(stages);
   GaussRadau(c, b1);
 
-  auto [a, b] = ComputeABfromC(c);
+  auto [a, b] = computeABfromC(c);
   ImplicitRungeKutta stepper(rhs, a, b, c);
   */
 
diff --git a/src/implicitRK.hpp b/src/implicitRK.hpp
index e7434b334..2caa88ce3 100644
--- a/src/implicitRK.hpp
+++ b/src/implicitRK.hpp
@@ -33,7 +33,7 @@ namespace ASC_ode {
       m_equ = knew - Compose(multiple_rhs, m_yold+m_tau*std::make_shared<MatVecFunc>(a, m_n));
     }
 
-    void DoStep(double tau, VectorView<double> y) override
+    void doStep(double tau, VectorView<double> y) override
     {
       for (int j = 0; j < m_stages; j++)
         m_y.range(j*m_n, (j+1)*m_n) = y;
@@ -178,7 +178,7 @@ void GaussJacobi (VectorView<> x, VectorView<> w, const double alf, const double
 /*
   given Runge-Kutta nodes c, compute the coefficients a and b
 */
-auto ComputeABfromC (const Vector<> & c)
+auto computeABfromC (const Vector<> & c)
 {
   int s = c.size();
   Matrix<> M(s, s);

From 443e6b2223373083c06532b3de9c03949d59bb54 Mon Sep 17 00:00:00 2001
From: Farooq Mian Azan <e12433773@student.tuwien.ac.at>
Date: Fri, 5 Dec 2025 10:48:37 +0000
Subject: [PATCH 19/20] Merge upstream/Newmark: resolved conflicts and added
 bindings.cpp stub

---
 src/bindings.cpp | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 src/bindings.cpp

diff --git a/src/bindings.cpp b/src/bindings.cpp
new file mode 100644
index 000000000..42c99e9c5
--- /dev/null
+++ b/src/bindings.cpp
@@ -0,0 +1,7 @@
+#include <pybind11/pybind11.h>
+namespace py = pybind11;
+
+PYBIND11_MODULE(asc_ode, m) {
+    m.doc() = "tiny asc_ode stub bindings to satisfy CMake configure";
+    // no bindings required for the C++ demos; this is only a placeholder
+}

From afb130d2abded26b199cf12ef6cb9dcb63eded71 Mon Sep 17 00:00:00 2001
From: Farooq Mian Azan <e12433773@student.tuwien.ac.at>
Date: Mon, 8 Dec 2025 20:51:06 +0000
Subject: [PATCH 20/20] =?UTF-8?q?Exercise=2020=20complete=20=E2=80=94=20co?=
 =?UTF-8?q?nstrained=20mass=E2=80=93spring=20system=20with=20exact=20Jacob?=
 =?UTF-8?q?ian?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .ipynb_checkpoints/CMakeLists-checkpoint.txt  |   31 +
 CMakeLists.txt                                |   31 +
 CrankNicolson.hpp                             |   23 +
 ImplicitEuler.hpp                             |   19 +
 ImprovedEuler.hpp                             |   14 +
 LICENSE                                       |   21 +
 README.md                                     |    7 +
 build/CMakeCache.txt                          |  378 +
 .../CMakeFiles/3.29.4/CMakeCXXCompiler.cmake  |   92 +
 .../3.29.4/CMakeDetermineCompilerABI_CXX.bin  |  Bin 0 -> 15440 bytes
 build/CMakeFiles/3.29.4/CMakeSystem.cmake     |   15 +
 .../CompilerIdCXX/CMakeCXXCompilerId.cpp      |  878 ++
 build/CMakeFiles/3.29.4/CompilerIdCXX/a.out   |  Bin 0 -> 15552 bytes
 build/CMakeFiles/CMakeConfigureLog.yaml       |  274 +
 build/CMakeFiles/cmake.check_cache            |    1 +
 .../compare_all-checkpoint.cpp                |   68 +
 .../test_ode-checkpoint.cpp                   |   72 +
 demos/compare_all.cpp                         |   68 +
 demos/test_ode.cpp                            |   72 +
 docs/ASC_Logo_transparent_300ppi_RGB.png      |  Bin 0 -> 82368 bytes
 docs/_config.yml                              |   57 +
 docs/_toc.yml                                 |   11 +
 docs/intro.md                                 |   66 +
 docs/pictures/massspring_phase.png            |  Bin 0 -> 41937 bytes
 .../CMakeLists-checkpoint.txt                 |   15 +
 .../.ipynb_checkpoints/ReadME-checkpoint.md   |   12 +
 .../demo_mass_spring-checkpoint.cpp           |   66 +
 .../linear_solve-checkpoint.hpp               |   49 +
 .../mass_spring-checkpoint.hpp                |  230 +
 .../.ipynb_checkpoints/matrix-checkpoint.hpp  |   26 +
 .../mss_function-checkpoint.cpp               |  212 +
 .../mss_function-checkpoint.hpp               |   18 +
 .../.ipynb_checkpoints/vector-checkpoint.hpp  |   28 +
 ex20_solution/CMakeLists.txt                  |   17 +
 ex20_solution/ReadME.md                       |   12 +
 ex20_solution/build/CMakeCache.txt            |  339 +
 .../CMakeFiles/3.29.4/CMakeCXXCompiler.cmake  |   92 +
 .../3.29.4/CMakeDetermineCompilerABI_CXX.bin  |  Bin 0 -> 15992 bytes
 .../build/CMakeFiles/3.29.4/CMakeSystem.cmake |   15 +
 .../CompilerIdCXX/CMakeCXXCompilerId.cpp      |  878 ++
 .../CMakeFiles/3.29.4/CompilerIdCXX/a.out     |  Bin 0 -> 16096 bytes
 .../build/CMakeFiles/CMakeConfigureLog.yaml   |  295 +
 .../CMakeDirectoryInformation.cmake           |   16 +
 ex20_solution/build/CMakeFiles/Makefile.cmake |  107 +
 ex20_solution/build/CMakeFiles/Makefile2      |  112 +
 .../build/CMakeFiles/TargetDirectories.txt    |    3 +
 .../build/CMakeFiles/cmake.check_cache        |    1 +
 .../demo_mass_spring.dir/DependInfo.cmake     |   25 +
 .../demo_mass_spring.dir/build.make           |  142 +
 .../demo_mass_spring.dir/cmake_clean.cmake    |   15 +
 .../demo_mass_spring.dir/compiler_depend.make |    2 +
 .../demo_mass_spring.dir/compiler_depend.ts   |    2 +
 .../demo_mass_spring.cpp.o                    |  Bin 0 -> 133992 bytes
 .../demo_mass_spring.cpp.o.d                  |  204 +
 .../demo_mass_spring.dir/depend.make          |    2 +
 .../demo_mass_spring.dir/flags.make           |   10 +
 .../CMakeFiles/demo_mass_spring.dir/link.txt  |    1 +
 .../demo_mass_spring.dir/mass_spring.cpp.o    |  Bin 0 -> 944 bytes
 .../demo_mass_spring.dir/mass_spring.cpp.o.d  |    3 +
 .../demo_mass_spring.dir/mss_function.cpp.o   |  Bin 0 -> 122216 bytes
 .../demo_mass_spring.dir/mss_function.cpp.o.d |  210 +
 .../demo_mass_spring.dir/progress.make        |    5 +
 ex20_solution/build/CMakeFiles/progress.marks |    1 +
 ex20_solution/build/Makefile                  |  235 +
 ex20_solution/build/cmake_install.cmake       |   54 +
 ex20_solution/build/demo_mass_spring          |  Bin 0 -> 88416 bytes
 ex20_solution/build/mass_spring_output.txt    |  402 +
 ex20_solution/demo_mass_spring.cpp            |   66 +
 ex20_solution/linear_solve.hpp                |   49 +
 ex20_solution/mass_spring.cpp                 |    0
 ex20_solution/mass_spring.hpp                 |  230 +
 ex20_solution/matrix.hpp                      |   26 +
 ex20_solution/mss_function.cpp                |  212 +
 ex20_solution/mss_function.hpp                |   18 +
 ex20_solution/vector.hpp                      |   28 +
 .../ExplicitEuler-checkpoint.hpp              |   16 +
 .../ImprovedEuler-checkpoint.hpp              |   14 +
 .../mass_spring-checkpoint.hpp                |   29 +
 .../plot_mass_spring-checkpoint.py            |   47 +
 .../timestepper-checkpoint.hpp                |  132 +
 include/CrankNicolson.hpp                     |   23 +
 include/ExplicitEuler.hpp                     |   16 +
 include/ImplicitEuler.hpp                     |   19 +
 include/ImprovedEuler.hpp                     |   14 +
 include/mass_spring.hpp                       |   29 +
 include/plot_mass_spring.py                   |   47 +
 include/timestepper.hpp                       |  132 +
 nanoblas/.gitignore                           |    9 +
 nanoblas/CMakeLists.txt                       |   67 +
 nanoblas/LICENSE                              |   21 +
 nanoblas/README.md                            |   12 +
 nanoblas/demos/CMakeLists.txt                 |   25 +
 nanoblas/demos/demo_lapack.cpp                |   41 +
 nanoblas/demos/demo_matrix.cpp                |   45 +
 nanoblas/demos/demo_vector.cpp                |   33 +
 .../docs/ASC_Logo_transparent_300ppi_RGB.png  |  Bin 0 -> 82368 bytes
 nanoblas/docs/_config.yml                     |   60 +
 nanoblas/docs/_toc.yml                        |   11 +
 nanoblas/docs/intro.md                        |   73 +
 nanoblas/nanoblas/__init__.py                 |    1 +
 nanoblas/pyproject.toml                       |   11 +
 nanoblas/setup.py                             |   17 +
 nanoblas/src/CMakeLists.txt                   |   18 +
 nanoblas/src/bind_bla.cpp                     |   72 +
 nanoblas/src/clapack.h                        | 7254 +++++++++++++++++
 nanoblas/src/inverse.hpp                      |   86 +
 nanoblas/src/lapack_interface.hpp             |  218 +
 nanoblas/src/matexpr.hpp                      |  170 +
 nanoblas/src/matrix.hpp                       |  205 +
 nanoblas/src/vecexpr.hpp                      |  192 +
 nanoblas/src/vector.hpp                       |  251 +
 solution.tar.gz                               |    0
 .../CMakeLists-checkpoint.txt                 |    3 +
 .../CrankNicolson-checkpoint.hpp              |   34 +
 .../ImplicitEuler-checkpoint.hpp              |   27 +
 .../ImprovedEuler-checkpoint.hpp              |   21 +
 src/.ipynb_checkpoints/Newton-checkpoint.hpp  |   52 +
 .../bindings-checkpoint.cpp                   |   41 +
 .../function_algebra-checkpoint.hpp           |    9 +
 src/.ipynb_checkpoints/main-checkpoint.cpp    |   40 +
 .../mass_spring_function-checkpoint.hpp       |   39 +
 src/.ipynb_checkpoints/matrix-checkpoint.hpp  |    0
 .../myfunction-checkpoint.hpp                 |   23 +
 src/.ipynb_checkpoints/newton-checkpoint.hpp  |   41 +
 .../timestepper-checkpoint.cpp                |   79 +
 .../timestepper-checkpoint.hpp                |   39 +
 src/.ipynb_checkpoints/vector-checkpoint.hpp  |    0
 src/CMakeLists.txt                            |    3 +
 src/compare_all                               |  Bin 0 -> 2212134 bytes
 src/function_algebra.hpp                      |    1 +
 src/mass_spring_function.hpp                  |    1 +
 src/matrix.hpp                                |    1 +
 src/newton.hpp                                |   41 +
 src/nonlinfunc.hpp                            |    1 +
 src/timestepper.hpp                           |    1 +
 src/vector.hpp                                |    1 +
 untitled.txt                                  |    0
 137 files changed, 16591 insertions(+)
 create mode 100644 .ipynb_checkpoints/CMakeLists-checkpoint.txt
 create mode 100644 CMakeLists.txt
 create mode 100644 CrankNicolson.hpp
 create mode 100644 ImplicitEuler.hpp
 create mode 100644 ImprovedEuler.hpp
 create mode 100644 LICENSE
 create mode 100644 README.md
 create mode 100644 build/CMakeCache.txt
 create mode 100644 build/CMakeFiles/3.29.4/CMakeCXXCompiler.cmake
 create mode 100755 build/CMakeFiles/3.29.4/CMakeDetermineCompilerABI_CXX.bin
 create mode 100644 build/CMakeFiles/3.29.4/CMakeSystem.cmake
 create mode 100644 build/CMakeFiles/3.29.4/CompilerIdCXX/CMakeCXXCompilerId.cpp
 create mode 100755 build/CMakeFiles/3.29.4/CompilerIdCXX/a.out
 create mode 100644 build/CMakeFiles/CMakeConfigureLog.yaml
 create mode 100644 build/CMakeFiles/cmake.check_cache
 create mode 100644 demos/.ipynb_checkpoints/compare_all-checkpoint.cpp
 create mode 100644 demos/.ipynb_checkpoints/test_ode-checkpoint.cpp
 create mode 100644 demos/compare_all.cpp
 create mode 100644 demos/test_ode.cpp
 create mode 100644 docs/ASC_Logo_transparent_300ppi_RGB.png
 create mode 100644 docs/_config.yml
 create mode 100644 docs/_toc.yml
 create mode 100644 docs/intro.md
 create mode 100644 docs/pictures/massspring_phase.png
 create mode 100644 ex20_solution/.ipynb_checkpoints/CMakeLists-checkpoint.txt
 create mode 100644 ex20_solution/.ipynb_checkpoints/ReadME-checkpoint.md
 create mode 100644 ex20_solution/.ipynb_checkpoints/demo_mass_spring-checkpoint.cpp
 create mode 100644 ex20_solution/.ipynb_checkpoints/linear_solve-checkpoint.hpp
 create mode 100644 ex20_solution/.ipynb_checkpoints/mass_spring-checkpoint.hpp
 create mode 100644 ex20_solution/.ipynb_checkpoints/matrix-checkpoint.hpp
 create mode 100644 ex20_solution/.ipynb_checkpoints/mss_function-checkpoint.cpp
 create mode 100644 ex20_solution/.ipynb_checkpoints/mss_function-checkpoint.hpp
 create mode 100644 ex20_solution/.ipynb_checkpoints/vector-checkpoint.hpp
 create mode 100644 ex20_solution/CMakeLists.txt
 create mode 100644 ex20_solution/ReadME.md
 create mode 100644 ex20_solution/build/CMakeCache.txt
 create mode 100644 ex20_solution/build/CMakeFiles/3.29.4/CMakeCXXCompiler.cmake
 create mode 100755 ex20_solution/build/CMakeFiles/3.29.4/CMakeDetermineCompilerABI_CXX.bin
 create mode 100644 ex20_solution/build/CMakeFiles/3.29.4/CMakeSystem.cmake
 create mode 100644 ex20_solution/build/CMakeFiles/3.29.4/CompilerIdCXX/CMakeCXXCompilerId.cpp
 create mode 100755 ex20_solution/build/CMakeFiles/3.29.4/CompilerIdCXX/a.out
 create mode 100644 ex20_solution/build/CMakeFiles/CMakeConfigureLog.yaml
 create mode 100644 ex20_solution/build/CMakeFiles/CMakeDirectoryInformation.cmake
 create mode 100644 ex20_solution/build/CMakeFiles/Makefile.cmake
 create mode 100644 ex20_solution/build/CMakeFiles/Makefile2
 create mode 100644 ex20_solution/build/CMakeFiles/TargetDirectories.txt
 create mode 100644 ex20_solution/build/CMakeFiles/cmake.check_cache
 create mode 100644 ex20_solution/build/CMakeFiles/demo_mass_spring.dir/DependInfo.cmake
 create mode 100644 ex20_solution/build/CMakeFiles/demo_mass_spring.dir/build.make
 create mode 100644 ex20_solution/build/CMakeFiles/demo_mass_spring.dir/cmake_clean.cmake
 create mode 100644 ex20_solution/build/CMakeFiles/demo_mass_spring.dir/compiler_depend.make
 create mode 100644 ex20_solution/build/CMakeFiles/demo_mass_spring.dir/compiler_depend.ts
 create mode 100644 ex20_solution/build/CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o
 create mode 100644 ex20_solution/build/CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o.d
 create mode 100644 ex20_solution/build/CMakeFiles/demo_mass_spring.dir/depend.make
 create mode 100644 ex20_solution/build/CMakeFiles/demo_mass_spring.dir/flags.make
 create mode 100644 ex20_solution/build/CMakeFiles/demo_mass_spring.dir/link.txt
 create mode 100644 ex20_solution/build/CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o
 create mode 100644 ex20_solution/build/CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o.d
 create mode 100644 ex20_solution/build/CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o
 create mode 100644 ex20_solution/build/CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o.d
 create mode 100644 ex20_solution/build/CMakeFiles/demo_mass_spring.dir/progress.make
 create mode 100644 ex20_solution/build/CMakeFiles/progress.marks
 create mode 100644 ex20_solution/build/Makefile
 create mode 100644 ex20_solution/build/cmake_install.cmake
 create mode 100755 ex20_solution/build/demo_mass_spring
 create mode 100644 ex20_solution/build/mass_spring_output.txt
 create mode 100644 ex20_solution/demo_mass_spring.cpp
 create mode 100644 ex20_solution/linear_solve.hpp
 create mode 100644 ex20_solution/mass_spring.cpp
 create mode 100644 ex20_solution/mass_spring.hpp
 create mode 100644 ex20_solution/matrix.hpp
 create mode 100644 ex20_solution/mss_function.cpp
 create mode 100644 ex20_solution/mss_function.hpp
 create mode 100644 ex20_solution/vector.hpp
 create mode 100644 include/.ipynb_checkpoints/ExplicitEuler-checkpoint.hpp
 create mode 100644 include/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp
 create mode 100644 include/.ipynb_checkpoints/mass_spring-checkpoint.hpp
 create mode 100644 include/.ipynb_checkpoints/plot_mass_spring-checkpoint.py
 create mode 100644 include/.ipynb_checkpoints/timestepper-checkpoint.hpp
 create mode 100644 include/CrankNicolson.hpp
 create mode 100644 include/ExplicitEuler.hpp
 create mode 100644 include/ImplicitEuler.hpp
 create mode 100644 include/ImprovedEuler.hpp
 create mode 100644 include/mass_spring.hpp
 create mode 100644 include/plot_mass_spring.py
 create mode 100644 include/timestepper.hpp
 create mode 100644 nanoblas/.gitignore
 create mode 100644 nanoblas/CMakeLists.txt
 create mode 100644 nanoblas/LICENSE
 create mode 100644 nanoblas/README.md
 create mode 100644 nanoblas/demos/CMakeLists.txt
 create mode 100644 nanoblas/demos/demo_lapack.cpp
 create mode 100644 nanoblas/demos/demo_matrix.cpp
 create mode 100644 nanoblas/demos/demo_vector.cpp
 create mode 100644 nanoblas/docs/ASC_Logo_transparent_300ppi_RGB.png
 create mode 100644 nanoblas/docs/_config.yml
 create mode 100644 nanoblas/docs/_toc.yml
 create mode 100644 nanoblas/docs/intro.md
 create mode 100644 nanoblas/nanoblas/__init__.py
 create mode 100644 nanoblas/pyproject.toml
 create mode 100644 nanoblas/setup.py
 create mode 100644 nanoblas/src/CMakeLists.txt
 create mode 100644 nanoblas/src/bind_bla.cpp
 create mode 100644 nanoblas/src/clapack.h
 create mode 100644 nanoblas/src/inverse.hpp
 create mode 100644 nanoblas/src/lapack_interface.hpp
 create mode 100644 nanoblas/src/matexpr.hpp
 create mode 100644 nanoblas/src/matrix.hpp
 create mode 100644 nanoblas/src/vecexpr.hpp
 create mode 100644 nanoblas/src/vector.hpp
 create mode 100644 solution.tar.gz
 create mode 100644 src/.ipynb_checkpoints/CMakeLists-checkpoint.txt
 create mode 100644 src/.ipynb_checkpoints/CrankNicolson-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/ImplicitEuler-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/Newton-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/bindings-checkpoint.cpp
 create mode 100644 src/.ipynb_checkpoints/function_algebra-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/main-checkpoint.cpp
 create mode 100644 src/.ipynb_checkpoints/mass_spring_function-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/matrix-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/myfunction-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/newton-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/timestepper-checkpoint.cpp
 create mode 100644 src/.ipynb_checkpoints/timestepper-checkpoint.hpp
 create mode 100644 src/.ipynb_checkpoints/vector-checkpoint.hpp
 create mode 100644 src/CMakeLists.txt
 create mode 100644 src/compare_all
 create mode 100644 src/function_algebra.hpp
 create mode 100644 src/mass_spring_function.hpp
 create mode 100644 src/matrix.hpp
 create mode 100644 src/newton.hpp
 create mode 100644 src/nonlinfunc.hpp
 create mode 100644 src/timestepper.hpp
 create mode 100644 src/vector.hpp
 create mode 100644 untitled.txt

diff --git a/.ipynb_checkpoints/CMakeLists-checkpoint.txt b/.ipynb_checkpoints/CMakeLists-checkpoint.txt
new file mode 100644
index 000000000..17abf0e86
--- /dev/null
+++ b/.ipynb_checkpoints/CMakeLists-checkpoint.txt
@@ -0,0 +1,31 @@
+cmake_minimum_required(VERSION 3.20)
+project(ASC_ode LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+include_directories(src nanoblas/src)
+add_subdirectory(nanoblas)
+
+add_executable(test_ode demos/test_ode.cpp)
+target_link_libraries(test_ode PUBLIC nanoblas)
+
+add_executable(demo_autodiff demos/demo_autodiff.cpp)
+target_link_libraries(demo_autodiff PUBLIC nanoblas)
+
+# Python bindings
+find_package(pybind11 REQUIRED CONFIG)
+
+# 🔥 FIX: Also link pybind11 for the C++ executables
+target_link_libraries(test_ode PRIVATE pybind11::pybind11)
+target_link_libraries(demo_autodiff PRIVATE pybind11::pybind11)
+
+pybind11_add_module(asc_ode
+    src/bindings.cpp
+)
+
+target_link_libraries(asc_ode PRIVATE nanoblas)
+
+set_target_properties(asc_ode PROPERTIES
+    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
+)
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 000000000..17abf0e86
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,31 @@
+cmake_minimum_required(VERSION 3.20)
+project(ASC_ode LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+include_directories(src nanoblas/src)
+add_subdirectory(nanoblas)
+
+add_executable(test_ode demos/test_ode.cpp)
+target_link_libraries(test_ode PUBLIC nanoblas)
+
+add_executable(demo_autodiff demos/demo_autodiff.cpp)
+target_link_libraries(demo_autodiff PUBLIC nanoblas)
+
+# Python bindings
+find_package(pybind11 REQUIRED CONFIG)
+
+# 🔥 FIX: Also link pybind11 for the C++ executables
+target_link_libraries(test_ode PRIVATE pybind11::pybind11)
+target_link_libraries(demo_autodiff PRIVATE pybind11::pybind11)
+
+pybind11_add_module(asc_ode
+    src/bindings.cpp
+)
+
+target_link_libraries(asc_ode PRIVATE nanoblas)
+
+set_target_properties(asc_ode PROPERTIES
+    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
+)
diff --git a/CrankNicolson.hpp b/CrankNicolson.hpp
new file mode 100644
index 000000000..d9ac5c568
--- /dev/null
+++ b/CrankNicolson.hpp
@@ -0,0 +1,23 @@
+#pragma once
+#include "timestepper.hpp"
+#include "function_algebra.hpp"
+#include "newton.hpp"
+class CrankNicolson : public TimeStepper {
+    std::shared_ptr<NonlinearFunction> eq;
+    std::shared_ptr<Parameter> tau;
+    std::shared_ptr<ConstantFunction> yold, fold;
+    Vector<> ftmp;
+public:
+    CrankNicolson(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs), tau(std::make_shared<Parameter>(0.0)), ftmp(rhs->dimF()) {
+        yold = std::make_shared<ConstantFunction>(rhs->dimX());
+        fold = std::make_shared<ConstantFunction>(rhs->dimF());
+        auto id = std::make_shared<IdentityFunction>(rhs->dimX());
+        eq = id - yold - 0.5*tau*(fold + rhs);
+    }
+    void doStep(double tau, VectorView<double> y) override {
+        m_rhs->evaluate(y, ftmp); fold->set(ftmp);
+        yold->set(y); tau->set(tau);
+        NewtonSolver(eq, y);
+    }
+};
diff --git a/ImplicitEuler.hpp b/ImplicitEuler.hpp
new file mode 100644
index 000000000..2619ba532
--- /dev/null
+++ b/ImplicitEuler.hpp
@@ -0,0 +1,19 @@
+#pragma once
+#include "timestepper.hpp"
+#include "function_algebra.hpp"
+#include "newton.hpp"
+class ImplicitEuler : public TimeStepper {
+    std::shared_ptr<NonlinearFunction> eq;
+    std::shared_ptr<Parameter> tau;
+    std::shared_ptr<ConstantFunction> yold;
+public:
+    ImplicitEuler(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs), tau(std::make_shared<Parameter>(0.0)) {
+        yold = std::make_shared<ConstantFunction>(rhs->dimX());
+        auto id = std::make_shared<IdentityFunction>(rhs->dimX());
+        eq = id - yold - tau * rhs;
+    }
+    void doStep(double tau, VectorView<double> y) override {
+        yold->set(y); tau->set(tau); NewtonSolver(eq, y);
+    }
+};
diff --git a/ImprovedEuler.hpp b/ImprovedEuler.hpp
new file mode 100644
index 000000000..50e3c2633
--- /dev/null
+++ b/ImprovedEuler.hpp
@@ -0,0 +1,14 @@
+#pragma once
+#include "timestepper.hpp"
+class ImprovedEuler : public TimeStepper {
+    Vector<> k1, k2, tmp;
+public:
+    ImprovedEuler(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs), k1(rhs->dimF()), k2(rhs->dimF()), tmp(rhs->dimF()) {}
+    void doStep(double tau, VectorView<double> y) override {
+        m_rhs->evaluate(y, k1);
+        tmp = y + tau * k1;
+        m_rhs->evaluate(tmp, k2);
+        y += tau * (0.5 * k1 + 0.5 * k2);
+    }
+};
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 000000000..09df6fca5
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 TU Wien - Institute of Analysis and Scientific Computing
+
+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.
diff --git a/README.md b/README.md
new file mode 100644
index 000000000..9572d8104
--- /dev/null
+++ b/README.md
@@ -0,0 +1,7 @@
+# ASC-ODE
+A package for solving ordinary differential equations
+
+Read the [documentation](https://tuwien-asc.github.io/ASC-ODE/intro.html)
+
+Find theory behind here: https://jschoeberl.github.io/IntroSC/ODEs/ODEs.html
+
diff --git a/build/CMakeCache.txt b/build/CMakeCache.txt
new file mode 100644
index 000000000..7e7f4e5a9
--- /dev/null
+++ b/build/CMakeCache.txt
@@ -0,0 +1,378 @@
+# This is the CMakeCache file.
+# For build in directory: /home/jovyan/ASC-ODE-backup-20251122-180845/build
+# It was generated by CMake: /home/jovyan/.local/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
+########################
+
+//No help, variable specified on the command line.
+ASC_ODE_BUILD_PYTHON:UNINITIALIZED=OFF
+
+//Value Computed by CMake
+ASC_ode_BINARY_DIR:STATIC=/home/jovyan/ASC-ODE-backup-20251122-180845/build
+
+//Value Computed by CMake
+ASC_ode_IS_TOP_LEVEL:STATIC=ON
+
+//Value Computed by CMake
+ASC_ode_SOURCE_DIR:STATIC=/home/jovyan/ASC-ODE-backup-20251122-180845
+
+//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.
+CMAKE_BUILD_TYPE:STRING=RelWithDebInfo
+
+//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
+
+//A wrapper around 'ranlib' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_CXX_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib
+
+//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
+
+//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=
+
+//Value Computed by CMake.
+CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/home/jovyan/ASC-ODE-backup-20251122-180845/build/CMakeFiles/pkgRedirects
+
+//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=ASC_ode
+
+//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
+
+//Path to a program.
+CMAKE_TAPI:FILEPATH=CMAKE_TAPI-NOTFOUND
+
+//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
+
+//Build demonstration targets
+NANOBLAS_BUILD_DEMOS:BOOL=OFF
+
+//No help, variable specified on the command line.
+Python3_EXECUTABLE:UNINITIALIZED=/opt/venv/bin/python3.13
+
+//Value Computed by CMake
+nanoblas_BINARY_DIR:STATIC=/home/jovyan/ASC-ODE-backup-20251122-180845/build/nanoblas
+
+//Value Computed by CMake
+nanoblas_IS_TOP_LEVEL:STATIC=OFF
+
+//Value Computed by CMake
+nanoblas_SOURCE_DIR:STATIC=/home/jovyan/ASC-ODE-backup-20251122-180845/nanoblas
+
+//The directory containing a CMake configuration file for pybind11.
+pybind11_DIR:PATH=pybind11_DIR-NOTFOUND
+
+
+########################
+# 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/jovyan/ASC-ODE-backup-20251122-180845/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=29
+//Patch version of cmake used to create the current loaded cache
+CMAKE_CACHE_PATCH_VERSION:INTERNAL=4
+//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE
+CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1
+//Path to CMake executable.
+CMAKE_COMMAND:INTERNAL=/home/jovyan/.local/bin/cmake
+//Path to cpack program executable.
+CMAKE_CPACK_COMMAND:INTERNAL=/home/jovyan/.local/bin/cpack
+//Path to ctest program executable.
+CMAKE_CTEST_COMMAND:INTERNAL=/home/jovyan/.local/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_DLLTOOL
+CMAKE_DLLTOOL-ADVANCED:INTERNAL=1
+//Path to cache edit program executable.
+CMAKE_EDIT_COMMAND:INTERNAL=/home/jovyan/.local/bin/ccmake
+//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/jovyan/ASC-ODE-backup-20251122-180845
+//Install .so files without execute permission.
+CMAKE_INSTALL_SO_NO_EXE:INTERNAL=0
+//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=2
+//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=/home/jovyan/.local/share/cmake-3.29
+//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
+//ADVANCED property for variable: CMAKE_TAPI
+CMAKE_TAPI-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 Python
+FIND_PACKAGE_MESSAGE_DETAILS_Python:INTERNAL=[/opt/venv/bin/python3.13][/usr/include/python3.13][/usr/lib/libpython3.13.so][cfound components: Interpreter Development Development.Module Development.Embed ][v3.13.7(3.8)]
+//linker supports push/pop state
+_CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED:INTERNAL=TRUE
+//Compiler reason failure
+_Python_Compiler_REASON_FAILURE:INTERNAL=
+_Python_DEVELOPMENT_EMBED_SIGNATURE:INTERNAL=82b13d141b9a005f0015bee39d059b07
+_Python_DEVELOPMENT_MODULE_SIGNATURE:INTERNAL=a95b148aac5e04f29e19ad19bf7876a8
+//Development reason failure
+_Python_Development_REASON_FAILURE:INTERNAL=
+//Path to a program.
+_Python_EXECUTABLE:INTERNAL=/opt/venv/bin/python3.13
+//Path to a file.
+_Python_INCLUDE_DIR:INTERNAL=/usr/include/python3.13
+//Python Properties
+_Python_INTERPRETER_PROPERTIES:INTERNAL=Python;3;13;7;64;;cpython-313-x86_64-linux-gnu;abi3;/usr/lib/python3.13;/opt/venv/lib/python3.13;/opt/venv/lib/python3.13/site-packages;/opt/venv/lib/python3.13/site-packages
+_Python_INTERPRETER_SIGNATURE:INTERNAL=616cd2011fcf6d4aa6814422fffedc62
+//Path to a library.
+_Python_LIBRARY_RELEASE:INTERNAL=/usr/lib/libpython3.13.so
+//NumPy reason failure
+_Python_NumPy_REASON_FAILURE:INTERNAL=
+
diff --git a/build/CMakeFiles/3.29.4/CMakeCXXCompiler.cmake b/build/CMakeFiles/3.29.4/CMakeCXXCompiler.cmake
new file mode 100644
index 000000000..cd0da0c4b
--- /dev/null
+++ b/build/CMakeFiles/3.29.4/CMakeCXXCompiler.cmake
@@ -0,0 +1,92 @@
+set(CMAKE_CXX_COMPILER "/usr/bin/c++")
+set(CMAKE_CXX_COMPILER_ARG1 "")
+set(CMAKE_CXX_COMPILER_ID "GNU")
+set(CMAKE_CXX_COMPILER_VERSION "15.2.1")
+set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "")
+set(CMAKE_CXX_COMPILER_WRAPPER "")
+set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "17")
+set(CMAKE_CXX_EXTENSIONS_COMPUTED_DEFAULT "ON")
+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;cxx_std_23")
+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_CXX23_COMPILE_FEATURES "cxx_std_23")
+
+set(CMAKE_CXX_PLATFORM_ID "Linux")
+set(CMAKE_CXX_SIMULATE_ID "")
+set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "GNU")
+set(CMAKE_CXX_SIMULATE_VERSION "")
+
+
+
+
+set(CMAKE_AR "/usr/bin/ar")
+set(CMAKE_CXX_COMPILER_AR "/usr/bin/gcc-ar")
+set(CMAKE_RANLIB "/usr/bin/ranlib")
+set(CMAKE_CXX_COMPILER_RANLIB "/usr/bin/gcc-ranlib")
+set(CMAKE_LINKER "/usr/bin/ld")
+set(CMAKE_LINKER_LINK "")
+set(CMAKE_LINKER_LLD "")
+set(CMAKE_CXX_COMPILER_LINKER "/usr/bin/ld")
+set(CMAKE_CXX_COMPILER_LINKER_ID "GNU")
+set(CMAKE_CXX_COMPILER_LINKER_VERSION 2.45.0)
+set(CMAKE_CXX_COMPILER_LINKER_FRONTEND_VARIANT GNU)
+set(CMAKE_MT "")
+set(CMAKE_TAPI "CMAKE_TAPI-NOTFOUND")
+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_CXX_COMPILER_ENV_VAR "CXX")
+
+set(CMAKE_CXX_COMPILER_ID_RUN 1)
+set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;mpp;CPP;ixx;cppm;ccm;cxxm;c++m)
+set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC)
+
+foreach (lang IN ITEMS 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)
+set(CMAKE_CXX_LINKER_DEPFILE_SUPPORTED FALSE)
+
+# Save compiler ABI information.
+set(CMAKE_CXX_SIZEOF_DATA_PTR "8")
+set(CMAKE_CXX_COMPILER_ABI "ELF")
+set(CMAKE_CXX_BYTE_ORDER "LITTLE_ENDIAN")
+set(CMAKE_CXX_LIBRARY_ARCHITECTURE "")
+
+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 "")
+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++/15.2.1;/usr/include/c++/15.2.1/x86_64-pc-linux-gnu;/usr/include/c++/15.2.1/backward;/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/include;/usr/local/include;/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/include-fixed;/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-pc-linux-gnu/15.2.1;/usr/lib;/lib")
+set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")
+set(CMAKE_CXX_COMPILER_CLANG_RESOURCE_DIR "")
diff --git a/build/CMakeFiles/3.29.4/CMakeDetermineCompilerABI_CXX.bin b/build/CMakeFiles/3.29.4/CMakeDetermineCompilerABI_CXX.bin
new file mode 100755
index 0000000000000000000000000000000000000000..26a6533bc61639b1bfdb74e79c600a5976f61fe8
GIT binary patch
literal 15440
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

literal 0
HcmV?d00001

diff --git a/build/CMakeFiles/3.29.4/CMakeSystem.cmake b/build/CMakeFiles/3.29.4/CMakeSystem.cmake
new file mode 100644
index 000000000..214af4ea4
--- /dev/null
+++ b/build/CMakeFiles/3.29.4/CMakeSystem.cmake
@@ -0,0 +1,15 @@
+set(CMAKE_HOST_SYSTEM "Linux-5.15.0-140-generic")
+set(CMAKE_HOST_SYSTEM_NAME "Linux")
+set(CMAKE_HOST_SYSTEM_VERSION "5.15.0-140-generic")
+set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64")
+
+
+
+set(CMAKE_SYSTEM "Linux-5.15.0-140-generic")
+set(CMAKE_SYSTEM_NAME "Linux")
+set(CMAKE_SYSTEM_VERSION "5.15.0-140-generic")
+set(CMAKE_SYSTEM_PROCESSOR "x86_64")
+
+set(CMAKE_CROSSCOMPILING "FALSE")
+
+set(CMAKE_SYSTEM_LOADED 1)
diff --git a/build/CMakeFiles/3.29.4/CompilerIdCXX/CMakeCXXCompilerId.cpp b/build/CMakeFiles/3.29.4/CompilerIdCXX/CMakeCXXCompilerId.cpp
new file mode 100644
index 000000000..9a5e8f8ce
--- /dev/null
+++ b/build/CMakeFiles/3.29.4/CompilerIdCXX/CMakeCXXCompilerId.cpp
@@ -0,0 +1,878 @@
+/* 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
+
+#if !defined(__has_include)
+/* If the compiler does not have __has_include, pretend the answer is
+   always no.  */
+#  define __has_include(x) 0
+#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 prior to 2021, and then VVVV for 2021 and later,
+     except that a few beta releases use the old format with V=2021.  */
+# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111
+#  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
+# else
+#  define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER)
+#  define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE)
+   /* The third version component from --version is an update index,
+      but no macro is provided for it.  */
+#  define COMPILER_VERSION_PATCH DEC(0)
+# 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(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER)
+# define COMPILER_ID "IntelLLVM"
+#if defined(_MSC_VER)
+# define SIMULATE_ID "MSVC"
+#endif
+#if defined(__GNUC__)
+# define SIMULATE_ID "GNU"
+#endif
+/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and
+ * later.  Look for 6 digit vs. 8 digit version number to decide encoding.
+ * VVVV is no smaller than the current year when a version is released.
+ */
+#if __INTEL_LLVM_COMPILER < 1000000L
+# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100)
+# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER    % 10)
+#else
+# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000)
+# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100)
+# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER     % 100)
+#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(__open_xl__) && defined(__clang__)
+# define COMPILER_ID "IBMClang"
+# define COMPILER_VERSION_MAJOR DEC(__open_xl_version__)
+# define COMPILER_VERSION_MINOR DEC(__open_xl_release__)
+# define COMPILER_VERSION_PATCH DEC(__open_xl_modification__)
+# define COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__)
+
+
+#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(__NVCOMPILER)
+# define COMPILER_ID "NVHPC"
+# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__)
+# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__)
+# if defined(__NVCOMPILER_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__)
+# endif
+
+#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(__clang__) && defined(__cray__)
+# define COMPILER_ID "CrayClang"
+# define COMPILER_VERSION_MAJOR DEC(__cray_major__)
+# define COMPILER_VERSION_MINOR DEC(__cray_minor__)
+# define COMPILER_VERSION_PATCH DEC(__cray_patchlevel__)
+# define COMPILER_VERSION_INTERNAL_STR __clang_version__
+
+
+#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(__CLANG_FUJITSU)
+# define COMPILER_ID "FujitsuClang"
+# define COMPILER_VERSION_MAJOR DEC(__FCC_major__)
+# define COMPILER_VERSION_MINOR DEC(__FCC_minor__)
+# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__)
+# define COMPILER_VERSION_INTERNAL_STR __clang_version__
+
+
+#elif defined(__FUJITSU)
+# define COMPILER_ID "Fujitsu"
+# if defined(__FCC_version__)
+#   define COMPILER_VERSION __FCC_version__
+# elif defined(__FCC_major__)
+#   define COMPILER_VERSION_MAJOR DEC(__FCC_major__)
+#   define COMPILER_VERSION_MINOR DEC(__FCC_minor__)
+#   define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__)
+# endif
+# if defined(__fcc_version)
+#   define COMPILER_VERSION_INTERNAL DEC(__fcc_version)
+# elif defined(__FCC_VERSION)
+#   define COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION)
+# endif
+
+
+#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(__TASKING__)
+# define COMPILER_ID "Tasking"
+  # define COMPILER_VERSION_MAJOR DEC(__VERSION__/1000)
+  # define COMPILER_VERSION_MINOR DEC(__VERSION__ % 100)
+# define COMPILER_VERSION_INTERNAL DEC(__VERSION__)
+
+#elif defined(__ORANGEC__)
+# define COMPILER_ID "OrangeC"
+# define COMPILER_VERSION_MAJOR DEC(__ORANGEC_MAJOR__)
+# define COMPILER_VERSION_MINOR DEC(__ORANGEC_MINOR__)
+# define COMPILER_VERSION_PATCH DEC(__ORANGEC_PATCHLEVEL__)
+
+#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/100   % 100)
+# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
+
+#elif defined(__clang__) && defined(__ti__)
+# define COMPILER_ID "TIClang"
+  # define COMPILER_VERSION_MAJOR DEC(__ti_major__)
+  # define COMPILER_VERSION_MINOR DEC(__ti_minor__)
+  # define COMPILER_VERSION_PATCH DEC(__ti_patchlevel__)
+# define COMPILER_VERSION_INTERNAL DEC(__ti_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(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__))
+# define COMPILER_ID "LCC"
+# define COMPILER_VERSION_MAJOR DEC(__LCC__ / 100)
+# define COMPILER_VERSION_MINOR DEC(__LCC__ % 100)
+# if defined(__LCC_MINOR__)
+#  define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__)
+# endif
+# if defined(__GNUC__) && defined(__GNUC_MINOR__)
+#  define SIMULATE_ID "GNU"
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
+#  define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
+#  if defined(__GNUC_PATCHLEVEL__)
+#   define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+#  endif
+# 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(_ADI_COMPILER)
+# define COMPILER_ID "ADSP"
+#if defined(__VERSIONNUM__)
+  /* __VERSIONNUM__ = 0xVVRRPPTT */
+#  define COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF)
+#  define COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF)
+#  define COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF)
+#  define COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 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__) || defined(__ICCSTM8__))
+#  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(__CRAYXT_COMPUTE_LINUX_TARGET)
+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(__MSYS__)
+# define PLATFORM_ID "MSYS"
+
+#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"
+
+# elif defined(__VXWORKS__)
+#  define PLATFORM_ID "VxWorks"
+
+# 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
+
+# elif defined(_ADI_COMPILER)
+#  define PLATFORM_ID "ADSP"
+
+#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_ARM64EC)
+#  define ARCHITECTURE_ID "ARM64EC"
+
+# 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"
+
+# elif defined(__ICCSTM8__)
+#  define ARCHITECTURE_ID "STM8"
+
+# 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
+
+#elif defined(__clang__) && defined(__ti__)
+# if defined(__ARM_ARCH)
+#  define ARCHITECTURE_ID "Arm"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__TI_COMPILER_VERSION__)
+# if defined(__TI_ARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__MSP430__)
+#  define ARCHITECTURE_ID "MSP430"
+
+# elif defined(__TMS320C28XX__)
+#  define ARCHITECTURE_ID "TMS320C28x"
+
+# elif defined(__TMS320C6X__) || defined(_TMS320C6X)
+#  define ARCHITECTURE_ID "TMS320C6x"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+# elif defined(__ADSPSHARC__)
+#  define ARCHITECTURE_ID "SHARC"
+
+# elif defined(__ADSPBLACKFIN__)
+#  define ARCHITECTURE_ID "Blackfin"
+
+#elif defined(__TASKING__)
+
+# if defined(__CTC__) || defined(__CPTC__)
+#  define ARCHITECTURE_ID "TriCore"
+
+# elif defined(__CMCS__)
+#  define ARCHITECTURE_ID "MCS"
+
+# elif defined(__CARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__CARC__)
+#  define ARCHITECTURE_ID "ARC"
+
+# elif defined(__C51__)
+#  define ARCHITECTURE_ID "8051"
+
+# elif defined(__CPCP__)
+#  define ARCHITECTURE_ID "PCP"
+
+# else
+#  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. */
+#ifdef COMPILER_VERSION
+char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]";
+
+/* Construct a string literal encoding the version number components. */
+#elif defined(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'};
+#elif defined(COMPILER_VERSION_INTERNAL_STR)
+char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]";
+#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_standard_default = "INFO" ":" "standard_default["
+#if CXX_STD > 202002L
+  "23"
+#elif CXX_STD > 201703L
+  "20"
+#elif CXX_STD >= 201703L
+  "17"
+#elif CXX_STD >= 201402L
+  "14"
+#elif CXX_STD >= 201103L
+  "11"
+#else
+  "98"
+#endif
+"]";
+
+const char* info_language_extensions_default = "INFO" ":" "extensions_default["
+#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) ||           \
+     defined(__TI_COMPILER_VERSION__)) &&                                     \
+  !defined(__STRICT_ANSI__)
+  "ON"
+#else
+  "OFF"
+#endif
+"]";
+
+/*--------------------------------------------------------------------------*/
+
+int main(int argc, char* argv[])
+{
+  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(__CRAYXT_COMPUTE_LINUX_TARGET)
+  require += info_cray[argc];
+#endif
+  require += info_language_standard_default[argc];
+  require += info_language_extensions_default[argc];
+  (void)argv;
+  return require;
+}
diff --git a/build/CMakeFiles/3.29.4/CompilerIdCXX/a.out b/build/CMakeFiles/3.29.4/CompilerIdCXX/a.out
new file mode 100755
index 0000000000000000000000000000000000000000..8f93456c52b4dcf138ab3ef99acdf10909e93493
GIT binary patch
literal 15552
zcmeHOYit}>6~4Pp8k;7z6Y7%26&a$caw(qJP8>|A={ok>W66(@IFi8)!+3XXue#n{
z?T#y_5~?NhvZ9m#qKbrgNT^bU6roC0K|)jxfkIG0?hmA@Kah*4Fj1gJ6qM4)%Q<t;
zx7od2M@XRlnrnH!d%p9ych1c0-kmw~RD5JG8i^>hI`t{VlGUu4m?&1er9%)?J*ttm
z_p4TQ7s)#UPU~YDNUK|OT{YGV&oukJAbJz;7ds$k$jE-%wdZ(3)PPF%gZ*~0LSz$v
zD+2(bFOO%jGc_yNmhmz116KO+RMy+I{d#XTPDZu-c|rKG$bOsRw<&(WH5m_xd~#0s
z|D@#8#2D$g#e%I;rr$;JGw}hj2l5!)82SH^kFfM!v;wxArt&d6{idH}KXZPNW8w$I
zJWq<>E0#7e5$6dI^ZYdV$tfX`?+iFSPRV%N9Y0Hs8&D2Qu%8_?1fOd|V`o%!Nv-l+
zppU3Xl^iu>w!Me``EaoRb31?eOv8=qKmT+7&~MsS3j1as-|_b0OnUm*(ZiW!dnTP-
zSZrVHIo5vcs9nt2UBNg!7RICQf7K?*>QD{KLE`q+;5koL4W7rX#eZxYUb*h<d@k!2
zeXroVu5yPbM%`qpkeW>w{ZwIMv_F%}rY5}UOiJr&Yg|f6LW0bD=`4j!EPC!tI_qW9
zPo@;9i+(ck@WY&?V=T^>d$S4hWT}(+gyx4vhEMdnUG|Zq3f(R{_zaBFv7w_#f7~J}
zs-7mqdGo^8pP|#OPF)gi;Xt}Uk<Aa-m>NC@a9%g>)%=EB=ipZ*V0}#M!9#8~c+1ju
z`whMzyk+oT5x&jfzbSl&!Cw}B^-&cx+DXZPmVaHr%cT)0)+%`Uhza=DDtKJ0tXQw$
zgU{>0I^2XA2s037Ak09RfiMGM2Eq*dzcTQTrVszyS-w&4oZorvuu{&KR{dyc%~}3M
z{ncOy)_4AOc;(g4IV*p3mjASQaw6Wj+Ih{n(EB<Wlv<X_>+Ko4>EIUwd*a{VI2U%l
z&hUwwehY=3k<bmL^`?VMY<N|W?4J+pyMM^=(3Z2Z>0J5Sqt2C^bx!1E=hZF$9tzMc
z0qRTZGff8vZu|56mU`z&trm`)ah7|p+thVd-t_l4=X)O{zSQy>Q5%U;sr2&B0U{!2
zuil<7%_F8}Zp$3+FSBHOhGMLI;fAxau>Py~EuOM-zU2=T>3sZ#bIFOUHNB{sURsUB
zZxR2yZTOdJ@jAeTmMe`)HNCi_xg6zEEo+MY)mr@d_^q>ah|0&We8hOFVGA=5W+2Q!
zn1L_@VFtnsgc%4k5N06EK$w9r1JxPe=T~=X!()Tv#}m2vd^(dVOwkj`v(?sBdiRM`
zp_tBPr#gbx*=_4iM;AJsXI0>l&v^b!t}s6}!cQ=T^a_c&De2Smz--bhB<We;jJJ^S
zr#e3_n$)77%JL}1vTl4Vm{p{;?vwjzdb~#yZ<R_%2}d_er4d4Yrphhy<S7+dY>u?<
z-c^5*9^o<1&y4qz{ex^Uuq$}-#vJ><L;SPM_cb<uIoiMHuITs4lL`I&n~nKNAU~_+
z#?P`UpJxSRxCt{5W+2Q!n1L_@VFtnsgc%4k5N06E!26H^)EA<jP**J~H7jF7e!`HK
z4Ebr1cMGE6agWHWQpb3o$f$E{6&dx52Si4_BkFab|L0aI$0lo1EQlJwCHYasb%)$G
zMgIXUsvim7Ey%wExwU90Z+A&AFM%;`k0gSMHG>BKcT0LcL<Xi?BFDs^o)ic3MIPzr
zW*~Qn{vDAqj)Z^T0rlhC4UD={%hDF88%3Qc>OxTmI@I5P+-jp=y$@ORGr!C3w7NRF
zx;uJ0k8C%B<~dJ0)Za^{73Vvm_NbVpHC+`3wd_9{=o=O4z+uj1v=Q||W$y1_z_+Lk
zsV{~7W7KI@_o|*47>$q6L@nZ#!6!()m*z>zpy9WEfuuv4s@h&4X`i}V-6z+_v!eY5
z;oj)I3VDaq_n4<~%{t!8!do$IiSy~lB<_puR=EDOR;iyc51|6NXoKT-#59RG?+V{+
z@G;5*&)<@I<lr6&*)}jArK?YP9gPYai0Az>^V!NgjoW6#KTbU7-^}w+z<)@^#2)cS
zgg4_)5^uq%0{w0H<!yM?Kk7Z6>YtqKmwR5rNjs6xEBCV_on7hdOb++BsKT7iemCy8
zgQxmN<E}GsO1T4{8S5Jz?pN;6$oPrA5qErW@N|5_o#;C;5~tesRMPW3Dq|m~O7&zq
z>n;>iNuyFdR#|N>mF&r4&Yh#%VN?Pi%m6pfw8VGK6j!>ZDU?wLUyep)?15{>%g!!%
zvnltzchR%~ZuKdb0{Rq@D)8O-*Z`I0R|ha}(2*(covy*BUCr{IO&5zG?o`)b;}w9K
zW&X-8o}2f*X+poCaSpv~&QIC1*#$da$mLT7|D3YR)bv7{UY1BFm7UJgO9goq7|wac
zIb|o$Whtmezo0d88?#DqNmoc^Ja*tXlpNcqEGj!ly<Nx!2iH!`xibZCKIP6O$pey1
zrtidXyYJ0vf7dG%Jenr^qff!T`E-It&QWCA*!c`~bZE+^vgrWLr?P&<DgHlo`TLo_
z6QdFZ@8JMr!UOPm0hvmZs{Aj?_cHJS7z*O^5_BJR=u#|?zukLauxH!KHcZ05=sOnk
zUz72HSYOE3arwO`#5heIUNgXdQ~ZG!#gNw>JT~?p>w_uc*aiMrrvR}oA(Nn)^G^`V
zYY6yb-2lXT3-gB^Fi-xxCV`A~39v&C8@y9iIe($mQ`F&O0)MQFfLIq{d~^R-$d}`C
zeu9SY13|3+pf->H*GN(6kM9}aca4N0JmP)J@W=NckiMy_nmPWr#UJ~xEHM|nCL%y+
zh{1b3JVp4wA_hR5e{e9zf1VVT{u|;CoPeVs@(=o_)Tz9F&G+#v7z&!>^Zqr`znu2v
z_mlA6n>ik2;P1(|slp%Y`i*uXsliT5w`K5ekb=)0jE{92-hae<jyS*Ihx6b%`Evf?
zkN1;S4--kPO+$GLf8blBsr1MCa6|lYog)DJfHw_)6%)%2jXfd);0Jk&I?Q4ISl9H3
zziH2Nt!#BfFem0^75vTX5B`;ibGPhFok<D!6Hy)@j?Xj92YG2A4s)k&xi!o0fbU=+
W(HJ7F32Xab=7(?8b{h_csQv?Z@bdrw

literal 0
HcmV?d00001

diff --git a/build/CMakeFiles/CMakeConfigureLog.yaml b/build/CMakeFiles/CMakeConfigureLog.yaml
new file mode 100644
index 000000000..72a7eec09
--- /dev/null
+++ b/build/CMakeFiles/CMakeConfigureLog.yaml
@@ -0,0 +1,274 @@
+
+---
+events:
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineSystem.cmake:205 (message)"
+      - "CMakeLists.txt:2 (project)"
+    message: |
+      The system is: Linux - 5.15.0-140-generic - x86_64
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompilerId.cmake:17 (message)"
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)"
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCXXCompiler.cmake:126 (CMAKE_DETERMINE_COMPILER_ID)"
+      - "CMakeLists.txt:2 (project)"
+    message: |
+      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/jovyan/ASC-ODE-backup-20251122-180845/build/CMakeFiles/3.29.4/CompilerIdCXX/a.out
+      
+  -
+    kind: "try_compile-v1"
+    backtrace:
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompilerABI.cmake:67 (try_compile)"
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:2 (project)"
+    checks:
+      - "Detecting CXX compiler ABI info"
+    directories:
+      source: "/home/jovyan/ASC-ODE-backup-20251122-180845/build/CMakeFiles/CMakeScratch/TryCompile-WQOc8U"
+      binary: "/home/jovyan/ASC-ODE-backup-20251122-180845/build/CMakeFiles/CMakeScratch/TryCompile-WQOc8U"
+    cmakeVariables:
+      CMAKE_CXX_FLAGS: ""
+      CMAKE_CXX_FLAGS_DEBUG: "-g"
+      CMAKE_CXX_SCAN_FOR_MODULES: "OFF"
+      CMAKE_EXE_LINKER_FLAGS: ""
+    buildResult:
+      variable: "CMAKE_CXX_ABI_COMPILED"
+      cached: true
+      stdout: |
+        Change Dir: '/home/jovyan/ASC-ODE-backup-20251122-180845/build/CMakeFiles/CMakeScratch/TryCompile-WQOc8U'
+        
+        Run Build Command(s): /home/jovyan/.local/bin/cmake -E env VERBOSE=1 /usr/bin/make -f Makefile cmTC_273da/fast
+        /usr/bin/make  -f CMakeFiles/cmTC_273da.dir/build.make CMakeFiles/cmTC_273da.dir/build
+        make[1]: Entering directory '/home/jovyan/ASC-ODE-backup-20251122-180845/build/CMakeFiles/CMakeScratch/TryCompile-WQOc8U'
+        Building CXX object CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o
+        /usr/bin/c++   -v -o CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o -c /home/jovyan/.local/share/cmake-3.29/Modules/CMakeCXXCompilerABI.cpp
+        Using built-in specs.
+        COLLECT_GCC=/usr/bin/c++
+        Target: x86_64-pc-linux-gnu
+        Configured with: /build/gcc/src/gcc/configure --enable-languages=ada,c,c++,d,fortran,go,lto,m2,objc,obj-c++,rust,cobol --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --enable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror
+        Thread model: posix
+        Supported LTO compression algorithms: zlib zstd
+        gcc version 15.2.1 20250813 (GCC) 
+        COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_273da.dir/'
+         /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/cc1plus -quiet -v -D_GNU_SOURCE /home/jovyan/.local/share/cmake-3.29/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpdir CMakeFiles/cmTC_273da.dir/ -dumpbase CMakeCXXCompilerABI.cpp.cpp -dumpbase-ext .cpp -mtune=generic -march=x86-64 -version -o /tmp/cc5veN8z.s
+        GNU C++17 (GCC) version 15.2.1 20250813 (x86_64-pc-linux-gnu)
+        	compiled by GNU C version 15.2.1 20250813, GMP version 6.3.0, MPFR version 4.2.2, MPC version 1.3.1, isl version isl-0.27-GMP
+        
+        GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
+        ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../x86_64-pc-linux-gnu/include"
+        #include "..." search starts here:
+        #include <...> search starts here:
+         /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../include/c++/15.2.1
+         /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../include/c++/15.2.1/x86_64-pc-linux-gnu
+         /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../include/c++/15.2.1/backward
+         /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/include
+         /usr/local/include
+         /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/include-fixed
+         /usr/include
+        End of search list.
+        Compiler executable checksum: 452a313327dacf71986995db29f6855a
+        COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_273da.dir/'
+         as -v --64 -o CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o /tmp/cc5veN8z.s
+        GNU assembler version 2.45.0 (x86_64-pc-linux-gnu) using BFD version (GNU Binutils) 2.45.0
+        COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/
+        LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../:/lib/:/usr/lib/
+        COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.'
+        Linking CXX executable cmTC_273da
+        /home/jovyan/.local/bin/cmake -E cmake_link_script CMakeFiles/cmTC_273da.dir/link.txt --verbose=1
+        /usr/bin/c++  -v -Wl,-v CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_273da
+        Using built-in specs.
+        COLLECT_GCC=/usr/bin/c++
+        COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/lto-wrapper
+        Target: x86_64-pc-linux-gnu
+        Configured with: /build/gcc/src/gcc/configure --enable-languages=ada,c,c++,d,fortran,go,lto,m2,objc,obj-c++,rust,cobol --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --enable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror
+        Thread model: posix
+        Supported LTO compression algorithms: zlib zstd
+        gcc version 15.2.1 20250813 (GCC) 
+        COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/
+        LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../:/lib/:/usr/lib/
+        COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_273da' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_273da.'
+         /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/collect2 -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/cchIf2wZ.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 --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_273da /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/crtbeginS.o -L/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../.. -L/lib -L/usr/lib -v CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/crtn.o
+        collect2 version 15.2.1 20250813
+        /usr/bin/ld -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/cchIf2wZ.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 --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_273da /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/crtbeginS.o -L/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../.. -L/lib -L/usr/lib -v CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/crtn.o
+        GNU ld (GNU Binutils) 2.45.0
+        COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_273da' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_273da.'
+        make[1]: Leaving directory '/home/jovyan/ASC-ODE-backup-20251122-180845/build/CMakeFiles/CMakeScratch/TryCompile-WQOc8U'
+        
+      exitCode: 0
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompilerABI.cmake:137 (message)"
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:2 (project)"
+    message: |
+      Parsed CXX implicit include dir info: rv=done
+        found start of include info
+        found start of implicit include info
+          add: [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../include/c++/15.2.1]
+          add: [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../include/c++/15.2.1/x86_64-pc-linux-gnu]
+          add: [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../include/c++/15.2.1/backward]
+          add: [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/include]
+          add: [/usr/local/include]
+          add: [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/include-fixed]
+          add: [/usr/include]
+        end of search list found
+        collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../include/c++/15.2.1] ==> [/usr/include/c++/15.2.1]
+        collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../include/c++/15.2.1/x86_64-pc-linux-gnu] ==> [/usr/include/c++/15.2.1/x86_64-pc-linux-gnu]
+        collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../include/c++/15.2.1/backward] ==> [/usr/include/c++/15.2.1/backward]
+        collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/include] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/include]
+        collapse include dir [/usr/local/include] ==> [/usr/local/include]
+        collapse include dir [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/include-fixed] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/include-fixed]
+        collapse include dir [/usr/include] ==> [/usr/include]
+        implicit include dirs: [/usr/include/c++/15.2.1;/usr/include/c++/15.2.1/x86_64-pc-linux-gnu;/usr/include/c++/15.2.1/backward;/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/include;/usr/local/include;/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/include-fixed;/usr/include]
+      
+      
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompilerABI.cmake:173 (message)"
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:2 (project)"
+    message: |
+      Parsed CXX implicit link information:
+        link line regex: [^( *|.*[/\\])(ld[0-9]*(\\.[a-z]+)?|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)]
+        linker tool regex: [^[ 	]*(->|")?[ 	]*(([^"]*[/\\])?(ld[0-9]*(\\.[a-z]+)?))("|,| |$)]
+        ignore line: [Change Dir: '/home/jovyan/ASC-ODE-backup-20251122-180845/build/CMakeFiles/CMakeScratch/TryCompile-WQOc8U']
+        ignore line: []
+        ignore line: [Run Build Command(s): /home/jovyan/.local/bin/cmake -E env VERBOSE=1 /usr/bin/make -f Makefile cmTC_273da/fast]
+        ignore line: [/usr/bin/make  -f CMakeFiles/cmTC_273da.dir/build.make CMakeFiles/cmTC_273da.dir/build]
+        ignore line: [make[1]: Entering directory '/home/jovyan/ASC-ODE-backup-20251122-180845/build/CMakeFiles/CMakeScratch/TryCompile-WQOc8U']
+        ignore line: [Building CXX object CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o]
+        ignore line: [/usr/bin/c++   -v -o CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o -c /home/jovyan/.local/share/cmake-3.29/Modules/CMakeCXXCompilerABI.cpp]
+        ignore line: [Using built-in specs.]
+        ignore line: [COLLECT_GCC=/usr/bin/c++]
+        ignore line: [Target: x86_64-pc-linux-gnu]
+        ignore line: [Configured with: /build/gcc/src/gcc/configure --enable-languages=ada c c++ d fortran go lto m2 objc obj-c++ rust cobol --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --enable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror]
+        ignore line: [Thread model: posix]
+        ignore line: [Supported LTO compression algorithms: zlib zstd]
+        ignore line: [gcc version 15.2.1 20250813 (GCC) ]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_273da.dir/']
+        ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/cc1plus -quiet -v -D_GNU_SOURCE /home/jovyan/.local/share/cmake-3.29/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpdir CMakeFiles/cmTC_273da.dir/ -dumpbase CMakeCXXCompilerABI.cpp.cpp -dumpbase-ext .cpp -mtune=generic -march=x86-64 -version -o /tmp/cc5veN8z.s]
+        ignore line: [GNU C++17 (GCC) version 15.2.1 20250813 (x86_64-pc-linux-gnu)]
+        ignore line: [	compiled by GNU C version 15.2.1 20250813  GMP version 6.3.0  MPFR version 4.2.2  MPC version 1.3.1  isl version isl-0.27-GMP]
+        ignore line: []
+        ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
+        ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../x86_64-pc-linux-gnu/include"]
+        ignore line: [#include "..." search starts here:]
+        ignore line: [#include <...> search starts here:]
+        ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../include/c++/15.2.1]
+        ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../include/c++/15.2.1/x86_64-pc-linux-gnu]
+        ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../include/c++/15.2.1/backward]
+        ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/include]
+        ignore line: [ /usr/local/include]
+        ignore line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/include-fixed]
+        ignore line: [ /usr/include]
+        ignore line: [End of search list.]
+        ignore line: [Compiler executable checksum: 452a313327dacf71986995db29f6855a]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_273da.dir/']
+        ignore line: [ as -v --64 -o CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o /tmp/cc5veN8z.s]
+        ignore line: [GNU assembler version 2.45.0 (x86_64-pc-linux-gnu) using BFD version (GNU Binutils) 2.45.0]
+        ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/]
+        ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../:/lib/:/usr/lib/]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.']
+        ignore line: [Linking CXX executable cmTC_273da]
+        ignore line: [/home/jovyan/.local/bin/cmake -E cmake_link_script CMakeFiles/cmTC_273da.dir/link.txt --verbose=1]
+        ignore line: [/usr/bin/c++  -v -Wl -v CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_273da]
+        ignore line: [Using built-in specs.]
+        ignore line: [COLLECT_GCC=/usr/bin/c++]
+        ignore line: [COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/lto-wrapper]
+        ignore line: [Target: x86_64-pc-linux-gnu]
+        ignore line: [Configured with: /build/gcc/src/gcc/configure --enable-languages=ada c c++ d fortran go lto m2 objc obj-c++ rust cobol --enable-bootstrap --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://gitlab.archlinux.org/archlinux/packaging/packages/gcc/-/issues --with-build-config=bootstrap-lto --with-linker-hash-style=gnu --with-system-zlib --enable-__cxa_atexit --enable-cet=auto --enable-checking=release --enable-clocale=gnu --enable-default-pie --enable-default-ssp --enable-gnu-indirect-function --enable-gnu-unique-object --enable-libstdcxx-backtrace --enable-link-serialization=1 --enable-linker-build-id --enable-lto --enable-multilib --enable-plugin --enable-shared --enable-threads=posix --disable-libssp --disable-libstdcxx-pch --disable-werror]
+        ignore line: [Thread model: posix]
+        ignore line: [Supported LTO compression algorithms: zlib zstd]
+        ignore line: [gcc version 15.2.1 20250813 (GCC) ]
+        ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/]
+        ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/:/lib/../lib/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../:/lib/:/usr/lib/]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_273da' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_273da.']
+        link line: [ /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/collect2 -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/cchIf2wZ.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 --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_273da /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/crtbeginS.o -L/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../.. -L/lib -L/usr/lib -v CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/crtn.o]
+          arg [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/collect2] ==> ignore
+          arg [-plugin] ==> ignore
+          arg [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/liblto_plugin.so] ==> ignore
+          arg [-plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/lto-wrapper] ==> ignore
+          arg [-plugin-opt=-fresolution=/tmp/cchIf2wZ.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 [--hash-style=gnu] ==> ignore
+          arg [-m] ==> ignore
+          arg [elf_x86_64] ==> ignore
+          arg [-dynamic-linker] ==> ignore
+          arg [/lib64/ld-linux-x86-64.so.2] ==> ignore
+          arg [-pie] ==> ignore
+          arg [-o] ==> ignore
+          arg [cmTC_273da] ==> ignore
+          arg [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/Scrt1.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/Scrt1.o]
+          arg [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/crti.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/crti.o]
+          arg [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/crtbeginS.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/crtbeginS.o]
+          arg [-L/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1] ==> dir [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1]
+          arg [-L/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib]
+          arg [-L/lib/../lib] ==> dir [/lib/../lib]
+          arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib]
+          arg [-L/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../..] ==> dir [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../..]
+          arg [-L/lib] ==> dir [/lib]
+          arg [-L/usr/lib] ==> dir [/usr/lib]
+          arg [-v] ==> ignore
+          arg [CMakeFiles/cmTC_273da.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-pc-linux-gnu/15.2.1/crtendS.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/crtendS.o]
+          arg [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/crtn.o] ==> obj [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/crtn.o]
+        ignore line: [collect2 version 15.2.1 20250813]
+        ignore line: [/usr/bin/ld -plugin /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/lto-wrapper -plugin-opt=-fresolution=/tmp/cchIf2wZ.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 --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_273da /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/Scrt1.o /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/crti.o /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/crtbeginS.o -L/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1 -L/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../.. -L/lib -L/usr/lib -v CMakeFiles/cmTC_273da.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/crtendS.o /usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/crtn.o]
+        linker tool for 'CXX': /usr/bin/ld
+        collapse obj [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/Scrt1.o] ==> [/usr/lib/Scrt1.o]
+        collapse obj [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/crti.o] ==> [/usr/lib/crti.o]
+        collapse obj [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib/crtn.o] ==> [/usr/lib/crtn.o]
+        collapse library dir [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1] ==> [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1]
+        collapse library dir [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib] ==> [/usr/lib]
+        collapse library dir [/lib/../lib] ==> [/lib]
+        collapse library dir [/usr/lib/../lib] ==> [/usr/lib]
+        collapse library dir [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/../../..] ==> [/usr/lib]
+        collapse library dir [/lib] ==> [/lib]
+        collapse library dir [/usr/lib] ==> [/usr/lib]
+        implicit libs: [stdc++;m;gcc_s;gcc;c;gcc_s;gcc]
+        implicit objs: [/usr/lib/Scrt1.o;/usr/lib/crti.o;/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/crtbeginS.o;/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1/crtendS.o;/usr/lib/crtn.o]
+        implicit dirs: [/usr/lib/gcc/x86_64-pc-linux-gnu/15.2.1;/usr/lib;/lib]
+        implicit fwks: []
+      
+      
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/Internal/CMakeDetermineLinkerId.cmake:40 (message)"
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompilerABI.cmake:210 (cmake_determine_linker_id)"
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:2 (project)"
+    message: |
+      Running the CXX compiler's linker: "/usr/bin/ld" "-v"
+      GNU ld (GNU Binutils) 2.45.0
+...
diff --git a/build/CMakeFiles/cmake.check_cache b/build/CMakeFiles/cmake.check_cache
new file mode 100644
index 000000000..3dccd7317
--- /dev/null
+++ b/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/demos/.ipynb_checkpoints/compare_all-checkpoint.cpp b/demos/.ipynb_checkpoints/compare_all-checkpoint.cpp
new file mode 100644
index 000000000..e647050a1
--- /dev/null
+++ b/demos/.ipynb_checkpoints/compare_all-checkpoint.cpp
@@ -0,0 +1,68 @@
+#include "timestepper.hpp"
+#include "mass_spring_function.hpp"
+#include "ExplicitEuler.hpp"   // <--- ADDED THIS (was missing in your original)
+#include "ImprovedEuler.hpp"
+#include "ImplicitEuler.hpp"
+#include "CrankNicolson.hpp"
+#include <memory>
+#include <vector>
+#include <fstream>
+#include <iostream>
+#include <iomanip>
+#include <string>              // <--- ADDED for std::to_string
+
+// IMPORTANT: If your classes (Vector, MassSpring, etc.) are in a namespace, 
+// you must uncomment the line below. Check your header files to see if they use one.
+// using namespace asc_ode; 
+
+int main() {
+    // 1. Setup the problem (Mass Spring System)
+    auto rhs = std::make_shared<MassSpring>(1.0, 1.0);
+    
+    // 2. Initial Condition
+    Vector<> y0{1.0, 0.0};
+
+    // 3. Define the helper lambda to run simulations
+    auto run = [&](auto& stepper, const std::string& name, double tau) {
+        Vector<> y = y0;
+        
+        // Construct filename (ensure "results" folder exists!)
+        std::string filename = "results/" + name + "_tau" + std::to_string(tau) + ".txt";
+        std::ofstream f(filename);
+        
+        if (!f.is_open()) {
+            std::cerr << "Error: Could not open file " << filename << ". Did you create the 'results' folder?\n";
+            return;
+        }
+
+        f << std::fixed << std::setprecision(10);
+        f << "0 " << y(0) << " " << y(1) << "\n";
+        
+        int steps = int(40.0 / tau + 0.5);
+        for (int i = 0; i < steps; ++i) {
+            stepper->doStep(tau, y);
+            f << (i+1)*tau << " " << y(0) << " " << y(1) << "\n";
+        }
+        std::cout << name << " t=" << tau << " done\n";
+    };
+
+    // 4. Register all solvers
+    // Note: ExplicitEuler was causing an error because it wasn't included at the top.
+    std::vector<std::pair<std::unique_ptr<TimeStepper>, std::string>> methods;
+    methods.push_back({std::make_unique<ExplicitEuler>(rhs), "ExplicitEuler"});
+    methods.push_back({std::make_unique<ImprovedEuler>(rhs), "ImprovedEuler"});
+    methods.push_back({std::make_unique<ImplicitEuler>(rhs), "ImplicitEuler"});
+    methods.push_back({std::make_unique<CrankNicolson>(rhs), "CrankNicolson"});
+
+    // 5. Run simulations for different time steps
+    for (double tau : {0.1, 0.5, 1.5, 3.0}) {
+        // We have to iterate carefully because unique_ptr cannot be copied, only moved.
+        // However, since we stored them in the vector, we can access them by reference.
+        for (auto& p : methods) {
+            // Reset the stepper if necessary (depends on implementation, usually safe for simple steppers)
+            run(p.first, p.second, tau);
+        }
+    }
+
+    std::cout << "\nALL DONE! Results in results/ folder\n";
+}
\ No newline at end of file
diff --git a/demos/.ipynb_checkpoints/test_ode-checkpoint.cpp b/demos/.ipynb_checkpoints/test_ode-checkpoint.cpp
new file mode 100644
index 000000000..a5de1841b
--- /dev/null
+++ b/demos/.ipynb_checkpoints/test_ode-checkpoint.cpp
@@ -0,0 +1,72 @@
+// demos/test_ode.cpp
+#include <iostream>
+#include <fstream>
+#include <memory>
+
+#include "mass_spring.hpp"   // implement the MassSpring NonlinearFunction (see below)
+#include "timestepper.hpp"   // include the file we modified/added
+
+int main()
+{
+  double m = 1.0, k = 1.0;
+  double tend = 4*M_PI;
+  int steps = 1000;   // try different time-steps to see behavior
+  double tau = tend / double(steps);
+
+  // initial y = [position, velocity]
+  Vector<> y0 = { 1.0, 0.0 };
+
+  // create rhs
+  std::shared_ptr<NonlinearFunction> rhs = std::make_shared<MassSpring>(m, k);
+
+  // explicit Euler
+  {
+    ExplicitEuler ee(rhs);
+    Vector<> y = y0;
+    std::ofstream f("mass_explicit.csv");
+    f << "t,x,v\n";
+    f << 0.0 << "," << y(0) << "," << y(1) << "\n";
+    for (int i = 0; i < steps; ++i)
+    {
+      ee.doStep(tau, y);
+      f << (i+1)*tau << "," << y(0) << "," << y(1) << "\n";
+    }
+    f.close();
+    std::cout << "Wrote mass_explicit.csv\n";
+  }
+
+  // improved Euler
+  {
+    ImprovedEuler ie(rhs);
+    Vector<> y = y0;
+    std::ofstream f("mass_improved.csv");
+    f << "t,x,v\n";
+    f << 0.0 << "," << y(0) << "," << y(1) << "\n";
+    for (int i = 0; i < steps; ++i)
+    {
+      ie.doStep(tau, y);
+      f << (i+1)*tau << "," << y(0) << "," << y(1) << "\n";
+    }
+    f.close();
+    std::cout << "Wrote mass_improved.csv\n";
+  }
+
+  // crank-nicolson (picard)
+  {
+    CrankNicolson cn(rhs, 50, 1e-12);
+    Vector<> y = y0;
+    std::ofstream f("mass_crank.csv");
+    f << "t,x,v\n";
+    f << 0.0 << "," << y(0) << "," << y(1) << "\n";
+    for (int i = 0; i < steps; ++i)
+    {
+      cn.doStep(tau, y);
+      f << (i+1)*tau << "," << y(0) << "," << y(1) << "\n";
+    }
+    f.close();
+    std::cout << "Wrote mass_crank.csv\n";
+  }
+
+  std::cout << "Done.\n";
+  return 0;
+}
diff --git a/demos/compare_all.cpp b/demos/compare_all.cpp
new file mode 100644
index 000000000..e647050a1
--- /dev/null
+++ b/demos/compare_all.cpp
@@ -0,0 +1,68 @@
+#include "timestepper.hpp"
+#include "mass_spring_function.hpp"
+#include "ExplicitEuler.hpp"   // <--- ADDED THIS (was missing in your original)
+#include "ImprovedEuler.hpp"
+#include "ImplicitEuler.hpp"
+#include "CrankNicolson.hpp"
+#include <memory>
+#include <vector>
+#include <fstream>
+#include <iostream>
+#include <iomanip>
+#include <string>              // <--- ADDED for std::to_string
+
+// IMPORTANT: If your classes (Vector, MassSpring, etc.) are in a namespace, 
+// you must uncomment the line below. Check your header files to see if they use one.
+// using namespace asc_ode; 
+
+int main() {
+    // 1. Setup the problem (Mass Spring System)
+    auto rhs = std::make_shared<MassSpring>(1.0, 1.0);
+    
+    // 2. Initial Condition
+    Vector<> y0{1.0, 0.0};
+
+    // 3. Define the helper lambda to run simulations
+    auto run = [&](auto& stepper, const std::string& name, double tau) {
+        Vector<> y = y0;
+        
+        // Construct filename (ensure "results" folder exists!)
+        std::string filename = "results/" + name + "_tau" + std::to_string(tau) + ".txt";
+        std::ofstream f(filename);
+        
+        if (!f.is_open()) {
+            std::cerr << "Error: Could not open file " << filename << ". Did you create the 'results' folder?\n";
+            return;
+        }
+
+        f << std::fixed << std::setprecision(10);
+        f << "0 " << y(0) << " " << y(1) << "\n";
+        
+        int steps = int(40.0 / tau + 0.5);
+        for (int i = 0; i < steps; ++i) {
+            stepper->doStep(tau, y);
+            f << (i+1)*tau << " " << y(0) << " " << y(1) << "\n";
+        }
+        std::cout << name << " t=" << tau << " done\n";
+    };
+
+    // 4. Register all solvers
+    // Note: ExplicitEuler was causing an error because it wasn't included at the top.
+    std::vector<std::pair<std::unique_ptr<TimeStepper>, std::string>> methods;
+    methods.push_back({std::make_unique<ExplicitEuler>(rhs), "ExplicitEuler"});
+    methods.push_back({std::make_unique<ImprovedEuler>(rhs), "ImprovedEuler"});
+    methods.push_back({std::make_unique<ImplicitEuler>(rhs), "ImplicitEuler"});
+    methods.push_back({std::make_unique<CrankNicolson>(rhs), "CrankNicolson"});
+
+    // 5. Run simulations for different time steps
+    for (double tau : {0.1, 0.5, 1.5, 3.0}) {
+        // We have to iterate carefully because unique_ptr cannot be copied, only moved.
+        // However, since we stored them in the vector, we can access them by reference.
+        for (auto& p : methods) {
+            // Reset the stepper if necessary (depends on implementation, usually safe for simple steppers)
+            run(p.first, p.second, tau);
+        }
+    }
+
+    std::cout << "\nALL DONE! Results in results/ folder\n";
+}
\ No newline at end of file
diff --git a/demos/test_ode.cpp b/demos/test_ode.cpp
new file mode 100644
index 000000000..a5de1841b
--- /dev/null
+++ b/demos/test_ode.cpp
@@ -0,0 +1,72 @@
+// demos/test_ode.cpp
+#include <iostream>
+#include <fstream>
+#include <memory>
+
+#include "mass_spring.hpp"   // implement the MassSpring NonlinearFunction (see below)
+#include "timestepper.hpp"   // include the file we modified/added
+
+int main()
+{
+  double m = 1.0, k = 1.0;
+  double tend = 4*M_PI;
+  int steps = 1000;   // try different time-steps to see behavior
+  double tau = tend / double(steps);
+
+  // initial y = [position, velocity]
+  Vector<> y0 = { 1.0, 0.0 };
+
+  // create rhs
+  std::shared_ptr<NonlinearFunction> rhs = std::make_shared<MassSpring>(m, k);
+
+  // explicit Euler
+  {
+    ExplicitEuler ee(rhs);
+    Vector<> y = y0;
+    std::ofstream f("mass_explicit.csv");
+    f << "t,x,v\n";
+    f << 0.0 << "," << y(0) << "," << y(1) << "\n";
+    for (int i = 0; i < steps; ++i)
+    {
+      ee.doStep(tau, y);
+      f << (i+1)*tau << "," << y(0) << "," << y(1) << "\n";
+    }
+    f.close();
+    std::cout << "Wrote mass_explicit.csv\n";
+  }
+
+  // improved Euler
+  {
+    ImprovedEuler ie(rhs);
+    Vector<> y = y0;
+    std::ofstream f("mass_improved.csv");
+    f << "t,x,v\n";
+    f << 0.0 << "," << y(0) << "," << y(1) << "\n";
+    for (int i = 0; i < steps; ++i)
+    {
+      ie.doStep(tau, y);
+      f << (i+1)*tau << "," << y(0) << "," << y(1) << "\n";
+    }
+    f.close();
+    std::cout << "Wrote mass_improved.csv\n";
+  }
+
+  // crank-nicolson (picard)
+  {
+    CrankNicolson cn(rhs, 50, 1e-12);
+    Vector<> y = y0;
+    std::ofstream f("mass_crank.csv");
+    f << "t,x,v\n";
+    f << 0.0 << "," << y(0) << "," << y(1) << "\n";
+    for (int i = 0; i < steps; ++i)
+    {
+      cn.doStep(tau, y);
+      f << (i+1)*tau << "," << y(0) << "," << y(1) << "\n";
+    }
+    f.close();
+    std::cout << "Wrote mass_crank.csv\n";
+  }
+
+  std::cout << "Done.\n";
+  return 0;
+}
diff --git a/docs/ASC_Logo_transparent_300ppi_RGB.png b/docs/ASC_Logo_transparent_300ppi_RGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..bd838934c80e469cb958718c2b026138c3d39d60
GIT binary patch
literal 82368
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

literal 0
HcmV?d00001

diff --git a/docs/_config.yml b/docs/_config.yml
new file mode 100644
index 000000000..d919df517
--- /dev/null
+++ b/docs/_config.yml
@@ -0,0 +1,57 @@
+# Book settings
+# Learn more at https://jupyterbook.org/customize/config.html
+
+title: ASC-ODE
+author: Joe Smith
+logo: ASC_Logo_transparent_300ppi_RGB.png
+copyright : "2025"  # Copyright year to be placed in the footer
+
+
+# Force re-execution of notebooks on each build.
+# See https://jupyterbook.org/content/execute.html
+execute:
+  execute_notebooks: force
+  timeout: 300
+
+# Define the name of the latex output file for PDF builds
+latex:
+  latex_documents:
+    targetname: book.tex
+
+# Add a bibtex file so that we can create citations
+bibtex_bibfiles:
+  - references.bib
+
+# Information about where the book exists on the web
+repository:
+  url: https://github.com/JSchoeberl/IntroSC.git
+#  url: https://github.com/executablebooks/jupyter-book  # Online location of your book
+#  path_to_book: docs  # Optional path to your book, relative to the repository root
+#  branch: master  # Which branch of the repository should be used when creating links (optional)
+
+# Add GitHub buttons to your book
+# See https://jupyterbook.org/customize/config.html#add-a-link-to-your-repository
+html:
+  use_issues_button: false
+  use_repository_button: true
+
+
+# parse:
+#  myst_enable_extensions:
+#    # don't forget to list any other extensions you want enabled,
+#    # including those that are enabled by default! See here: https://jupyterbook.org/en/stable/customize/config.html
+#    - html_image
+
+
+
+parse:
+  myst_enable_extensions:
+#    # don't forget to list any other extensions you want enabled,
+#    # including those that are enabled by default! See here: https://jupyterbook.org/en/stable/customize/config.html
+    - html_image
+    - dollarmath
+    - amsmath
+    - linkify
+    - colon_fence
+  myst_dmath_double_inline: true
+  
\ No newline at end of file
diff --git a/docs/_toc.yml b/docs/_toc.yml
new file mode 100644
index 000000000..a11c4d6ac
--- /dev/null
+++ b/docs/_toc.yml
@@ -0,0 +1,11 @@
+# Table of contents
+# Learn more at https://jupyterbook.org/customize/toc.html
+
+format: jb-book
+root: intro.md
+
+
+
+
+
+
diff --git a/docs/intro.md b/docs/intro.md
new file mode 100644
index 000000000..ae16b2eb1
--- /dev/null
+++ b/docs/intro.md
@@ -0,0 +1,66 @@
+# Welcome to ASC-ODE's documentation!
+
+
+ASC-ODE is is a C++ library for solving ordinary differential equations (ODEs).
+The equation is defined by the right hand side function.
+ASC-ODE provides various time-steppers which may be used for odes with right hand sides
+given by a function object.
+
+A small demo for solving a mass-spring model as first order ODE
+\begin{eqnarray*}
+y_0^\prime & = & y_1 \\
+y_1^\prime & = & -\frac{k}{m} y_0
+\end{eqnarray*}
+is here:
+
+```cpp
+double tend = 4*M_PI;
+int steps = 100;
+double tau = tend/steps;
+
+Vector<> y = { 1, 0 };  // initial conditions
+shared_ptr<NonlinearFunction> rhs = std::make_shared<MassSpring>(mass, stiffness);
+  
+ExplicitEuler stepper(rhs);
+
+std::cout << 0.0 << "  " << y(0) << " " << y(1) << std::endl;
+for (int i = 0; i < steps; i++)
+  {
+     stepper.DoStep(tau, y);
+     std::cout << (i+1) * tau << "  " << y(0) << " " << y(1) << std::endl;
+  }
+```    
+
+The result of this simulation in phase space is shown here:
+
+```{image} pictures/massspring_phase.png
+:width: 40%
+:align: center
+```
+
+
+
+
+## Installation
+
+install XXX-odesolver it via git-clone:
+
+    git clone https://github.com/my-github-clone/my-ode-solver.git
+
+
+To configure and build some tests do
+
+    cd my-ode-solver
+    mkdir build
+    cd build
+    cmake ..
+    make
+    
+
+## Available time-stepping methods are
+...
+
+
+
+
+   
diff --git a/docs/pictures/massspring_phase.png b/docs/pictures/massspring_phase.png
new file mode 100644
index 0000000000000000000000000000000000000000..8947960e7d1b93ae4c1270ce9dec79626c3e1241
GIT binary patch
literal 41937
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
HY!UE3tm{*%

literal 0
HcmV?d00001

diff --git a/ex20_solution/.ipynb_checkpoints/CMakeLists-checkpoint.txt b/ex20_solution/.ipynb_checkpoints/CMakeLists-checkpoint.txt
new file mode 100644
index 000000000..af4071447
--- /dev/null
+++ b/ex20_solution/.ipynb_checkpoints/CMakeLists-checkpoint.txt
@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.10)
+project(ex20_mass_spring_demo LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_executable(demo_mass_spring
+  demo_mass_spring.cpp
+  mass_spring.cpp
+  mss_function.cpp
+)
+
+target_include_directories(demo_mass_spring PRIVATE
+  ${CMAKE_CURRENT_SOURCE_DIR}
+)
diff --git a/ex20_solution/.ipynb_checkpoints/ReadME-checkpoint.md b/ex20_solution/.ipynb_checkpoints/ReadME-checkpoint.md
new file mode 100644
index 000000000..a5b6724e8
--- /dev/null
+++ b/ex20_solution/.ipynb_checkpoints/ReadME-checkpoint.md
@@ -0,0 +1,12 @@
+This project implements a **constrained mass–spring system** with the following features:
+
+- Multiple point masses in 2D
+- Distance constraints between pairs of masses
+- Correct computation of:
+  - Positions `q`
+  - Velocities `v`
+  - Accelerations `q_dd`
+  - Lagrange multipliers `λ`
+- Augmented constraint solver using a symmetric saddle-point system
+- Exact Jacobian `df/dx` for the constrained dynamics
+- Demonstration program simulating a 3-mass chain
\ No newline at end of file
diff --git a/ex20_solution/.ipynb_checkpoints/demo_mass_spring-checkpoint.cpp b/ex20_solution/.ipynb_checkpoints/demo_mass_spring-checkpoint.cpp
new file mode 100644
index 000000000..073259abc
--- /dev/null
+++ b/ex20_solution/.ipynb_checkpoints/demo_mass_spring-checkpoint.cpp
@@ -0,0 +1,66 @@
+#include "mass_spring.hpp"
+#include "mss_function.hpp"
+#include <iostream>
+#include <fstream>
+#include <cmath>
+
+// simple integrator (symplectic explicit) just for demo output
+int main(){
+    // Build a 3-mass chain (like double pendulum with 3 masses)
+    int n_masses = 3;
+    MassSpringSystem sys(n_masses, 2);
+    sys.mass = {1.0, 1.0, 1.0};
+
+    // positions: equilateral triangle for spinning top demo OR chain initial positions
+    // We'll build a chain along x-axis with spacing 1.0 and then also create constraints
+    double spacing = 1.0;
+    VectorD q(sys.dimX()), v(sys.dimX());
+    for(int i=0;i<n_masses;++i){
+        q[i*2 + 0] = i * spacing; // x
+        q[i*2 + 1] = 0.0;         // y
+        v[i*2 + 0] = 0.0;
+        v[i*2 + 1] = 0.0;
+    }
+
+    // add distance constraints between consecutive masses (chain)
+    sys.addDistanceConstraint(0,1, spacing);
+    sys.addDistanceConstraint(1,2, spacing);
+
+    // set initial velocities: small upward velocity on middle mass to excite
+    v[1*2 + 1] = 0.5;
+
+    // Time stepping
+    double dt = 0.01;
+    double T = 4.0;
+    std::ofstream ofs("mass_spring_output.txt");
+    ofs << "t ";
+    for(int i=0;i<n_masses;++i) ofs << "x" << i << " y" << i << " ";
+    for(int i=0;i<n_masses;++i) ofs << "vx" << i << " vy" << i << " ";
+    ofs << "\n";
+
+    int steps = int(T/dt);
+    for(int s=0;s<=steps;++s){
+        double t = s * dt;
+        ofs << t << " ";
+        for(int i=0;i<n_masses;++i){
+            ofs << q[i*2 + 0] << " " << q[i*2 + 1] << " ";
+        }
+        for(int i=0;i<n_masses;++i){
+            ofs << v[i*2 + 0] << " " << v[i*2 + 1] << " ";
+        }
+        ofs << "\n";
+
+        // compute acceleration via augmented constraint solver
+        VectorD qdd, lambda;
+        sys.computeAccelerationsConstraint(q, v, qdd, lambda, true, 10.0); // with small stabilization
+
+        // explicit symplectic Euler (simple)
+        for(int i=0;i<sys.dimX();++i){
+            v[i] += qdd[i] * dt;
+            q[i] += v[i] * dt;
+        }
+    }
+    ofs.close();
+    std::cout<<"Written mass_spring_output.txt\n";
+    return 0;
+}
diff --git a/ex20_solution/.ipynb_checkpoints/linear_solve-checkpoint.hpp b/ex20_solution/.ipynb_checkpoints/linear_solve-checkpoint.hpp
new file mode 100644
index 000000000..231cfa787
--- /dev/null
+++ b/ex20_solution/.ipynb_checkpoints/linear_solve-checkpoint.hpp
@@ -0,0 +1,49 @@
+#pragma once
+#include "matrix.hpp"
+#include "vector.hpp"
+#include <cmath>
+#include <algorithm>
+#include <stdexcept>
+
+// Simple dense Gaussian elimination with partial pivoting.
+
+inline bool solveLinearSystem(const Matrix& A_in, const VectorD& b_in, VectorD& x_out) {
+    int N = A_in.rows();
+    if(A_in.cols() != N) return false;
+    if(b_in.size() != N) return false;
+    Matrix A = A_in; // copy
+    VectorD b = b_in; // copy
+    x_out.resize(N);
+
+    // make sure b has contiguous data
+    for(int k=0;k<N;++k){
+        // pivot
+        int piv = k;
+        double maxv = std::fabs(A(k,k));
+        for(int i=k+1;i<N;++i){
+            double v = std::fabs(A(i,k));
+            if(v > maxv){ maxv = v; piv = i; }
+        }
+        if(maxv < 1e-15) return false;
+        if(piv != k){
+            for(int j=k;j<N;++j) std::swap(A(k,j), A(piv,j));
+            std::swap(b[k], b[piv]);
+        }
+        double akk = A(k,k);
+        // normalize row k
+        for(int j=k+1;j<N;++j) A(k,j) /= akk;
+        b[k] /= akk;
+        for(int i=k+1;i<N;++i){
+            double factor = A(i,k);
+            for(int j=k+1;j<N;++j) A(i,j) -= factor * A(k,j);
+            b[i] -= factor * b[k];
+        }
+    }
+    // back substitution
+    for(int i=N-1;i>=0;--i){
+        double s = b[i];
+        for(int j=i+1;j<N;++j) s -= A(i,j) * x_out[j];
+        x_out[i] = s; // diagonal normalized
+    }
+    return true;
+}
diff --git a/ex20_solution/.ipynb_checkpoints/mass_spring-checkpoint.hpp b/ex20_solution/.ipynb_checkpoints/mass_spring-checkpoint.hpp
new file mode 100644
index 000000000..2b9a18772
--- /dev/null
+++ b/ex20_solution/.ipynb_checkpoints/mass_spring-checkpoint.hpp
@@ -0,0 +1,230 @@
+#pragma once
+// mass_spring.hpp
+
+
+#include <vector>
+#include <cmath>
+#include <stdexcept>
+#include <cassert>
+
+#ifndef VECTOR_D_DEFINED_BY_REPO
+// If your repo already has VectorD, include its header above and undef this block.
+using VectorD = std::vector<double>;
+#endif
+
+struct DistanceConstraint {
+    int i, j;      // mass indices
+    double rest;   // rest length
+    DistanceConstraint(int ii = 0, int jj = 0, double r = 0.0) : i(ii), j(jj), rest(r) {}
+};
+
+class MassSpringSystem {
+public:
+    // n_masses : number of point masses
+    // dim : spatial dimension (2 for the exercise)
+    MassSpringSystem(int n_masses = 0, int dim = 2)
+      : n(n_masses), dim(dim), mass(n_masses, 1.0)
+    {
+        if (n < 0) throw std::runtime_error("n_masses must be >= 0");
+    }
+
+    // public data (simple)
+    std::vector<double> mass;                 // length n
+    std::vector<DistanceConstraint> cons;     // distance constraints
+
+    int dimX() const { return n * dim; }
+    int numMasses() const { return n; }
+    int spaceDim() const { return dim; }
+
+    // add constraint between mass i and j with rest length L
+    void addDistanceConstraint(int i, int j, double L) {
+        if (i < 0 || j < 0 || i >= n || j >= n) throw std::runtime_error("constraint indices out of range");
+        cons.emplace_back(i, j, L);
+    }
+
+    // Compute accelerations qdd and Lagrange multipliers lambda for distance constraints.
+    // q, v are vectors of length dimX(). qdd and lambda are output (resized inside).
+    // stabilization: if true use Baumgarte-like stabilization, stab_k is strength.
+    void computeAccelerationsConstraint(const VectorD& q, const VectorD& v,
+                                         VectorD& qdd, VectorD& lambda,
+                                         bool stabilization = true, double stab_k = 50.0) const
+    {
+        if ((int)q.size() != dimX() || (int)v.size() != dimX()) {
+            throw std::runtime_error("q or v size mismatch");
+        }
+
+        // zero right-hand acceleration
+        qdd.assign(dimX(), 0.0);
+
+        int m = (int)cons.size();
+        if (m == 0) {
+            // no constraints -> zero acceleration (no internal forces implemented)
+            return;
+        }
+
+        // Build J (m x dimX), g (m), Jv (m)
+        // We'll compute A = J * M^{-1} * J^T (m x m) and rhs = -J * M^{-1} * f - Jdot*v - alpha*g - beta*Jv
+        // Here f = 0 (no springs/forces implemented). We use g = |ri - rj|^2 - rest^2.
+        // J rows: for constraint k between i and j: derivative of g w.r.t q is:
+        //   dg/dqi = 2*(qi - qj), dg/dqj = -2*(qi - qj)
+        // So J_{k, idx} = 2 * (qi - qj) component.
+
+        // Precompute inverse mass diagonal
+        VectorD invM(n);
+        for (int i = 0; i < n; ++i) {
+            double mi = mass[i];
+            if (mi <= 0.0) throw std::runtime_error("mass must be > 0");
+            invM[i] = 1.0 / mi;
+        }
+
+        // Compute g and Jv and store small data for each constraint
+        std::vector<double> g(m, 0.0);
+        std::vector<double> Jv(m, 0.0);
+        // For building A we need J*M^{-1}*J^T. We'll compute A_{kl} by summing contributions explicitly.
+        std::vector< std::vector<double> > A(m, std::vector<double>(m, 0.0));
+
+        // store per-constraint vector d = qi - qj (length dim)
+        std::vector< std::vector<double> > dvec(m, std::vector<double>(dim, 0.0));
+
+        for (int k = 0; k < m; ++k) {
+            int i = cons[k].i;
+            int j = cons[k].j;
+            double rest = cons[k].rest;
+
+            // d = qi - qj
+            for (int dd = 0; dd < dim; ++dd) {
+                double qi = q[i*dim + dd];
+                double qj = q[j*dim + dd];
+                dvec[k][dd] = qi - qj;
+            }
+            // g = |d|^2 - rest^2
+            double dotd = 0.0;
+            for (int dd=0; dd<dim; ++dd) dotd += dvec[k][dd] * dvec[k][dd];
+            g[k] = dotd - rest * rest;
+
+            // Jv = 2 * d · (vi - vj)
+            double dotdv = 0.0;
+            for (int dd=0; dd<dim; ++dd) {
+                double vi = v[i*dim + dd];
+                double vj = v[j*dim + dd];
+                dotdv += dvec[k][dd] * (vi - vj);
+            }
+            Jv[k] = 2.0 * dotdv;
+        }
+
+        // Build A matrix (m x m): A_{kl} = (J_k) M^{-1} (J_l)^T
+        // Note J_k has components 2*d_k at indices of mass i, and -2*d_k at indices of mass j.
+        // So contribution from mass p to A_{kl} = (component at p in J_k)*(component at p in J_l) * invM[p]
+        for (int k = 0; k < m; ++k) {
+            for (int l = 0; l < m; ++l) {
+                double sum = 0.0;
+                int ik = cons[k].i, jk = cons[k].j;
+                int il = cons[l].i, jl = cons[l].j;
+
+                // contributions from mass ik
+                for (int dd=0; dd<dim; ++dd) {
+                    double Jk_ik = 2.0 * dvec[k][dd];
+                    double Jl_ik = 0.0;
+                    if (il == ik) Jl_ik += 2.0 * dvec[l][dd];
+                    if (jl == ik) Jl_ik += -2.0 * dvec[l][dd];
+                    sum += Jk_ik * Jl_ik * invM[ik];
+                }
+                // contributions from mass jk
+                for (int dd=0; dd<dim; ++dd) {
+                    double Jk_jk = -2.0 * dvec[k][dd];
+                    double Jl_jk = 0.0;
+                    if (il == jk) Jl_jk += 2.0 * dvec[l][dd];
+                    if (jl == jk) Jl_jk += -2.0 * dvec[l][dd];
+                    sum += Jk_jk * Jl_jk * invM[jk];
+                }
+
+                A[k][l] = sum;
+            }
+        }
+
+        // Build rhs: rhs_k = - Jdot*v - alpha*g - beta*Jv
+        // choose simple stabilization coefficients
+        double alpha = stabilization ? stab_k : 0.0;
+        double beta  = stabilization ? (stab_k * 0.2) : 0.0;
+
+        std::vector<double> rhs(m, 0.0);
+        for (int k = 0; k < m; ++k) {
+            // Jdot*v is approximated by derivative of Jv; for our g formulation Jv is 2*d·(vi-vj)
+            // and Jdot*v approx = 2*(vi-vj)·(vi-vj) + 2*d·(ai - aj) -> we don't have a yet, so we drop second part.
+            // We use: rhs = - Jv_dot - alpha*g - beta*Jv. We approximate Jv_dot ~= 2*(vi-vj)·(vi-vj)
+            int i = cons[k].i, j = cons[k].j;
+            double approx_Jv_dot = 0.0;
+            for (int dd=0; dd<dim; ++dd) {
+                double dv = v[i*dim+dd] - v[j*dim+dd];
+                approx_Jv_dot += dv * dv * 2.0; // scaled
+            }
+            rhs[k] = - approx_Jv_dot - alpha * g[k] - beta * Jv[k];
+        }
+
+        // Solve A * lambda = rhs (m x m). Use naive Gaussian elimination (m is small typically).
+        lambda.assign(m, 0.0);
+        // If A nearly singular, add small regularization
+        double reg = 1e-10;
+        for (int i=0;i<m;i++) A[i][i] += reg;
+
+        // Gaussian elimination (in-place)
+        std::vector<std::vector<double>> B = A; // copy
+        std::vector<double> bb = rhs;
+        // forward elimination
+        for (int i = 0; i < m; ++i) {
+            // pivot
+            int piv = i;
+            double pivabs = std::fabs(B[i][i]);
+            for (int r = i+1; r < m; ++r) {
+                if (std::fabs(B[r][i]) > pivabs) { piv = r; pivabs = std::fabs(B[r][i]); }
+            }
+            if (pivabs < 1e-14) {
+                // singular-ish -> set lambda zero (fallback)
+                lambda.assign(m, 0.0);
+                // compute qdd = - M^{-1} J^T lambda = 0 -> already zero
+                return;
+            }
+            if (piv != i) {
+                std::swap(B[i], B[piv]);
+                std::swap(bb[i], bb[piv]);
+            }
+            double diag = B[i][i];
+            for (int c = i; c < m; ++c) B[i][c] /= diag;
+            bb[i] /= diag;
+            for (int r = i+1; r < m; ++r) {
+                double fac = B[r][i];
+                if (fac == 0.0) continue;
+                for (int c = i; c < m; ++c) B[r][c] -= fac * B[i][c];
+                bb[r] -= fac * bb[i];
+            }
+        }
+        // back substitution
+        for (int i = m-1; i >= 0; --i) {
+            double sum = bb[i];
+            for (int c = i+1; c < m; ++c) sum -= B[i][c] * lambda[c];
+            lambda[i] = sum; // since B[i][i] normalized to 1
+        }
+
+        // compute accelerations qdd = M^{-1} * ( - J^T * lambda )
+        // initialize qdd zero
+        qdd.assign(dimX(), 0.0);
+        for (int k = 0; k < m; ++k) {
+            int i = cons[k].i;
+            int j = cons[k].j;
+            double lam = lambda[k];
+            // J^T contributes +2*d * lam to mass i, and -2*d * lam to mass j (because J row had +2d for i and -2d for j)
+            for (int dd=0; dd<dim; ++dd) {
+                double contrib_i = 2.0 * dvec[k][dd] * lam;
+                double contrib_j = -2.0 * dvec[k][dd] * lam;
+                qdd[i*dim + dd] += contrib_i * invM[i]; // since we multiply by M^{-1} here
+                qdd[j*dim + dd] += contrib_j * invM[j];
+            }
+        }
+
+        // Note: this qdd contains only constraint-induced accelerations (no external forces or springs).
+    }
+
+private:
+    int n;   // number of masses
+    int dim; // spatial dimension
+};
diff --git a/ex20_solution/.ipynb_checkpoints/matrix-checkpoint.hpp b/ex20_solution/.ipynb_checkpoints/matrix-checkpoint.hpp
new file mode 100644
index 000000000..cbc19f7f8
--- /dev/null
+++ b/ex20_solution/.ipynb_checkpoints/matrix-checkpoint.hpp
@@ -0,0 +1,26 @@
+#pragma once
+#include <vector>
+#include <cassert>
+#include <cmath>
+#include <iomanip>
+#include <iostream>
+
+struct Matrix {
+    int r=0, c=0;
+    std::vector<double> d;
+    Matrix() = default;
+    Matrix(int rr, int cc) { resize(rr,cc); }
+    void resize(int rr, int cc) { r=rr; c=cc; d.assign(r*c, 0.0); }
+    void zero() { std::fill(d.begin(), d.end(), 0.0); }
+    double& operator()(int i,int j){ assert(i>=0 && i<r && j>=0 && j<c); return d[i*c + j]; }
+    double operator()(int i,int j) const { assert(i>=0 && i<r && j>=0 && j<c); return d[i*c + j]; }
+    int rows() const { return r; }
+    int cols() const { return c; }
+    void print(const char* name=nullptr) const {
+        if(name) std::cout<<name<<":\n";
+        for(int i=0;i<r;++i){
+            for(int j=0;j<c;++j) std::cout<<std::setw(12)<<operator()(i,j)<<" ";
+            std::cout<<"\n";
+        }
+    }
+};
diff --git a/ex20_solution/.ipynb_checkpoints/mss_function-checkpoint.cpp b/ex20_solution/.ipynb_checkpoints/mss_function-checkpoint.cpp
new file mode 100644
index 000000000..c9a754308
--- /dev/null
+++ b/ex20_solution/.ipynb_checkpoints/mss_function-checkpoint.cpp
@@ -0,0 +1,212 @@
+// mss_function.cpp  
+#include "mss_function.hpp"
+#include "linear_solve.hpp"
+#include <stdexcept>
+#include <cmath>
+
+// helper to split x = [q; v]
+static void splitState(const VectorD& x, int n_q, VectorD& q, VectorD& v) {
+    q.assign(n_q, 0.0);
+    v.assign(n_q, 0.0);
+    for(int i=0;i<n_q;++i){ q[i]=x[i]; v[i]=x[n_q+i]; }
+}
+
+void MSS_Function::computeRHS(const VectorD& x, VectorD& fx) const {
+    int n_q = sys.dimX();
+    VectorD q, v;
+    splitState(x, n_q, q, v);
+
+    VectorD qdd, lambda;
+    sys.computeAccelerationsConstraint(q, v, qdd, lambda);
+
+    fx.resize(2*n_q);
+    // dx/dt = [ v ; qdd ]
+    for(int i=0;i<n_q;++i){ fx[i] = v[i]; fx[n_q + i] = qdd[i]; }
+}
+
+
+// -----------------------------------------------------------------------------
+// Exact Jacobian via loop-and-solve:
+// df/dx = [ 0    I
+//           d(qdd)/dq  d(qdd)/dv ]
+//
+// We compute qdd by solving augmented system A_aug * x_aug = b_aug where
+// x_aug = [ qdd (n_q) ; lambda (nc) ]
+// A_aug = [ M     G^T
+//           G     0   ]
+// b_aug = [ F
+//          -Gdotv ]
+// -----------------------------------------------------------------------------
+void MSS_Function::computeJacobian(const VectorD& x, Matrix& J) const {
+    int n_q = sys.dimX();
+    int stateN = 2 * n_q;
+    J.resize(stateN, stateN); J.zero();
+
+    // top-right block = I
+    for(int i=0;i<n_q;++i) J(i, n_q + i) = 1.0;
+
+    // split state
+    VectorD q, v;
+    splitState(x, n_q, q, v);
+
+    // number of constraints
+    int nc = (int)sys.cons.size();
+
+    // Build mass matrix M (n_q x n_q) as diagonal
+    Matrix M(n_q, n_q); M.zero();
+    for(int mi = 0; mi < sys.numMasses(); ++mi){
+        double mval = sys.mass[mi];
+        if (mval <= 0.0) throw std::runtime_error("mass must be > 0");
+        for(int dd=0; dd<sys.spaceDim(); ++dd){
+            int idx = mi*sys.spaceDim() + dd;
+            M(idx, idx) = mval;
+        }
+    }
+
+    // Build G (nc x n_q) and Gdotv (nc) and phi (constraint gap)
+    Matrix G(nc, n_q); G.zero();
+    VectorD Gdotv(nc, 0.0);
+    VectorD phi(nc, 0.0);
+
+    // Precompute dvec per constraint (d = qi - qj)
+    std::vector<std::vector<double>> dvec(nc, std::vector<double>(sys.spaceDim(), 0.0));
+    for(int r=0;r<nc;++r){
+        int i = sys.cons[r].i;
+        int j = sys.cons[r].j;
+        double rest = sys.cons[r].rest;
+        double dotd = 0.0;
+        for(int dd=0; dd<sys.spaceDim(); ++dd){
+            double di = q[i*sys.spaceDim()+dd];
+            double dj = q[j*sys.spaceDim()+dd];
+            double dcomp = di - dj;
+            dvec[r][dd] = dcomp;
+            dotd += dcomp * dcomp;
+            // set G at the coordinate positions
+            int idx_i = i*sys.spaceDim() + dd;
+            int idx_j = j*sys.spaceDim() + dd;
+            // Following the constraint formulation used in computeAccelerationsConstraint:
+            // G row stores 2*d at i-coordinates and -2*d at j-coordinates
+            G(r, idx_i) = 2.0 * dcomp;
+            G(r, idx_j) = -2.0 * dcomp;
+        }
+        phi[r] = dotd - rest*rest;
+        // Gdotv = 2 * d · (v_i - v_j)
+        double dotdv = 0.0;
+        for(int dd=0; dd<sys.spaceDim(); ++dd){
+            double vi = v[i*sys.spaceDim()+dd];
+            double vj = v[j*sys.spaceDim()+dd];
+            dotdv += dvec[r][dd] * (vi - vj);
+        }
+        Gdotv[r] = 2.0 * dotdv;
+    }
+
+    // Build b_aug: top F (no internal forces in simple model -> zero), bottom = -Gdotv
+    int Naug = n_q + nc;
+    VectorD b(Naug, 0.0);
+    // top is F (zero)
+    for(int idx=0; idx<n_q; ++idx) b[idx] = 0.0;
+    for(int r=0;r<nc;++r) b[n_q + r] = - Gdotv[r];
+
+    // Build augmented matrix A_aug (Naug x Naug)
+    Matrix A(Naug, Naug); A.zero();
+    // top-left = M
+    for(int i=0;i<n_q;++i) for(int j=0;j<n_q;++j) A(i,j) = M(i,j);
+    // top-right (i, n_q + r) = G(r,i)
+    for(int r=0;r<nc;++r) for(int i=0;i<n_q;++i) A(i, n_q + r) = G(r, i);
+    // bottom-left (n_q + r, i) = G(r,i)
+    for(int r=0;r<nc;++r) for(int i=0;i<n_q;++i) A(n_q + r, i) = G(r, i);
+    // bottom-right zero (already zero)
+
+    // Solve base augmented system A * xaug = b
+    VectorD xaug;
+    if (!solveLinearSystem(A, b, xaug)) throw std::runtime_error("Base augmented solve failed in Jacobian");
+
+    // Now compute derivative columns
+    VectorD rhs(Naug), y(Naug);
+
+    // Precompute xaug components: first n_q are qdd_base, rest are lambda_base (not used directly here)
+    // Loop over q-derivatives (d/dq_k)
+    for(int k=0;k<n_q;++k){
+        // db/dq_k : top part dF/dq_k = 0 (no internal springs here)
+        // bottom part d(-Gdotv)/dq_k = - d(Gdotv)/dq_k
+        // recall Gdotv[r] = 2 * dvec[r] · (v_i - v_j)
+        // derivative wrt a coordinate q_k affects dvec entries:
+        // if k corresponds to coordinate dd of mass i -> d(dvec[r][dd])/dq_k = 1 (if that constraint uses i)
+        // if k is coordinate dd of mass j -> derivative is -1
+        for(int i=0;i<Naug;++i) rhs[i] = 0.0;
+
+        for(int r=0;r<nc;++r){
+            const auto &C = sys.cons[r];
+            int ii = C.i, jj = C.j;
+            for(int dd=0; dd<sys.spaceDim(); ++dd){
+                int idx_i = ii*sys.spaceDim() + dd;
+                int idx_j = jj*sys.spaceDim() + dd;
+                if(k == idx_i){
+                    // d(Gdotv)/dq_k contribution: 2 * (v_i - v_j)[dd]
+                    rhs[n_q + r] -= 2.0 * ( v[ii*sys.spaceDim()+dd] - v[jj*sys.spaceDim()+dd] );
+                } else if(k == idx_j){
+                    // derivative of dvec is -1 -> contribution -2*(v_i - v_j) * (-1) => +2*(v_i - v_j)
+                    rhs[n_q + r] -= 2.0 * ( - (v[ii*sys.spaceDim()+dd] - v[jj*sys.spaceDim()+dd]) );
+                    // simplify: that's +2*(v[ii]-v[jj])? but above sign covers
+                }
+            }
+            // Note: we DID NOT include stabilization derivatives here; if you use Baumgarte terms, add them.
+        }
+
+        // Compute (dA/dq_k) * xaug and subtract: rhs_total = db_dqk - dA_dqk * xaug
+        // dA/dq_k nonzero only in entries where G depends on q (top-right and bottom-left blocks)
+        // For a given constraint r and coordinate c:
+        // dG(r,c)/dq_k = derivative of 2*d_component: equals 2 if c==coord of mass i (same dd) and k==that coord,
+        // equals -2 if c==coord of mass j and k==that coord, else 0.
+        // Implement multiply dA * xaug without building dA.
+
+        VectorD temp(Naug, 0.0); // temp = (dA/dq_k) * xaug
+        for(int r=0;r<nc;++r){
+            const auto &C = sys.cons[r];
+            int ii = C.i, jj = C.j;
+            for(int dd=0; dd<sys.spaceDim(); ++dd){
+                int idx_i = ii*sys.spaceDim() + dd;
+                int idx_j = jj*sys.spaceDim() + dd;
+
+                if(k == idx_i){
+                    // dG(r, idx_i) / dq_k = 2
+                    // contributes to top-row idx_i: (dA)_{idx_i, n_q + r} = 2 -> multiply by xaug[n_q + r]
+                    temp[idx_i] += 2.0 * xaug[n_q + r];
+                    // contributes to bottom-row n_q + r: (dA)_{n_q + r, idx_i} = 2 -> multiply by xaug[idx_i]
+                    temp[n_q + r] += 2.0 * xaug[idx_i];
+                }
+                if(k == idx_j){
+                    // dG(r, idx_j) / dq_k = -2
+                    temp[idx_j] += -2.0 * xaug[n_q + r];
+                    temp[n_q + r] += -2.0 * xaug[idx_j];
+                }
+            }
+        }
+
+        // subtract temp
+        for(int i=0;i<Naug;++i) rhs[i] -= temp[i];
+
+        // solve A * y = rhs
+        if(!solveLinearSystem(A, rhs, y)) throw std::runtime_error("Jacobian column solve failed (dq)");
+        // store accelerations derivative dqdd/dq_k in Jacobian bottom-left block (rows n_q.., col k)
+        for(int i=0;i<n_q;++i) J(n_q + i, k) = y[i];
+    }
+
+    // now derivatives w.r.t. velocities (d/dv_k)
+    for(int k=0;k<n_q;++k){
+        for(int i=0;i<Naug;++i) rhs[i] = 0.0;
+
+        // db/dv_k : top part zero, bottom part = - d(Gdotv)/dv_k
+        // Gdotv[r] = 2 * sum_c (dvec[r,c] * v_c_contribution)
+        // derivative wrt v_k is simply 2 * d_component located at column k (i.e. G(r,k))
+        for(int r=0;r<nc;++r){
+            rhs[n_q + r] -= G(r, k);
+        }
+
+        // dA/dv_k = 0 (G does not depend on v), so no dA term
+        if(!solveLinearSystem(A, rhs, y)) throw std::runtime_error("Jacobian column solve failed (dv)");
+        for(int i=0;i<n_q;++i) J(n_q + i, n_q + k) = y[i];
+    }
+
+    // Top-left is zero already; top-right was set above; full Jacobian ready.
+}
diff --git a/ex20_solution/.ipynb_checkpoints/mss_function-checkpoint.hpp b/ex20_solution/.ipynb_checkpoints/mss_function-checkpoint.hpp
new file mode 100644
index 000000000..28c521d95
--- /dev/null
+++ b/ex20_solution/.ipynb_checkpoints/mss_function-checkpoint.hpp
@@ -0,0 +1,18 @@
+#pragma once
+#include "mass_spring.hpp"
+#include "vector.hpp"
+#include "matrix.hpp"
+
+// MSS_Function provides the RHS f(x) = [v; qdd] and an exact Jacobian
+struct MSS_Function {
+    MassSpringSystem sys;
+
+    MSS_Function() = default;
+    MSS_Function(const MassSpringSystem& s): sys(s) {}
+
+    // compute RHS: x = [q; v] (size 2*nq)
+    void computeRHS(const VectorD& x, VectorD& fx) const;
+
+    // compute exact Jacobian J (size 2*nq x 2*nq)
+    void computeJacobian(const VectorD& x, Matrix& J) const;
+};
diff --git a/ex20_solution/.ipynb_checkpoints/vector-checkpoint.hpp b/ex20_solution/.ipynb_checkpoints/vector-checkpoint.hpp
new file mode 100644
index 000000000..f63035702
--- /dev/null
+++ b/ex20_solution/.ipynb_checkpoints/vector-checkpoint.hpp
@@ -0,0 +1,28 @@
+#pragma once
+#include <vector>
+#include <cassert>
+#include <cmath>
+
+/*
+  Minimal vector class wrapper for matrix operations.
+  BUT we do NOT define VectorD here — the project uses
+  `using VectorD = std::vector<double>` from mass_spring.hpp.
+
+  That is the ONLY VectorD alias in the entire exercise.
+*/
+
+template<typename T>
+struct Vec {
+    std::vector<T> d;
+
+    Vec() {}
+    explicit Vec(size_t n): d(n) {}
+    void resize(size_t n) { d.resize(n); }
+    size_t size() const { return d.size(); }
+
+    T& operator[](size_t i) { return d[i]; }
+    const T& operator[](size_t i) const { return d[i]; }
+
+    void zero() { for(auto& x : d) x = T(0); }
+    void fill(T v) { std::fill(d.begin(), d.end(), v); }
+};
diff --git a/ex20_solution/CMakeLists.txt b/ex20_solution/CMakeLists.txt
new file mode 100644
index 000000000..404b1322b
--- /dev/null
+++ b/ex20_solution/CMakeLists.txt
@@ -0,0 +1,17 @@
+include_directories(${CMAKE_SOURCE_DIR}/ex20_solution)
+
+cmake_minimum_required(VERSION 3.10)
+project(ex20_mass_spring_demo LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_executable(demo_mass_spring
+  demo_mass_spring.cpp
+  mass_spring.cpp
+  mss_function.cpp
+)
+
+target_include_directories(demo_mass_spring PRIVATE
+  ${CMAKE_CURRENT_SOURCE_DIR}
+)
diff --git a/ex20_solution/ReadME.md b/ex20_solution/ReadME.md
new file mode 100644
index 000000000..a5b6724e8
--- /dev/null
+++ b/ex20_solution/ReadME.md
@@ -0,0 +1,12 @@
+This project implements a **constrained mass–spring system** with the following features:
+
+- Multiple point masses in 2D
+- Distance constraints between pairs of masses
+- Correct computation of:
+  - Positions `q`
+  - Velocities `v`
+  - Accelerations `q_dd`
+  - Lagrange multipliers `λ`
+- Augmented constraint solver using a symmetric saddle-point system
+- Exact Jacobian `df/dx` for the constrained dynamics
+- Demonstration program simulating a 3-mass chain
\ No newline at end of file
diff --git a/ex20_solution/build/CMakeCache.txt b/ex20_solution/build/CMakeCache.txt
new file mode 100644
index 000000000..78de945de
--- /dev/null
+++ b/ex20_solution/build/CMakeCache.txt
@@ -0,0 +1,339 @@
+# This is the CMakeCache file.
+# For build in directory: /home/jovyan/ASC-ODE-clean/ex20_solution/build
+# It was generated by CMake: /home/jovyan/.local/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-13
+
+//A wrapper around 'ranlib' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_CXX_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib-13
+
+//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
+
+//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=
+
+//Value Computed by CMake.
+CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles/pkgRedirects
+
+//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/gmake
+
+//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=ex20_mass_spring_demo
+
+//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
+
+//Path to a program.
+CMAKE_TAPI:FILEPATH=CMAKE_TAPI-NOTFOUND
+
+//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
+
+//Value Computed by CMake
+ex20_mass_spring_demo_BINARY_DIR:STATIC=/home/jovyan/ASC-ODE-clean/ex20_solution/build
+
+//Value Computed by CMake
+ex20_mass_spring_demo_IS_TOP_LEVEL:STATIC=ON
+
+//Value Computed by CMake
+ex20_mass_spring_demo_SOURCE_DIR:STATIC=/home/jovyan/ASC-ODE-clean/ex20_solution
+
+
+########################
+# 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/jovyan/ASC-ODE-clean/ex20_solution/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=29
+//Patch version of cmake used to create the current loaded cache
+CMAKE_CACHE_PATCH_VERSION:INTERNAL=4
+//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE
+CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1
+//Path to CMake executable.
+CMAKE_COMMAND:INTERNAL=/home/jovyan/.local/bin/cmake
+//Path to cpack program executable.
+CMAKE_CPACK_COMMAND:INTERNAL=/home/jovyan/.local/bin/cpack
+//Path to ctest program executable.
+CMAKE_CTEST_COMMAND:INTERNAL=/home/jovyan/.local/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_DLLTOOL
+CMAKE_DLLTOOL-ADVANCED:INTERNAL=1
+//Path to cache edit program executable.
+CMAKE_EDIT_COMMAND:INTERNAL=/home/jovyan/.local/bin/ccmake
+//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/jovyan/ASC-ODE-clean/ex20_solution
+//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=/home/jovyan/.local/share/cmake-3.29
+//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
+//ADVANCED property for variable: CMAKE_TAPI
+CMAKE_TAPI-ADVANCED:INTERNAL=1
+//uname command
+CMAKE_UNAME:INTERNAL=/usr/bin/uname
+//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE
+CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1
+//linker supports push/pop state
+_CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED:INTERNAL=TRUE
+
diff --git a/ex20_solution/build/CMakeFiles/3.29.4/CMakeCXXCompiler.cmake b/ex20_solution/build/CMakeFiles/3.29.4/CMakeCXXCompiler.cmake
new file mode 100644
index 000000000..e44b17a13
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/3.29.4/CMakeCXXCompiler.cmake
@@ -0,0 +1,92 @@
+set(CMAKE_CXX_COMPILER "/usr/bin/c++")
+set(CMAKE_CXX_COMPILER_ARG1 "")
+set(CMAKE_CXX_COMPILER_ID "GNU")
+set(CMAKE_CXX_COMPILER_VERSION "13.3.0")
+set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "")
+set(CMAKE_CXX_COMPILER_WRAPPER "")
+set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "17")
+set(CMAKE_CXX_EXTENSIONS_COMPUTED_DEFAULT "ON")
+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;cxx_std_23")
+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_CXX23_COMPILE_FEATURES "cxx_std_23")
+
+set(CMAKE_CXX_PLATFORM_ID "Linux")
+set(CMAKE_CXX_SIMULATE_ID "")
+set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "GNU")
+set(CMAKE_CXX_SIMULATE_VERSION "")
+
+
+
+
+set(CMAKE_AR "/usr/bin/ar")
+set(CMAKE_CXX_COMPILER_AR "/usr/bin/gcc-ar-13")
+set(CMAKE_RANLIB "/usr/bin/ranlib")
+set(CMAKE_CXX_COMPILER_RANLIB "/usr/bin/gcc-ranlib-13")
+set(CMAKE_LINKER "/usr/bin/ld")
+set(CMAKE_LINKER_LINK "")
+set(CMAKE_LINKER_LLD "")
+set(CMAKE_CXX_COMPILER_LINKER "/usr/bin/ld")
+set(CMAKE_CXX_COMPILER_LINKER_ID "GNU")
+set(CMAKE_CXX_COMPILER_LINKER_VERSION 2.42)
+set(CMAKE_CXX_COMPILER_LINKER_FRONTEND_VARIANT GNU)
+set(CMAKE_MT "")
+set(CMAKE_TAPI "CMAKE_TAPI-NOTFOUND")
+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_CXX_COMPILER_ENV_VAR "CXX")
+
+set(CMAKE_CXX_COMPILER_ID_RUN 1)
+set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;mpp;CPP;ixx;cppm;ccm;cxxm;c++m)
+set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC)
+
+foreach (lang IN ITEMS 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)
+set(CMAKE_CXX_LINKER_DEPFILE_SUPPORTED FALSE)
+
+# Save compiler ABI information.
+set(CMAKE_CXX_SIZEOF_DATA_PTR "8")
+set(CMAKE_CXX_COMPILER_ABI "ELF")
+set(CMAKE_CXX_BYTE_ORDER "LITTLE_ENDIAN")
+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++/13;/usr/include/x86_64-linux-gnu/c++/13;/usr/include/c++/13/backward;/usr/lib/gcc/x86_64-linux-gnu/13/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/13;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib")
+set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")
+set(CMAKE_CXX_COMPILER_CLANG_RESOURCE_DIR "")
diff --git a/ex20_solution/build/CMakeFiles/3.29.4/CMakeDetermineCompilerABI_CXX.bin b/ex20_solution/build/CMakeFiles/3.29.4/CMakeDetermineCompilerABI_CXX.bin
new file mode 100755
index 0000000000000000000000000000000000000000..e90f3f71d98d8b48fdca37fdc4f6d991fd1db519
GIT binary patch
literal 15992
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

literal 0
HcmV?d00001

diff --git a/ex20_solution/build/CMakeFiles/3.29.4/CMakeSystem.cmake b/ex20_solution/build/CMakeFiles/3.29.4/CMakeSystem.cmake
new file mode 100644
index 000000000..214af4ea4
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/3.29.4/CMakeSystem.cmake
@@ -0,0 +1,15 @@
+set(CMAKE_HOST_SYSTEM "Linux-5.15.0-140-generic")
+set(CMAKE_HOST_SYSTEM_NAME "Linux")
+set(CMAKE_HOST_SYSTEM_VERSION "5.15.0-140-generic")
+set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64")
+
+
+
+set(CMAKE_SYSTEM "Linux-5.15.0-140-generic")
+set(CMAKE_SYSTEM_NAME "Linux")
+set(CMAKE_SYSTEM_VERSION "5.15.0-140-generic")
+set(CMAKE_SYSTEM_PROCESSOR "x86_64")
+
+set(CMAKE_CROSSCOMPILING "FALSE")
+
+set(CMAKE_SYSTEM_LOADED 1)
diff --git a/ex20_solution/build/CMakeFiles/3.29.4/CompilerIdCXX/CMakeCXXCompilerId.cpp b/ex20_solution/build/CMakeFiles/3.29.4/CompilerIdCXX/CMakeCXXCompilerId.cpp
new file mode 100644
index 000000000..9a5e8f8ce
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/3.29.4/CompilerIdCXX/CMakeCXXCompilerId.cpp
@@ -0,0 +1,878 @@
+/* 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
+
+#if !defined(__has_include)
+/* If the compiler does not have __has_include, pretend the answer is
+   always no.  */
+#  define __has_include(x) 0
+#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 prior to 2021, and then VVVV for 2021 and later,
+     except that a few beta releases use the old format with V=2021.  */
+# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111
+#  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
+# else
+#  define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER)
+#  define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE)
+   /* The third version component from --version is an update index,
+      but no macro is provided for it.  */
+#  define COMPILER_VERSION_PATCH DEC(0)
+# 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(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER)
+# define COMPILER_ID "IntelLLVM"
+#if defined(_MSC_VER)
+# define SIMULATE_ID "MSVC"
+#endif
+#if defined(__GNUC__)
+# define SIMULATE_ID "GNU"
+#endif
+/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and
+ * later.  Look for 6 digit vs. 8 digit version number to decide encoding.
+ * VVVV is no smaller than the current year when a version is released.
+ */
+#if __INTEL_LLVM_COMPILER < 1000000L
+# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100)
+# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER    % 10)
+#else
+# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000)
+# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100)
+# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER     % 100)
+#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(__open_xl__) && defined(__clang__)
+# define COMPILER_ID "IBMClang"
+# define COMPILER_VERSION_MAJOR DEC(__open_xl_version__)
+# define COMPILER_VERSION_MINOR DEC(__open_xl_release__)
+# define COMPILER_VERSION_PATCH DEC(__open_xl_modification__)
+# define COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__)
+
+
+#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(__NVCOMPILER)
+# define COMPILER_ID "NVHPC"
+# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__)
+# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__)
+# if defined(__NVCOMPILER_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__)
+# endif
+
+#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(__clang__) && defined(__cray__)
+# define COMPILER_ID "CrayClang"
+# define COMPILER_VERSION_MAJOR DEC(__cray_major__)
+# define COMPILER_VERSION_MINOR DEC(__cray_minor__)
+# define COMPILER_VERSION_PATCH DEC(__cray_patchlevel__)
+# define COMPILER_VERSION_INTERNAL_STR __clang_version__
+
+
+#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(__CLANG_FUJITSU)
+# define COMPILER_ID "FujitsuClang"
+# define COMPILER_VERSION_MAJOR DEC(__FCC_major__)
+# define COMPILER_VERSION_MINOR DEC(__FCC_minor__)
+# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__)
+# define COMPILER_VERSION_INTERNAL_STR __clang_version__
+
+
+#elif defined(__FUJITSU)
+# define COMPILER_ID "Fujitsu"
+# if defined(__FCC_version__)
+#   define COMPILER_VERSION __FCC_version__
+# elif defined(__FCC_major__)
+#   define COMPILER_VERSION_MAJOR DEC(__FCC_major__)
+#   define COMPILER_VERSION_MINOR DEC(__FCC_minor__)
+#   define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__)
+# endif
+# if defined(__fcc_version)
+#   define COMPILER_VERSION_INTERNAL DEC(__fcc_version)
+# elif defined(__FCC_VERSION)
+#   define COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION)
+# endif
+
+
+#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(__TASKING__)
+# define COMPILER_ID "Tasking"
+  # define COMPILER_VERSION_MAJOR DEC(__VERSION__/1000)
+  # define COMPILER_VERSION_MINOR DEC(__VERSION__ % 100)
+# define COMPILER_VERSION_INTERNAL DEC(__VERSION__)
+
+#elif defined(__ORANGEC__)
+# define COMPILER_ID "OrangeC"
+# define COMPILER_VERSION_MAJOR DEC(__ORANGEC_MAJOR__)
+# define COMPILER_VERSION_MINOR DEC(__ORANGEC_MINOR__)
+# define COMPILER_VERSION_PATCH DEC(__ORANGEC_PATCHLEVEL__)
+
+#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/100   % 100)
+# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
+
+#elif defined(__clang__) && defined(__ti__)
+# define COMPILER_ID "TIClang"
+  # define COMPILER_VERSION_MAJOR DEC(__ti_major__)
+  # define COMPILER_VERSION_MINOR DEC(__ti_minor__)
+  # define COMPILER_VERSION_PATCH DEC(__ti_patchlevel__)
+# define COMPILER_VERSION_INTERNAL DEC(__ti_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(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__))
+# define COMPILER_ID "LCC"
+# define COMPILER_VERSION_MAJOR DEC(__LCC__ / 100)
+# define COMPILER_VERSION_MINOR DEC(__LCC__ % 100)
+# if defined(__LCC_MINOR__)
+#  define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__)
+# endif
+# if defined(__GNUC__) && defined(__GNUC_MINOR__)
+#  define SIMULATE_ID "GNU"
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
+#  define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
+#  if defined(__GNUC_PATCHLEVEL__)
+#   define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+#  endif
+# 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(_ADI_COMPILER)
+# define COMPILER_ID "ADSP"
+#if defined(__VERSIONNUM__)
+  /* __VERSIONNUM__ = 0xVVRRPPTT */
+#  define COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF)
+#  define COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF)
+#  define COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF)
+#  define COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 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__) || defined(__ICCSTM8__))
+#  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(__CRAYXT_COMPUTE_LINUX_TARGET)
+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(__MSYS__)
+# define PLATFORM_ID "MSYS"
+
+#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"
+
+# elif defined(__VXWORKS__)
+#  define PLATFORM_ID "VxWorks"
+
+# 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
+
+# elif defined(_ADI_COMPILER)
+#  define PLATFORM_ID "ADSP"
+
+#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_ARM64EC)
+#  define ARCHITECTURE_ID "ARM64EC"
+
+# 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"
+
+# elif defined(__ICCSTM8__)
+#  define ARCHITECTURE_ID "STM8"
+
+# 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
+
+#elif defined(__clang__) && defined(__ti__)
+# if defined(__ARM_ARCH)
+#  define ARCHITECTURE_ID "Arm"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__TI_COMPILER_VERSION__)
+# if defined(__TI_ARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__MSP430__)
+#  define ARCHITECTURE_ID "MSP430"
+
+# elif defined(__TMS320C28XX__)
+#  define ARCHITECTURE_ID "TMS320C28x"
+
+# elif defined(__TMS320C6X__) || defined(_TMS320C6X)
+#  define ARCHITECTURE_ID "TMS320C6x"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+# elif defined(__ADSPSHARC__)
+#  define ARCHITECTURE_ID "SHARC"
+
+# elif defined(__ADSPBLACKFIN__)
+#  define ARCHITECTURE_ID "Blackfin"
+
+#elif defined(__TASKING__)
+
+# if defined(__CTC__) || defined(__CPTC__)
+#  define ARCHITECTURE_ID "TriCore"
+
+# elif defined(__CMCS__)
+#  define ARCHITECTURE_ID "MCS"
+
+# elif defined(__CARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__CARC__)
+#  define ARCHITECTURE_ID "ARC"
+
+# elif defined(__C51__)
+#  define ARCHITECTURE_ID "8051"
+
+# elif defined(__CPCP__)
+#  define ARCHITECTURE_ID "PCP"
+
+# else
+#  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. */
+#ifdef COMPILER_VERSION
+char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]";
+
+/* Construct a string literal encoding the version number components. */
+#elif defined(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'};
+#elif defined(COMPILER_VERSION_INTERNAL_STR)
+char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]";
+#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_standard_default = "INFO" ":" "standard_default["
+#if CXX_STD > 202002L
+  "23"
+#elif CXX_STD > 201703L
+  "20"
+#elif CXX_STD >= 201703L
+  "17"
+#elif CXX_STD >= 201402L
+  "14"
+#elif CXX_STD >= 201103L
+  "11"
+#else
+  "98"
+#endif
+"]";
+
+const char* info_language_extensions_default = "INFO" ":" "extensions_default["
+#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) ||           \
+     defined(__TI_COMPILER_VERSION__)) &&                                     \
+  !defined(__STRICT_ANSI__)
+  "ON"
+#else
+  "OFF"
+#endif
+"]";
+
+/*--------------------------------------------------------------------------*/
+
+int main(int argc, char* argv[])
+{
+  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(__CRAYXT_COMPUTE_LINUX_TARGET)
+  require += info_cray[argc];
+#endif
+  require += info_language_standard_default[argc];
+  require += info_language_extensions_default[argc];
+  (void)argv;
+  return require;
+}
diff --git a/ex20_solution/build/CMakeFiles/3.29.4/CompilerIdCXX/a.out b/ex20_solution/build/CMakeFiles/3.29.4/CompilerIdCXX/a.out
new file mode 100755
index 0000000000000000000000000000000000000000..c8ced32cf082708045baa23211fbf858c298928d
GIT binary patch
literal 16096
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
ASpWb4

literal 0
HcmV?d00001

diff --git a/ex20_solution/build/CMakeFiles/CMakeConfigureLog.yaml b/ex20_solution/build/CMakeFiles/CMakeConfigureLog.yaml
new file mode 100644
index 000000000..7d1683ee1
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/CMakeConfigureLog.yaml
@@ -0,0 +1,295 @@
+
+---
+events:
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineSystem.cmake:205 (message)"
+      - "CMakeLists.txt:4 (project)"
+    message: |
+      The system is: Linux - 5.15.0-140-generic - x86_64
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompilerId.cmake:17 (message)"
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)"
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCXXCompiler.cmake:126 (CMAKE_DETERMINE_COMPILER_ID)"
+      - "CMakeLists.txt:4 (project)"
+    message: |
+      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/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles/3.29.4/CompilerIdCXX/a.out
+      
+  -
+    kind: "try_compile-v1"
+    backtrace:
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompilerABI.cmake:67 (try_compile)"
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:4 (project)"
+    checks:
+      - "Detecting CXX compiler ABI info"
+    directories:
+      source: "/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles/CMakeScratch/TryCompile-vwjj45"
+      binary: "/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles/CMakeScratch/TryCompile-vwjj45"
+    cmakeVariables:
+      CMAKE_CXX_FLAGS: ""
+      CMAKE_CXX_FLAGS_DEBUG: "-g"
+      CMAKE_CXX_SCAN_FOR_MODULES: "OFF"
+      CMAKE_EXE_LINKER_FLAGS: ""
+    buildResult:
+      variable: "CMAKE_CXX_ABI_COMPILED"
+      cached: true
+      stdout: |
+        Change Dir: '/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles/CMakeScratch/TryCompile-vwjj45'
+        
+        Run Build Command(s): /home/jovyan/.local/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_73869/fast
+        /usr/bin/gmake  -f CMakeFiles/cmTC_73869.dir/build.make CMakeFiles/cmTC_73869.dir/build
+        gmake[1]: Entering directory '/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles/CMakeScratch/TryCompile-vwjj45'
+        Building CXX object CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o
+        /usr/bin/c++   -v -o CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o -c /home/jovyan/.local/share/cmake-3.29/Modules/CMakeCXXCompilerABI.cpp
+        Using built-in specs.
+        COLLECT_GCC=/usr/bin/c++
+        OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa
+        OFFLOAD_TARGET_DEFAULT=1
+        Target: x86_64-linux-gnu
+        Configured with: ../src/configure -v --with-pkgversion='Ubuntu 13.3.0-6ubuntu2~24.04' --with-bugurl=file:///usr/share/doc/gcc-13/README.Bugs --enable-languages=c,ada,c++,go,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-13 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/libexec --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-libstdcxx-backtrace --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --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-13-fG75Ri/gcc-13-13.3.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-13-fG75Ri/gcc-13-13.3.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2
+        Thread model: posix
+        Supported LTO compression algorithms: zlib zstd
+        gcc version 13.3.0 (Ubuntu 13.3.0-6ubuntu2~24.04) 
+        COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_73869.dir/'
+         /usr/libexec/gcc/x86_64-linux-gnu/13/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /home/jovyan/.local/share/cmake-3.29/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpdir CMakeFiles/cmTC_73869.dir/ -dumpbase CMakeCXXCompilerABI.cpp.cpp -dumpbase-ext .cpp -mtune=generic -march=x86-64 -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccDGwsCC.s
+        GNU C++17 (Ubuntu 13.3.0-6ubuntu2~24.04) version 13.3.0 (x86_64-linux-gnu)
+        	compiled by GNU C version 13.3.0, GMP version 6.3.0, MPFR version 4.2.1, MPC version 1.3.1, isl version isl-0.26-GMP
+        
+        GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
+        ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/13"
+        ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"
+        ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/13/include-fixed/x86_64-linux-gnu"
+        ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/13/include-fixed"
+        ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/13/../../../../x86_64-linux-gnu/include"
+        #include "..." search starts here:
+        #include <...> search starts here:
+         /usr/include/c++/13
+         /usr/include/x86_64-linux-gnu/c++/13
+         /usr/include/c++/13/backward
+         /usr/lib/gcc/x86_64-linux-gnu/13/include
+         /usr/local/include
+         /usr/include/x86_64-linux-gnu
+         /usr/include
+        End of search list.
+        Compiler executable checksum: c81c05345ce537099dafd5580045814a
+        COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_73869.dir/'
+         as -v --64 -o CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccDGwsCC.s
+        GNU assembler version 2.42 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.42
+        COMPILER_PATH=/usr/libexec/gcc/x86_64-linux-gnu/13/:/usr/libexec/gcc/x86_64-linux-gnu/13/:/usr/libexec/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/13/:/usr/lib/gcc/x86_64-linux-gnu/
+        LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/13/:/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/13/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/13/../../../:/lib/:/usr/lib/
+        COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.'
+        Linking CXX executable cmTC_73869
+        /home/jovyan/.local/bin/cmake -E cmake_link_script CMakeFiles/cmTC_73869.dir/link.txt --verbose=1
+        /usr/bin/c++  -v -Wl,-v CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_73869
+        Using built-in specs.
+        COLLECT_GCC=/usr/bin/c++
+        COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-linux-gnu/13/lto-wrapper
+        OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa
+        OFFLOAD_TARGET_DEFAULT=1
+        Target: x86_64-linux-gnu
+        Configured with: ../src/configure -v --with-pkgversion='Ubuntu 13.3.0-6ubuntu2~24.04' --with-bugurl=file:///usr/share/doc/gcc-13/README.Bugs --enable-languages=c,ada,c++,go,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-13 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/libexec --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-libstdcxx-backtrace --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --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-13-fG75Ri/gcc-13-13.3.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-13-fG75Ri/gcc-13-13.3.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2
+        Thread model: posix
+        Supported LTO compression algorithms: zlib zstd
+        gcc version 13.3.0 (Ubuntu 13.3.0-6ubuntu2~24.04) 
+        COMPILER_PATH=/usr/libexec/gcc/x86_64-linux-gnu/13/:/usr/libexec/gcc/x86_64-linux-gnu/13/:/usr/libexec/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/13/:/usr/lib/gcc/x86_64-linux-gnu/
+        LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/13/:/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/13/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/13/../../../:/lib/:/usr/lib/
+        COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_73869' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_73869.'
+         /usr/libexec/gcc/x86_64-linux-gnu/13/collect2 -plugin /usr/libexec/gcc/x86_64-linux-gnu/13/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-linux-gnu/13/lto-wrapper -plugin-opt=-fresolution=/tmp/ccILOgaY.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_73869 /usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/13/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/13 -L/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/13/../../../../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/13/../../.. -v CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/13/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/crtn.o
+        collect2 version 13.3.0
+        /usr/bin/ld -plugin /usr/libexec/gcc/x86_64-linux-gnu/13/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-linux-gnu/13/lto-wrapper -plugin-opt=-fresolution=/tmp/ccILOgaY.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_73869 /usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/13/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/13 -L/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/13/../../../../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/13/../../.. -v CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/13/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/crtn.o
+        GNU ld (GNU Binutils for Ubuntu) 2.42
+        COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_73869' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_73869.'
+        gmake[1]: Leaving directory '/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles/CMakeScratch/TryCompile-vwjj45'
+        
+      exitCode: 0
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompilerABI.cmake:137 (message)"
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:4 (project)"
+    message: |
+      Parsed CXX implicit include dir info: rv=done
+        found start of include info
+        found start of implicit include info
+          add: [/usr/include/c++/13]
+          add: [/usr/include/x86_64-linux-gnu/c++/13]
+          add: [/usr/include/c++/13/backward]
+          add: [/usr/lib/gcc/x86_64-linux-gnu/13/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++/13] ==> [/usr/include/c++/13]
+        collapse include dir [/usr/include/x86_64-linux-gnu/c++/13] ==> [/usr/include/x86_64-linux-gnu/c++/13]
+        collapse include dir [/usr/include/c++/13/backward] ==> [/usr/include/c++/13/backward]
+        collapse include dir [/usr/lib/gcc/x86_64-linux-gnu/13/include] ==> [/usr/lib/gcc/x86_64-linux-gnu/13/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++/13;/usr/include/x86_64-linux-gnu/c++/13;/usr/include/c++/13/backward;/usr/lib/gcc/x86_64-linux-gnu/13/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include]
+      
+      
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompilerABI.cmake:173 (message)"
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:4 (project)"
+    message: |
+      Parsed CXX implicit link information:
+        link line regex: [^( *|.*[/\\])(ld[0-9]*(\\.[a-z]+)?|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)]
+        linker tool regex: [^[ 	]*(->|")?[ 	]*(([^"]*[/\\])?(ld[0-9]*(\\.[a-z]+)?))("|,| |$)]
+        ignore line: [Change Dir: '/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles/CMakeScratch/TryCompile-vwjj45']
+        ignore line: []
+        ignore line: [Run Build Command(s): /home/jovyan/.local/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_73869/fast]
+        ignore line: [/usr/bin/gmake  -f CMakeFiles/cmTC_73869.dir/build.make CMakeFiles/cmTC_73869.dir/build]
+        ignore line: [gmake[1]: Entering directory '/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles/CMakeScratch/TryCompile-vwjj45']
+        ignore line: [Building CXX object CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o]
+        ignore line: [/usr/bin/c++   -v -o CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o -c /home/jovyan/.local/share/cmake-3.29/Modules/CMakeCXXCompilerABI.cpp]
+        ignore line: [Using built-in specs.]
+        ignore line: [COLLECT_GCC=/usr/bin/c++]
+        ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa]
+        ignore line: [OFFLOAD_TARGET_DEFAULT=1]
+        ignore line: [Target: x86_64-linux-gnu]
+        ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 13.3.0-6ubuntu2~24.04' --with-bugurl=file:///usr/share/doc/gcc-13/README.Bugs --enable-languages=c ada c++ go d fortran objc obj-c++ m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-13 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/libexec --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-libstdcxx-backtrace --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --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-13-fG75Ri/gcc-13-13.3.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-13-fG75Ri/gcc-13-13.3.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2]
+        ignore line: [Thread model: posix]
+        ignore line: [Supported LTO compression algorithms: zlib zstd]
+        ignore line: [gcc version 13.3.0 (Ubuntu 13.3.0-6ubuntu2~24.04) ]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_73869.dir/']
+        ignore line: [ /usr/libexec/gcc/x86_64-linux-gnu/13/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /home/jovyan/.local/share/cmake-3.29/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpdir CMakeFiles/cmTC_73869.dir/ -dumpbase CMakeCXXCompilerABI.cpp.cpp -dumpbase-ext .cpp -mtune=generic -march=x86-64 -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccDGwsCC.s]
+        ignore line: [GNU C++17 (Ubuntu 13.3.0-6ubuntu2~24.04) version 13.3.0 (x86_64-linux-gnu)]
+        ignore line: [	compiled by GNU C version 13.3.0  GMP version 6.3.0  MPFR version 4.2.1  MPC version 1.3.1  isl version isl-0.26-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++/13"]
+        ignore line: [ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"]
+        ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/13/include-fixed/x86_64-linux-gnu"]
+        ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/13/include-fixed"]
+        ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/13/../../../../x86_64-linux-gnu/include"]
+        ignore line: [#include "..." search starts here:]
+        ignore line: [#include <...> search starts here:]
+        ignore line: [ /usr/include/c++/13]
+        ignore line: [ /usr/include/x86_64-linux-gnu/c++/13]
+        ignore line: [ /usr/include/c++/13/backward]
+        ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/13/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: [Compiler executable checksum: c81c05345ce537099dafd5580045814a]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_73869.dir/']
+        ignore line: [ as -v --64 -o CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccDGwsCC.s]
+        ignore line: [GNU assembler version 2.42 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.42]
+        ignore line: [COMPILER_PATH=/usr/libexec/gcc/x86_64-linux-gnu/13/:/usr/libexec/gcc/x86_64-linux-gnu/13/:/usr/libexec/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/13/:/usr/lib/gcc/x86_64-linux-gnu/]
+        ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/13/:/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/13/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/13/../../../:/lib/:/usr/lib/]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.']
+        ignore line: [Linking CXX executable cmTC_73869]
+        ignore line: [/home/jovyan/.local/bin/cmake -E cmake_link_script CMakeFiles/cmTC_73869.dir/link.txt --verbose=1]
+        ignore line: [/usr/bin/c++  -v -Wl -v CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_73869]
+        ignore line: [Using built-in specs.]
+        ignore line: [COLLECT_GCC=/usr/bin/c++]
+        ignore line: [COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-linux-gnu/13/lto-wrapper]
+        ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa]
+        ignore line: [OFFLOAD_TARGET_DEFAULT=1]
+        ignore line: [Target: x86_64-linux-gnu]
+        ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 13.3.0-6ubuntu2~24.04' --with-bugurl=file:///usr/share/doc/gcc-13/README.Bugs --enable-languages=c ada c++ go d fortran objc obj-c++ m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-13 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/libexec --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-libstdcxx-backtrace --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --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-13-fG75Ri/gcc-13-13.3.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-13-fG75Ri/gcc-13-13.3.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2]
+        ignore line: [Thread model: posix]
+        ignore line: [Supported LTO compression algorithms: zlib zstd]
+        ignore line: [gcc version 13.3.0 (Ubuntu 13.3.0-6ubuntu2~24.04) ]
+        ignore line: [COMPILER_PATH=/usr/libexec/gcc/x86_64-linux-gnu/13/:/usr/libexec/gcc/x86_64-linux-gnu/13/:/usr/libexec/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/13/:/usr/lib/gcc/x86_64-linux-gnu/]
+        ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/13/:/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/13/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/13/../../../:/lib/:/usr/lib/]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_73869' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_73869.']
+        link line: [ /usr/libexec/gcc/x86_64-linux-gnu/13/collect2 -plugin /usr/libexec/gcc/x86_64-linux-gnu/13/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-linux-gnu/13/lto-wrapper -plugin-opt=-fresolution=/tmp/ccILOgaY.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_73869 /usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/13/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/13 -L/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/13/../../../../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/13/../../.. -v CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/13/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/crtn.o]
+          arg [/usr/libexec/gcc/x86_64-linux-gnu/13/collect2] ==> ignore
+          arg [-plugin] ==> ignore
+          arg [/usr/libexec/gcc/x86_64-linux-gnu/13/liblto_plugin.so] ==> ignore
+          arg [-plugin-opt=/usr/libexec/gcc/x86_64-linux-gnu/13/lto-wrapper] ==> ignore
+          arg [-plugin-opt=-fresolution=/tmp/ccILOgaY.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_73869] ==> ignore
+          arg [/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/Scrt1.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/Scrt1.o]
+          arg [/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/crti.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/crti.o]
+          arg [/usr/lib/gcc/x86_64-linux-gnu/13/crtbeginS.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/13/crtbeginS.o]
+          arg [-L/usr/lib/gcc/x86_64-linux-gnu/13] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/13]
+          arg [-L/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu]
+          arg [-L/usr/lib/gcc/x86_64-linux-gnu/13/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/13/../../../../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/13/../../..] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/13/../../..]
+          arg [-v] ==> ignore
+          arg [CMakeFiles/cmTC_73869.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/13/crtendS.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/13/crtendS.o]
+          arg [/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/crtn.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/crtn.o]
+        ignore line: [collect2 version 13.3.0]
+        ignore line: [/usr/bin/ld -plugin /usr/libexec/gcc/x86_64-linux-gnu/13/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-linux-gnu/13/lto-wrapper -plugin-opt=-fresolution=/tmp/ccILOgaY.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_73869 /usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/13/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/13 -L/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/13/../../../../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/13/../../.. -v CMakeFiles/cmTC_73869.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/13/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/crtn.o]
+        linker tool for 'CXX': /usr/bin/ld
+        collapse obj [/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/Scrt1.o] ==> [/usr/lib/x86_64-linux-gnu/Scrt1.o]
+        collapse obj [/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/crti.o] ==> [/usr/lib/x86_64-linux-gnu/crti.o]
+        collapse obj [/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/crtn.o] ==> [/usr/lib/x86_64-linux-gnu/crtn.o]
+        collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/13] ==> [/usr/lib/gcc/x86_64-linux-gnu/13]
+        collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu]
+        collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/13/../../../../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/13/../../..] ==> [/usr/lib]
+        implicit libs: [stdc++;m;gcc_s;gcc;c;gcc_s;gcc]
+        implicit objs: [/usr/lib/x86_64-linux-gnu/Scrt1.o;/usr/lib/x86_64-linux-gnu/crti.o;/usr/lib/gcc/x86_64-linux-gnu/13/crtbeginS.o;/usr/lib/gcc/x86_64-linux-gnu/13/crtendS.o;/usr/lib/x86_64-linux-gnu/crtn.o]
+        implicit dirs: [/usr/lib/gcc/x86_64-linux-gnu/13;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib]
+        implicit fwks: []
+      
+      
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/Internal/CMakeDetermineLinkerId.cmake:40 (message)"
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompilerABI.cmake:210 (cmake_determine_linker_id)"
+      - "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:4 (project)"
+    message: |
+      Running the CXX compiler's linker: "/usr/bin/ld" "-v"
+      GNU ld (GNU Binutils for Ubuntu) 2.42
+...
diff --git a/ex20_solution/build/CMakeFiles/CMakeDirectoryInformation.cmake b/ex20_solution/build/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 000000000..e4e0bd5e6
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.29
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/jovyan/ASC-ODE-clean/ex20_solution")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/jovyan/ASC-ODE-clean/ex20_solution/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/ex20_solution/build/CMakeFiles/Makefile.cmake b/ex20_solution/build/CMakeFiles/Makefile.cmake
new file mode 100644
index 000000000..cd98f4d42
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/Makefile.cmake
@@ -0,0 +1,107 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.29
+
+# 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"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeCXXCompiler.cmake.in"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeCXXCompilerABI.cpp"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeCXXInformation.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeCommonLanguageInclude.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeCompilerIdDetection.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCXXCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompileFeatures.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompilerABI.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineCompilerId.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeDetermineSystem.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeFindBinUtils.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeGenericSystem.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeInitializeConfigs.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeLanguageInformation.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeParseImplicitIncludeInfo.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeParseImplicitLinkInfo.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeParseLibraryArchitecture.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeSystem.cmake.in"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeSystemSpecificInformation.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeSystemSpecificInitialize.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeTestCXXCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeTestCompilerCommon.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/CMakeUnixFindMake.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/ADSP-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/ARMCC-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/ARMClang-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/AppleClang-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/Borland-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/CMakeCommonCompilerMacros.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/Clang-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/Clang-DetermineCompilerInternal.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/Cray-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/CrayClang-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/Embarcadero-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/Fujitsu-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/FujitsuClang-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/GHS-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/GNU-CXX.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/GNU-FindBinUtils.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/GNU.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/HP-CXX-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/IAR-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/IBMClang-CXX-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/Intel-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/LCC-CXX-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/MSVC-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/NVHPC-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/NVIDIA-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/OrangeC-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/PGI-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/PathScale-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/SCO-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/TI-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/TIClang-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/Tasking-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/Watcom-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/XL-CXX-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Internal/CMakeDetermineLinkerId.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Internal/FeatureTesting.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Platform/Linux-Determine-CXX.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Platform/Linux-GNU-CXX.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Platform/Linux-GNU.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Platform/Linux-Initialize.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Platform/Linux.cmake"
+  "/home/jovyan/.local/share/cmake-3.29/Modules/Platform/UnixPaths.cmake"
+  "/home/jovyan/ASC-ODE-clean/ex20_solution/CMakeLists.txt"
+  "CMakeFiles/3.29.4/CMakeCXXCompiler.cmake"
+  "CMakeFiles/3.29.4/CMakeSystem.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.29.4/CMakeSystem.cmake"
+  "CMakeFiles/3.29.4/CMakeCXXCompiler.cmake"
+  "CMakeFiles/3.29.4/CMakeCXXCompiler.cmake"
+  "CMakeFiles/CMakeDirectoryInformation.cmake"
+  )
+
+# Dependency information for all targets:
+set(CMAKE_DEPEND_INFO_FILES
+  "CMakeFiles/demo_mass_spring.dir/DependInfo.cmake"
+  )
diff --git a/ex20_solution/build/CMakeFiles/Makefile2 b/ex20_solution/build/CMakeFiles/Makefile2
new file mode 100644
index 000000000..dc27125ab
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/Makefile2
@@ -0,0 +1,112 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.29
+
+# 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:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#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 = /home/jovyan/.local/bin/cmake
+
+# The command to remove a file.
+RM = /home/jovyan/.local/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /home/jovyan/ASC-ODE-clean/ex20_solution
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /home/jovyan/ASC-ODE-clean/ex20_solution/build
+
+#=============================================================================
+# Directory level rules for the build root directory
+
+# The main recursive "all" target.
+all: CMakeFiles/demo_mass_spring.dir/all
+.PHONY : all
+
+# The main recursive "preinstall" target.
+preinstall:
+.PHONY : preinstall
+
+# The main recursive "clean" target.
+clean: CMakeFiles/demo_mass_spring.dir/clean
+.PHONY : clean
+
+#=============================================================================
+# Target rules for target CMakeFiles/demo_mass_spring.dir
+
+# All Build rule for target.
+CMakeFiles/demo_mass_spring.dir/all:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/demo_mass_spring.dir/build.make CMakeFiles/demo_mass_spring.dir/depend
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/demo_mass_spring.dir/build.make CMakeFiles/demo_mass_spring.dir/build
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles --progress-num=1,2,3,4 "Built target demo_mass_spring"
+.PHONY : CMakeFiles/demo_mass_spring.dir/all
+
+# Build rule for subdir invocation for target.
+CMakeFiles/demo_mass_spring.dir/rule: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles 4
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/demo_mass_spring.dir/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles 0
+.PHONY : CMakeFiles/demo_mass_spring.dir/rule
+
+# Convenience name for target.
+demo_mass_spring: CMakeFiles/demo_mass_spring.dir/rule
+.PHONY : demo_mass_spring
+
+# clean rule for target.
+CMakeFiles/demo_mass_spring.dir/clean:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/demo_mass_spring.dir/build.make CMakeFiles/demo_mass_spring.dir/clean
+.PHONY : CMakeFiles/demo_mass_spring.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/ex20_solution/build/CMakeFiles/TargetDirectories.txt b/ex20_solution/build/CMakeFiles/TargetDirectories.txt
new file mode 100644
index 000000000..2018b8df9
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/TargetDirectories.txt
@@ -0,0 +1,3 @@
+/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles/demo_mass_spring.dir
+/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles/edit_cache.dir
+/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles/rebuild_cache.dir
diff --git a/ex20_solution/build/CMakeFiles/cmake.check_cache b/ex20_solution/build/CMakeFiles/cmake.check_cache
new file mode 100644
index 000000000..3dccd7317
--- /dev/null
+++ b/ex20_solution/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/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/DependInfo.cmake b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/DependInfo.cmake
new file mode 100644
index 000000000..5c79a2024
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/DependInfo.cmake
@@ -0,0 +1,25 @@
+
+# Consider dependencies only in project.
+set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
+
+# The set of languages for which implicit dependencies are needed:
+set(CMAKE_DEPENDS_LANGUAGES
+  )
+
+# The set of dependency files which are needed:
+set(CMAKE_DEPENDS_DEPENDENCY_FILES
+  "/home/jovyan/ASC-ODE-clean/ex20_solution/demo_mass_spring.cpp" "CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o" "gcc" "CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o.d"
+  "/home/jovyan/ASC-ODE-clean/ex20_solution/mass_spring.cpp" "CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o" "gcc" "CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o.d"
+  "/home/jovyan/ASC-ODE-clean/ex20_solution/mss_function.cpp" "CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o" "gcc" "CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o.d"
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
+  )
+
+# Fortran module output directory.
+set(CMAKE_Fortran_TARGET_MODULE_DIR "")
diff --git a/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/build.make b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/build.make
new file mode 100644
index 000000000..25087a4b2
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/build.make
@@ -0,0 +1,142 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.29
+
+# Delete rule output on recipe failure.
+.DELETE_ON_ERROR:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#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 = /home/jovyan/.local/bin/cmake
+
+# The command to remove a file.
+RM = /home/jovyan/.local/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /home/jovyan/ASC-ODE-clean/ex20_solution
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /home/jovyan/ASC-ODE-clean/ex20_solution/build
+
+# Include any dependencies generated for this target.
+include CMakeFiles/demo_mass_spring.dir/depend.make
+# Include any dependencies generated by the compiler for this target.
+include CMakeFiles/demo_mass_spring.dir/compiler_depend.make
+
+# Include the progress variables for this target.
+include CMakeFiles/demo_mass_spring.dir/progress.make
+
+# Include the compile flags for this target's objects.
+include CMakeFiles/demo_mass_spring.dir/flags.make
+
+CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o: CMakeFiles/demo_mass_spring.dir/flags.make
+CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o: /home/jovyan/ASC-ODE-clean/ex20_solution/demo_mass_spring.cpp
+CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o: CMakeFiles/demo_mass_spring.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o -MF CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o.d -o CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o -c /home/jovyan/ASC-ODE-clean/ex20_solution/demo_mass_spring.cpp
+
+CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/jovyan/ASC-ODE-clean/ex20_solution/demo_mass_spring.cpp > CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.i
+
+CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/jovyan/ASC-ODE-clean/ex20_solution/demo_mass_spring.cpp -o CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.s
+
+CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o: CMakeFiles/demo_mass_spring.dir/flags.make
+CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o: /home/jovyan/ASC-ODE-clean/ex20_solution/mass_spring.cpp
+CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o: CMakeFiles/demo_mass_spring.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o -MF CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o.d -o CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o -c /home/jovyan/ASC-ODE-clean/ex20_solution/mass_spring.cpp
+
+CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/jovyan/ASC-ODE-clean/ex20_solution/mass_spring.cpp > CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.i
+
+CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/jovyan/ASC-ODE-clean/ex20_solution/mass_spring.cpp -o CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.s
+
+CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o: CMakeFiles/demo_mass_spring.dir/flags.make
+CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o: /home/jovyan/ASC-ODE-clean/ex20_solution/mss_function.cpp
+CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o: CMakeFiles/demo_mass_spring.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building CXX object CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o -MF CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o.d -o CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o -c /home/jovyan/ASC-ODE-clean/ex20_solution/mss_function.cpp
+
+CMakeFiles/demo_mass_spring.dir/mss_function.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/demo_mass_spring.dir/mss_function.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/jovyan/ASC-ODE-clean/ex20_solution/mss_function.cpp > CMakeFiles/demo_mass_spring.dir/mss_function.cpp.i
+
+CMakeFiles/demo_mass_spring.dir/mss_function.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/demo_mass_spring.dir/mss_function.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/jovyan/ASC-ODE-clean/ex20_solution/mss_function.cpp -o CMakeFiles/demo_mass_spring.dir/mss_function.cpp.s
+
+# Object files for target demo_mass_spring
+demo_mass_spring_OBJECTS = \
+"CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o" \
+"CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o" \
+"CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o"
+
+# External object files for target demo_mass_spring
+demo_mass_spring_EXTERNAL_OBJECTS =
+
+demo_mass_spring: CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o
+demo_mass_spring: CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o
+demo_mass_spring: CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o
+demo_mass_spring: CMakeFiles/demo_mass_spring.dir/build.make
+demo_mass_spring: CMakeFiles/demo_mass_spring.dir/link.txt
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Linking CXX executable demo_mass_spring"
+	$(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/demo_mass_spring.dir/link.txt --verbose=$(VERBOSE)
+
+# Rule to build all files generated by this target.
+CMakeFiles/demo_mass_spring.dir/build: demo_mass_spring
+.PHONY : CMakeFiles/demo_mass_spring.dir/build
+
+CMakeFiles/demo_mass_spring.dir/clean:
+	$(CMAKE_COMMAND) -P CMakeFiles/demo_mass_spring.dir/cmake_clean.cmake
+.PHONY : CMakeFiles/demo_mass_spring.dir/clean
+
+CMakeFiles/demo_mass_spring.dir/depend:
+	cd /home/jovyan/ASC-ODE-clean/ex20_solution/build && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/jovyan/ASC-ODE-clean/ex20_solution /home/jovyan/ASC-ODE-clean/ex20_solution /home/jovyan/ASC-ODE-clean/ex20_solution/build /home/jovyan/ASC-ODE-clean/ex20_solution/build /home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/DependInfo.cmake "--color=$(COLOR)"
+.PHONY : CMakeFiles/demo_mass_spring.dir/depend
+
diff --git a/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/cmake_clean.cmake b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/cmake_clean.cmake
new file mode 100644
index 000000000..0a889af01
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/cmake_clean.cmake
@@ -0,0 +1,15 @@
+file(REMOVE_RECURSE
+  "CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o"
+  "CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o.d"
+  "CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o"
+  "CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o.d"
+  "CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o"
+  "CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o.d"
+  "demo_mass_spring"
+  "demo_mass_spring.pdb"
+)
+
+# Per-language clean rules from dependency scanning.
+foreach(lang CXX)
+  include(CMakeFiles/demo_mass_spring.dir/cmake_clean_${lang}.cmake OPTIONAL)
+endforeach()
diff --git a/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/compiler_depend.make b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/compiler_depend.make
new file mode 100644
index 000000000..57c871b46
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/compiler_depend.make
@@ -0,0 +1,2 @@
+# Empty compiler generated dependencies file for demo_mass_spring.
+# This may be replaced when dependencies are built.
diff --git a/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/compiler_depend.ts b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/compiler_depend.ts
new file mode 100644
index 000000000..dc7e3bbe0
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/compiler_depend.ts
@@ -0,0 +1,2 @@
+# CMAKE generated file: DO NOT EDIT!
+# Timestamp file for compiler generated dependencies management for demo_mass_spring.
diff --git a/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..b6ad8c32444e75834063bfaef405cb4ab6fb4a95
GIT binary patch
literal 133992
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

literal 0
HcmV?d00001

diff --git a/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o.d b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o.d
new file mode 100644
index 000000000..cf66fe6b7
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o.d
@@ -0,0 +1,204 @@
+CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o: \
+ /home/jovyan/ASC-ODE-clean/ex20_solution/demo_mass_spring.cpp \
+ /usr/include/stdc-predef.h \
+ /home/jovyan/ASC-ODE-clean/ex20_solution/mass_spring.hpp \
+ /usr/include/c++/13/vector /usr/include/c++/13/bits/requires_hosted.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/c++config.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/os_defines.h \
+ /usr/include/features.h /usr/include/features-time64.h \
+ /usr/include/x86_64-linux-gnu/bits/wordsize.h \
+ /usr/include/x86_64-linux-gnu/bits/timesize.h \
+ /usr/include/x86_64-linux-gnu/sys/cdefs.h \
+ /usr/include/x86_64-linux-gnu/bits/long-double.h \
+ /usr/include/x86_64-linux-gnu/gnu/stubs.h \
+ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/cpu_defines.h \
+ /usr/include/c++/13/pstl/pstl_config.h \
+ /usr/include/c++/13/bits/stl_algobase.h \
+ /usr/include/c++/13/bits/functexcept.h \
+ /usr/include/c++/13/bits/exception_defines.h \
+ /usr/include/c++/13/bits/cpp_type_traits.h \
+ /usr/include/c++/13/ext/type_traits.h \
+ /usr/include/c++/13/ext/numeric_traits.h \
+ /usr/include/c++/13/bits/stl_pair.h /usr/include/c++/13/type_traits \
+ /usr/include/c++/13/bits/move.h /usr/include/c++/13/bits/utility.h \
+ /usr/include/c++/13/compare /usr/include/c++/13/concepts \
+ /usr/include/c++/13/bits/stl_iterator_base_types.h \
+ /usr/include/c++/13/bits/iterator_concepts.h \
+ /usr/include/c++/13/bits/ptr_traits.h \
+ /usr/include/c++/13/bits/ranges_cmp.h \
+ /usr/include/c++/13/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/13/bits/concept_check.h \
+ /usr/include/c++/13/debug/assertions.h \
+ /usr/include/c++/13/bits/stl_iterator.h /usr/include/c++/13/new \
+ /usr/include/c++/13/bits/exception.h \
+ /usr/include/c++/13/bits/stl_construct.h \
+ /usr/include/c++/13/debug/debug.h \
+ /usr/include/c++/13/bits/predefined_ops.h /usr/include/c++/13/bit \
+ /usr/include/c++/13/bits/allocator.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/c++allocator.h \
+ /usr/include/c++/13/bits/new_allocator.h \
+ /usr/include/c++/13/bits/memoryfwd.h \
+ /usr/include/c++/13/bits/stl_uninitialized.h \
+ /usr/include/c++/13/ext/alloc_traits.h \
+ /usr/include/c++/13/bits/alloc_traits.h \
+ /usr/include/c++/13/bits/stl_vector.h \
+ /usr/include/c++/13/initializer_list \
+ /usr/include/c++/13/bits/stl_bvector.h \
+ /usr/include/c++/13/bits/functional_hash.h \
+ /usr/include/c++/13/bits/hash_bytes.h /usr/include/c++/13/bits/refwrap.h \
+ /usr/include/c++/13/bits/invoke.h \
+ /usr/include/c++/13/bits/stl_function.h \
+ /usr/include/c++/13/backward/binders.h \
+ /usr/include/c++/13/bits/range_access.h \
+ /usr/include/c++/13/bits/vector.tcc \
+ /usr/include/c++/13/bits/memory_resource.h /usr/include/c++/13/cstddef \
+ /usr/lib/gcc/x86_64-linux-gnu/13/include/stddef.h \
+ /usr/include/c++/13/bits/uses_allocator.h \
+ /usr/include/c++/13/bits/uses_allocator_args.h /usr/include/c++/13/tuple \
+ /usr/include/c++/13/bits/ranges_util.h \
+ /usr/include/c++/13/bits/ranges_base.h \
+ /usr/include/c++/13/bits/max_size_type.h /usr/include/c++/13/numbers \
+ /usr/include/c++/13/cmath /usr/include/math.h \
+ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
+ /usr/include/x86_64-linux-gnu/bits/types.h \
+ /usr/include/x86_64-linux-gnu/bits/typesizes.h \
+ /usr/include/x86_64-linux-gnu/bits/time64.h \
+ /usr/include/x86_64-linux-gnu/bits/math-vector.h \
+ /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \
+ /usr/include/x86_64-linux-gnu/bits/floatn.h \
+ /usr/include/x86_64-linux-gnu/bits/floatn-common.h \
+ /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \
+ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \
+ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \
+ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
+ /usr/include/x86_64-linux-gnu/bits/mathcalls.h \
+ /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \
+ /usr/include/x86_64-linux-gnu/bits/iscanonical.h \
+ /usr/include/c++/13/bits/std_abs.h /usr/include/stdlib.h \
+ /usr/include/x86_64-linux-gnu/bits/waitflags.h \
+ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \
+ /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \
+ /usr/include/x86_64-linux-gnu/sys/types.h \
+ /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/time_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \
+ /usr/include/x86_64-linux-gnu/bits/stdint-intn.h /usr/include/endian.h \
+ /usr/include/x86_64-linux-gnu/bits/endian.h \
+ /usr/include/x86_64-linux-gnu/bits/endianness.h \
+ /usr/include/x86_64-linux-gnu/bits/byteswap.h \
+ /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \
+ /usr/include/x86_64-linux-gnu/sys/select.h \
+ /usr/include/x86_64-linux-gnu/bits/select.h \
+ /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \
+ /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \
+ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
+ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
+ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
+ /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
+ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
+ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
+ /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \
+ /usr/include/c++/13/bits/specfun.h /usr/include/c++/13/limits \
+ /usr/include/c++/13/tr1/gamma.tcc \
+ /usr/include/c++/13/tr1/special_function_util.h \
+ /usr/include/c++/13/tr1/bessel_function.tcc \
+ /usr/include/c++/13/tr1/beta_function.tcc \
+ /usr/include/c++/13/tr1/ell_integral.tcc \
+ /usr/include/c++/13/tr1/exp_integral.tcc \
+ /usr/include/c++/13/tr1/hypergeometric.tcc \
+ /usr/include/c++/13/tr1/legendre_function.tcc \
+ /usr/include/c++/13/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/13/tr1/poly_hermite.tcc \
+ /usr/include/c++/13/tr1/poly_laguerre.tcc \
+ /usr/include/c++/13/tr1/riemann_zeta.tcc /usr/include/c++/13/stdexcept \
+ /usr/include/c++/13/exception /usr/include/c++/13/bits/exception_ptr.h \
+ /usr/include/c++/13/bits/cxxabi_init_exception.h \
+ /usr/include/c++/13/typeinfo /usr/include/c++/13/bits/nested_exception.h \
+ /usr/include/c++/13/string /usr/include/c++/13/bits/stringfwd.h \
+ /usr/include/c++/13/bits/char_traits.h \
+ /usr/include/c++/13/bits/postypes.h /usr/include/c++/13/cwchar \
+ /usr/include/wchar.h /usr/lib/gcc/x86_64-linux-gnu/13/include/stdarg.h \
+ /usr/include/x86_64-linux-gnu/bits/wchar.h \
+ /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \
+ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \
+ /usr/include/c++/13/bits/localefwd.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/c++locale.h \
+ /usr/include/c++/13/clocale /usr/include/locale.h \
+ /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/13/iosfwd \
+ /usr/include/c++/13/cctype /usr/include/ctype.h \
+ /usr/include/c++/13/bits/ostream_insert.h \
+ /usr/include/c++/13/bits/cxxabi_forced.h \
+ /usr/include/c++/13/bits/basic_string.h /usr/include/c++/13/string_view \
+ /usr/include/c++/13/bits/string_view.tcc \
+ /usr/include/c++/13/ext/string_conversions.h /usr/include/c++/13/cstdlib \
+ /usr/include/c++/13/cstdio /usr/include/stdio.h \
+ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
+ /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \
+ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
+ /usr/include/c++/13/cerrno /usr/include/errno.h \
+ /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/x86_64-linux-gnu/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/x86_64-linux-gnu/bits/types/error_t.h \
+ /usr/include/c++/13/bits/charconv.h \
+ /usr/include/c++/13/bits/basic_string.tcc /usr/include/c++/13/cassert \
+ /usr/include/assert.h \
+ /home/jovyan/ASC-ODE-clean/ex20_solution/mss_function.hpp \
+ /home/jovyan/ASC-ODE-clean/ex20_solution/vector.hpp \
+ /home/jovyan/ASC-ODE-clean/ex20_solution/matrix.hpp \
+ /usr/include/c++/13/iomanip /usr/include/c++/13/bits/ios_base.h \
+ /usr/include/c++/13/ext/atomicity.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/gthr.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/x86_64-linux-gnu/bits/sched.h \
+ /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \
+ /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \
+ /usr/include/x86_64-linux-gnu/bits/time.h \
+ /usr/include/x86_64-linux-gnu/bits/timex.h \
+ /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \
+ /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \
+ /usr/include/x86_64-linux-gnu/bits/setjmp.h \
+ /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \
+ /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/atomic_word.h \
+ /usr/include/x86_64-linux-gnu/sys/single_threaded.h \
+ /usr/include/c++/13/bits/locale_classes.h \
+ /usr/include/c++/13/bits/locale_classes.tcc \
+ /usr/include/c++/13/system_error \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/error_constants.h \
+ /usr/include/c++/13/locale /usr/include/c++/13/bits/locale_facets.h \
+ /usr/include/c++/13/cwctype /usr/include/wctype.h \
+ /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/ctype_base.h \
+ /usr/include/c++/13/streambuf /usr/include/c++/13/bits/streambuf.tcc \
+ /usr/include/c++/13/bits/streambuf_iterator.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/ctype_inline.h \
+ /usr/include/c++/13/bits/locale_facets.tcc \
+ /usr/include/c++/13/bits/locale_facets_nonio.h /usr/include/c++/13/ctime \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/time_members.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/13/bits/codecvt.h \
+ /usr/include/c++/13/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/13/bits/locale_conv.h \
+ /usr/include/c++/13/bits/quoted_string.h /usr/include/c++/13/sstream \
+ /usr/include/c++/13/istream /usr/include/c++/13/ios \
+ /usr/include/c++/13/bits/basic_ios.h \
+ /usr/include/c++/13/bits/basic_ios.tcc /usr/include/c++/13/ostream \
+ /usr/include/c++/13/bits/ostream.tcc \
+ /usr/include/c++/13/bits/istream.tcc \
+ /usr/include/c++/13/bits/sstream.tcc /usr/include/c++/13/iostream \
+ /usr/include/c++/13/fstream \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/basic_file.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/c++io.h \
+ /usr/include/c++/13/bits/fstream.tcc
diff --git a/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/depend.make b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/depend.make
new file mode 100644
index 000000000..3ccc1ddca
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/depend.make
@@ -0,0 +1,2 @@
+# Empty dependencies file for demo_mass_spring.
+# This may be replaced when dependencies are built.
diff --git a/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/flags.make b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/flags.make
new file mode 100644
index 000000000..7803a3135
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/flags.make
@@ -0,0 +1,10 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.29
+
+# compile CXX with /usr/bin/c++
+CXX_DEFINES = 
+
+CXX_INCLUDES = -I/home/jovyan/ASC-ODE-clean/ex20_solution/ex20_solution -I/home/jovyan/ASC-ODE-clean/ex20_solution
+
+CXX_FLAGS = -std=gnu++20
+
diff --git a/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/link.txt b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/link.txt
new file mode 100644
index 000000000..b8939318f
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/link.txt
@@ -0,0 +1 @@
+/usr/bin/c++ CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o -o demo_mass_spring
diff --git a/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..4c4fdda07ec6d3b05bb9bb6d0024efe7235d3ded
GIT binary patch
literal 944
zcmbVKy-ve05WbZ1JHdv;l1_j`t<V+*1{A3(T@YI(Hk5>@AjpqmN1_XT1s<udz@zX4
z^v?BxaU_PGba%e*yU&g<o{w&CTAl}N9$dq3#V9~vfuV*&*n?ew@o;$MpG@L9SG9lM
z7kv?QFKb=)-g^TP3{DNKRc(y>=$q){y9u-a7KCk}|7Uc38@|39Jy|5>gDk7(d@7Q%
z1Q2qTsVK&*s#SjCl}g_fh{s4pAYv&&Bt@2`IbwOCQi0#ol`2YJOg+tOQC3BnR%+Hb
zcTM03b##|4M;|&hm)6)d)WJxYJFif)&EV>fv1JE+UHutqY0m)Nw$K#B+s5Z}zCe=K
zcHgUASZlX;gxoedzMDUWKVF+}GAFvLZM2`OCH})S@x4e#eXKt;JihqG?1)-WKs#8a
UpXh!+@$T%Y`O_%wP3Gk4m)sCLv;Y7A

literal 0
HcmV?d00001

diff --git a/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o.d b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o.d
new file mode 100644
index 000000000..7863f5c10
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o.d
@@ -0,0 +1,3 @@
+CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o: \
+ /home/jovyan/ASC-ODE-clean/ex20_solution/mass_spring.cpp \
+ /usr/include/stdc-predef.h
diff --git a/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..54e9487f8730a71f219e0dc76842219b100a17fb
GIT binary patch
literal 122216
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

literal 0
HcmV?d00001

diff --git a/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o.d b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o.d
new file mode 100644
index 000000000..445284b87
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o.d
@@ -0,0 +1,210 @@
+CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o: \
+ /home/jovyan/ASC-ODE-clean/ex20_solution/mss_function.cpp \
+ /usr/include/stdc-predef.h \
+ /home/jovyan/ASC-ODE-clean/ex20_solution/mss_function.hpp \
+ /home/jovyan/ASC-ODE-clean/ex20_solution/mass_spring.hpp \
+ /usr/include/c++/13/vector /usr/include/c++/13/bits/requires_hosted.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/c++config.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/os_defines.h \
+ /usr/include/features.h /usr/include/features-time64.h \
+ /usr/include/x86_64-linux-gnu/bits/wordsize.h \
+ /usr/include/x86_64-linux-gnu/bits/timesize.h \
+ /usr/include/x86_64-linux-gnu/sys/cdefs.h \
+ /usr/include/x86_64-linux-gnu/bits/long-double.h \
+ /usr/include/x86_64-linux-gnu/gnu/stubs.h \
+ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/cpu_defines.h \
+ /usr/include/c++/13/pstl/pstl_config.h \
+ /usr/include/c++/13/bits/stl_algobase.h \
+ /usr/include/c++/13/bits/functexcept.h \
+ /usr/include/c++/13/bits/exception_defines.h \
+ /usr/include/c++/13/bits/cpp_type_traits.h \
+ /usr/include/c++/13/ext/type_traits.h \
+ /usr/include/c++/13/ext/numeric_traits.h \
+ /usr/include/c++/13/bits/stl_pair.h /usr/include/c++/13/type_traits \
+ /usr/include/c++/13/bits/move.h /usr/include/c++/13/bits/utility.h \
+ /usr/include/c++/13/compare /usr/include/c++/13/concepts \
+ /usr/include/c++/13/bits/stl_iterator_base_types.h \
+ /usr/include/c++/13/bits/iterator_concepts.h \
+ /usr/include/c++/13/bits/ptr_traits.h \
+ /usr/include/c++/13/bits/ranges_cmp.h \
+ /usr/include/c++/13/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/13/bits/concept_check.h \
+ /usr/include/c++/13/debug/assertions.h \
+ /usr/include/c++/13/bits/stl_iterator.h /usr/include/c++/13/new \
+ /usr/include/c++/13/bits/exception.h \
+ /usr/include/c++/13/bits/stl_construct.h \
+ /usr/include/c++/13/debug/debug.h \
+ /usr/include/c++/13/bits/predefined_ops.h /usr/include/c++/13/bit \
+ /usr/include/c++/13/bits/allocator.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/c++allocator.h \
+ /usr/include/c++/13/bits/new_allocator.h \
+ /usr/include/c++/13/bits/memoryfwd.h \
+ /usr/include/c++/13/bits/stl_uninitialized.h \
+ /usr/include/c++/13/ext/alloc_traits.h \
+ /usr/include/c++/13/bits/alloc_traits.h \
+ /usr/include/c++/13/bits/stl_vector.h \
+ /usr/include/c++/13/initializer_list \
+ /usr/include/c++/13/bits/stl_bvector.h \
+ /usr/include/c++/13/bits/functional_hash.h \
+ /usr/include/c++/13/bits/hash_bytes.h /usr/include/c++/13/bits/refwrap.h \
+ /usr/include/c++/13/bits/invoke.h \
+ /usr/include/c++/13/bits/stl_function.h \
+ /usr/include/c++/13/backward/binders.h \
+ /usr/include/c++/13/bits/range_access.h \
+ /usr/include/c++/13/bits/vector.tcc \
+ /usr/include/c++/13/bits/memory_resource.h /usr/include/c++/13/cstddef \
+ /usr/lib/gcc/x86_64-linux-gnu/13/include/stddef.h \
+ /usr/include/c++/13/bits/uses_allocator.h \
+ /usr/include/c++/13/bits/uses_allocator_args.h /usr/include/c++/13/tuple \
+ /usr/include/c++/13/bits/ranges_util.h \
+ /usr/include/c++/13/bits/ranges_base.h \
+ /usr/include/c++/13/bits/max_size_type.h /usr/include/c++/13/numbers \
+ /usr/include/c++/13/cmath /usr/include/math.h \
+ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
+ /usr/include/x86_64-linux-gnu/bits/types.h \
+ /usr/include/x86_64-linux-gnu/bits/typesizes.h \
+ /usr/include/x86_64-linux-gnu/bits/time64.h \
+ /usr/include/x86_64-linux-gnu/bits/math-vector.h \
+ /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \
+ /usr/include/x86_64-linux-gnu/bits/floatn.h \
+ /usr/include/x86_64-linux-gnu/bits/floatn-common.h \
+ /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \
+ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \
+ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \
+ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
+ /usr/include/x86_64-linux-gnu/bits/mathcalls.h \
+ /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \
+ /usr/include/x86_64-linux-gnu/bits/iscanonical.h \
+ /usr/include/c++/13/bits/std_abs.h /usr/include/stdlib.h \
+ /usr/include/x86_64-linux-gnu/bits/waitflags.h \
+ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \
+ /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \
+ /usr/include/x86_64-linux-gnu/sys/types.h \
+ /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/time_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \
+ /usr/include/x86_64-linux-gnu/bits/stdint-intn.h /usr/include/endian.h \
+ /usr/include/x86_64-linux-gnu/bits/endian.h \
+ /usr/include/x86_64-linux-gnu/bits/endianness.h \
+ /usr/include/x86_64-linux-gnu/bits/byteswap.h \
+ /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \
+ /usr/include/x86_64-linux-gnu/sys/select.h \
+ /usr/include/x86_64-linux-gnu/bits/select.h \
+ /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \
+ /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \
+ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
+ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
+ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
+ /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
+ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
+ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
+ /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \
+ /usr/include/c++/13/bits/specfun.h /usr/include/c++/13/limits \
+ /usr/include/c++/13/tr1/gamma.tcc \
+ /usr/include/c++/13/tr1/special_function_util.h \
+ /usr/include/c++/13/tr1/bessel_function.tcc \
+ /usr/include/c++/13/tr1/beta_function.tcc \
+ /usr/include/c++/13/tr1/ell_integral.tcc \
+ /usr/include/c++/13/tr1/exp_integral.tcc \
+ /usr/include/c++/13/tr1/hypergeometric.tcc \
+ /usr/include/c++/13/tr1/legendre_function.tcc \
+ /usr/include/c++/13/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/13/tr1/poly_hermite.tcc \
+ /usr/include/c++/13/tr1/poly_laguerre.tcc \
+ /usr/include/c++/13/tr1/riemann_zeta.tcc /usr/include/c++/13/stdexcept \
+ /usr/include/c++/13/exception /usr/include/c++/13/bits/exception_ptr.h \
+ /usr/include/c++/13/bits/cxxabi_init_exception.h \
+ /usr/include/c++/13/typeinfo /usr/include/c++/13/bits/nested_exception.h \
+ /usr/include/c++/13/string /usr/include/c++/13/bits/stringfwd.h \
+ /usr/include/c++/13/bits/char_traits.h \
+ /usr/include/c++/13/bits/postypes.h /usr/include/c++/13/cwchar \
+ /usr/include/wchar.h /usr/lib/gcc/x86_64-linux-gnu/13/include/stdarg.h \
+ /usr/include/x86_64-linux-gnu/bits/wchar.h \
+ /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \
+ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \
+ /usr/include/c++/13/bits/localefwd.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/c++locale.h \
+ /usr/include/c++/13/clocale /usr/include/locale.h \
+ /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/13/iosfwd \
+ /usr/include/c++/13/cctype /usr/include/ctype.h \
+ /usr/include/c++/13/bits/ostream_insert.h \
+ /usr/include/c++/13/bits/cxxabi_forced.h \
+ /usr/include/c++/13/bits/basic_string.h /usr/include/c++/13/string_view \
+ /usr/include/c++/13/bits/string_view.tcc \
+ /usr/include/c++/13/ext/string_conversions.h /usr/include/c++/13/cstdlib \
+ /usr/include/c++/13/cstdio /usr/include/stdio.h \
+ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \
+ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
+ /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \
+ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
+ /usr/include/c++/13/cerrno /usr/include/errno.h \
+ /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/x86_64-linux-gnu/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/x86_64-linux-gnu/bits/types/error_t.h \
+ /usr/include/c++/13/bits/charconv.h \
+ /usr/include/c++/13/bits/basic_string.tcc /usr/include/c++/13/cassert \
+ /usr/include/assert.h \
+ /home/jovyan/ASC-ODE-clean/ex20_solution/vector.hpp \
+ /home/jovyan/ASC-ODE-clean/ex20_solution/matrix.hpp \
+ /usr/include/c++/13/iomanip /usr/include/c++/13/bits/ios_base.h \
+ /usr/include/c++/13/ext/atomicity.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/gthr.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/x86_64-linux-gnu/bits/sched.h \
+ /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \
+ /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \
+ /usr/include/x86_64-linux-gnu/bits/time.h \
+ /usr/include/x86_64-linux-gnu/bits/timex.h \
+ /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \
+ /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \
+ /usr/include/x86_64-linux-gnu/bits/setjmp.h \
+ /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \
+ /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/atomic_word.h \
+ /usr/include/x86_64-linux-gnu/sys/single_threaded.h \
+ /usr/include/c++/13/bits/locale_classes.h \
+ /usr/include/c++/13/bits/locale_classes.tcc \
+ /usr/include/c++/13/system_error \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/error_constants.h \
+ /usr/include/c++/13/locale /usr/include/c++/13/bits/locale_facets.h \
+ /usr/include/c++/13/cwctype /usr/include/wctype.h \
+ /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/ctype_base.h \
+ /usr/include/c++/13/streambuf /usr/include/c++/13/bits/streambuf.tcc \
+ /usr/include/c++/13/bits/streambuf_iterator.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/ctype_inline.h \
+ /usr/include/c++/13/bits/locale_facets.tcc \
+ /usr/include/c++/13/bits/locale_facets_nonio.h /usr/include/c++/13/ctime \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/time_members.h \
+ /usr/include/x86_64-linux-gnu/c++/13/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/13/bits/codecvt.h \
+ /usr/include/c++/13/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/13/bits/locale_conv.h \
+ /usr/include/c++/13/bits/quoted_string.h /usr/include/c++/13/sstream \
+ /usr/include/c++/13/istream /usr/include/c++/13/ios \
+ /usr/include/c++/13/bits/basic_ios.h \
+ /usr/include/c++/13/bits/basic_ios.tcc /usr/include/c++/13/ostream \
+ /usr/include/c++/13/bits/ostream.tcc \
+ /usr/include/c++/13/bits/istream.tcc \
+ /usr/include/c++/13/bits/sstream.tcc /usr/include/c++/13/iostream \
+ /home/jovyan/ASC-ODE-clean/ex20_solution/linear_solve.hpp \
+ /usr/include/c++/13/algorithm /usr/include/c++/13/bits/stl_algo.h \
+ /usr/include/c++/13/bits/algorithmfwd.h \
+ /usr/include/c++/13/bits/stl_heap.h \
+ /usr/include/c++/13/bits/uniform_int_dist.h \
+ /usr/include/c++/13/bits/stl_tempbuf.h \
+ /usr/include/c++/13/bits/ranges_algo.h \
+ /usr/include/c++/13/bits/ranges_algobase.h \
+ /usr/include/c++/13/pstl/glue_algorithm_defs.h \
+ /usr/include/c++/13/pstl/execution_defs.h
diff --git a/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/progress.make b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/progress.make
new file mode 100644
index 000000000..a69a57e8e
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/demo_mass_spring.dir/progress.make
@@ -0,0 +1,5 @@
+CMAKE_PROGRESS_1 = 1
+CMAKE_PROGRESS_2 = 2
+CMAKE_PROGRESS_3 = 3
+CMAKE_PROGRESS_4 = 4
+
diff --git a/ex20_solution/build/CMakeFiles/progress.marks b/ex20_solution/build/CMakeFiles/progress.marks
new file mode 100644
index 000000000..b8626c4cf
--- /dev/null
+++ b/ex20_solution/build/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+4
diff --git a/ex20_solution/build/Makefile b/ex20_solution/build/Makefile
new file mode 100644
index 000000000..6e93a4c5b
--- /dev/null
+++ b/ex20_solution/build/Makefile
@@ -0,0 +1,235 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 3.29
+
+# 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:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#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 = /home/jovyan/.local/bin/cmake
+
+# The command to remove a file.
+RM = /home/jovyan/.local/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /home/jovyan/ASC-ODE-clean/ex20_solution
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /home/jovyan/ASC-ODE-clean/ex20_solution/build
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake cache editor..."
+	/home/jovyan/.local/bin/ccmake -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
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/home/jovyan/.local/bin/cmake --regenerate-during-build -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
+
+# The main all target
+all: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles /home/jovyan/ASC-ODE-clean/ex20_solution/build//CMakeFiles/progress.marks
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 all
+	$(CMAKE_COMMAND) -E cmake_progress_start /home/jovyan/ASC-ODE-clean/ex20_solution/build/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	$(MAKE) $(MAKESILENT) -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 demo_mass_spring
+
+# Build rule for target.
+demo_mass_spring: cmake_check_build_system
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 demo_mass_spring
+.PHONY : demo_mass_spring
+
+# fast build rule for target.
+demo_mass_spring/fast:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/demo_mass_spring.dir/build.make CMakeFiles/demo_mass_spring.dir/build
+.PHONY : demo_mass_spring/fast
+
+demo_mass_spring.o: demo_mass_spring.cpp.o
+.PHONY : demo_mass_spring.o
+
+# target to build an object file
+demo_mass_spring.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/demo_mass_spring.dir/build.make CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.o
+.PHONY : demo_mass_spring.cpp.o
+
+demo_mass_spring.i: demo_mass_spring.cpp.i
+.PHONY : demo_mass_spring.i
+
+# target to preprocess a source file
+demo_mass_spring.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/demo_mass_spring.dir/build.make CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.i
+.PHONY : demo_mass_spring.cpp.i
+
+demo_mass_spring.s: demo_mass_spring.cpp.s
+.PHONY : demo_mass_spring.s
+
+# target to generate assembly for a file
+demo_mass_spring.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/demo_mass_spring.dir/build.make CMakeFiles/demo_mass_spring.dir/demo_mass_spring.cpp.s
+.PHONY : demo_mass_spring.cpp.s
+
+mass_spring.o: mass_spring.cpp.o
+.PHONY : mass_spring.o
+
+# target to build an object file
+mass_spring.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/demo_mass_spring.dir/build.make CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.o
+.PHONY : mass_spring.cpp.o
+
+mass_spring.i: mass_spring.cpp.i
+.PHONY : mass_spring.i
+
+# target to preprocess a source file
+mass_spring.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/demo_mass_spring.dir/build.make CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.i
+.PHONY : mass_spring.cpp.i
+
+mass_spring.s: mass_spring.cpp.s
+.PHONY : mass_spring.s
+
+# target to generate assembly for a file
+mass_spring.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/demo_mass_spring.dir/build.make CMakeFiles/demo_mass_spring.dir/mass_spring.cpp.s
+.PHONY : mass_spring.cpp.s
+
+mss_function.o: mss_function.cpp.o
+.PHONY : mss_function.o
+
+# target to build an object file
+mss_function.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/demo_mass_spring.dir/build.make CMakeFiles/demo_mass_spring.dir/mss_function.cpp.o
+.PHONY : mss_function.cpp.o
+
+mss_function.i: mss_function.cpp.i
+.PHONY : mss_function.i
+
+# target to preprocess a source file
+mss_function.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/demo_mass_spring.dir/build.make CMakeFiles/demo_mass_spring.dir/mss_function.cpp.i
+.PHONY : mss_function.cpp.i
+
+mss_function.s: mss_function.cpp.s
+.PHONY : mss_function.s
+
+# target to generate assembly for a file
+mss_function.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/demo_mass_spring.dir/build.make CMakeFiles/demo_mass_spring.dir/mss_function.cpp.s
+.PHONY : mss_function.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 "... edit_cache"
+	@echo "... rebuild_cache"
+	@echo "... demo_mass_spring"
+	@echo "... demo_mass_spring.o"
+	@echo "... demo_mass_spring.i"
+	@echo "... demo_mass_spring.s"
+	@echo "... mass_spring.o"
+	@echo "... mass_spring.i"
+	@echo "... mass_spring.s"
+	@echo "... mss_function.o"
+	@echo "... mss_function.i"
+	@echo "... mss_function.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/ex20_solution/build/cmake_install.cmake b/ex20_solution/build/cmake_install.cmake
new file mode 100644
index 000000000..a227518d7
--- /dev/null
+++ b/ex20_solution/build/cmake_install.cmake
@@ -0,0 +1,54 @@
+# Install script for directory: /home/jovyan/ASC-ODE-clean/ex20_solution
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/usr/local")
+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()
+
+# Set default install directory permissions.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/usr/bin/objdump")
+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/jovyan/ASC-ODE-clean/ex20_solution/build/${CMAKE_INSTALL_MANIFEST}"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
diff --git a/ex20_solution/build/demo_mass_spring b/ex20_solution/build/demo_mass_spring
new file mode 100755
index 0000000000000000000000000000000000000000..6952aa4c8482e92032cdb40519ecab8cd0f538f2
GIT binary patch
literal 88416
zcmeFa3wTsT(m#9>G8h$2K*Xr1;|+r%1VrVkK^YkoG;&c?FoYzKXh>o*L39y=VU%$)
z8Wj`;U35{AMa5lovkDpznRwmkx^7%qjjWf6LCw0TS!JF7ud1uhEi>r8@BjIp?|VKD
z52@2t)z#J2)zy8v`<%JiH|c`ZloUf>J&bb<N_h`cm|P)vFSU4bjS<EnMy_$Z;Wc`K
zo`(OL&kb8sLByqDx=I>704ZM<-6Vkh7242HmrjuKCA~6)qG6^=Q$7#fO4<!izf19H
zsOe^T8x`Gf!Lrj8UPF66vQ6`DMR&tIsds~}jOaz?qI{i_&kZxho*HU<k{J3wLgcz(
z4rp{~=+0Ln`P^{4%4TRtWzaSC(?HSxq`W-ISMqx$#|;-9pzs>%@-9U_vdb^M#GJ+y
zDbH<xop#$v``M7P(m7`hA5vCydRb|C&BD_cjyUV|vxX0@t{6OwRUo~*_)k7H;o|8A
znx%<wVn!piR;9H(qV*Lz@n8IT<6q8fo}2pkVfFo2P3l<j-1k?kCLYq8@(>SQBu|>$
zOdp3k;!*av3-`SY!qIg+{<jprHUIZJ&-lyXD|?;K$OL~L2d+;7d~FhZQxg2wN$?jW
z!9Rz}Br11F68sxU@Ka%cL~>$D%3Ys?e^(NGQ4%?$lJE~nqUWPY@Yg4i6H9_8CrDJ^
z^d$V-lki`c1b=c8IjfS`VL=i+`L7rM-PgTI%0;mW`OAP$RNp~K_&<dF6WoO&{SN*g
zZ)6#*5>K;)=Q|YK8>35Zr$S_sB6Q{F&zoOSo?jg(s0!rg8~GEbP0lYWt}32aS{*2^
znl}0TvWoKJX$5o2iWMy}<;tmnVLAEvfs(3<>+{Qs%jX43@{6mgDys4>Dm3!1EGo-e
zFdy*ZsTF0_z9RFkl<xvV&#0;?50uU?R(Z}J>f>zrg$oOmNU%)}3_V*HFsGm>zo4wF
zqHqD!C#E@2w>-bFAW&EW)@c*L>=X$s=^*T!w;+Jx78Vv)21+Z+xqx9qODn4L=M+>I
z=OY?c6;$1jUs_%opj`77F3hhiuBxsmFDNSw+>pN@2RSb8R?PUJK5&yUMmTh>sw%i4
zzr0wRhIlCRaFkVAm|rosI#5+yFn?kpa6=1A3aau0RRyJi>WPIu-<gGF71hNewyc_}
z=4P2fdWa}3X<EK->Y4e<`sLTd_H3uBVs0T;ad=@xP2j&!MC$fS^;V5Yn&nS~RWGS5
zE}vgf1Seueipz_1b8&iZRk5Qrrk7t|3YICw)iv`e58Six+Wf+jYxCz8l$HTeP+eUN
zhvn4#;`#F{77!bntx#NfenBZ(RS7SpR=cs-0J%C)RCwBHG_IXR$$5p~r_@kN6)OCM
z^Uu#eV{nc!Vba9&&d(n<c({3YhIKn^@R<rdV+NRq4?bg<asG@M<IbCyKXmXJgGV}O
z!$#U@PRdYw65TNsBVZc-rDCK_!-#hP?&x1S|2+_YiFOcE6<>;RFh;~w{P!>q_iCh4
zjJ=2vIzHtMxZz*}oPA}$PC+>b;hyNZ_}{m*^bo^1(C9C?O?Tak;kKtSK+-iwl^#f=
z|4=i3Pvc9GPbHq$bstg(8DoY2hPR(adFjR^oo4z0#ubwO^V8R2Dv@T;{EKwBj_Ey&
zYDotM-i;|+s&Na_bm{qvp2zXz0{9k*a~j_y^Z0a$a~iMHEi{1RqPc{gLr}WahSzxr
z-)6%fN(i}PHvCZ<3D{}F>$yCUyKMMlZTy*{Cxzo9Y<L~NX};yP;dT5b{P8w?mdK~+
zqz>&w_S*1hAoI$$;l;#E%dz2Uex|PxHawNBuUs2m&Ce9YZ^O$JmkD_`JRHirX4vot
znOMV^ZNtN%%&WwP?`2{Qqtb?lLz~w^8$QFt8b+-RPkyMcWj1_ojRb74;qBw~N*i8W
zkaMlE;SaaTS!cudv*9<|@Otbfa-$7@q>aDHhCkYdZ?@r&vEl#!e*3SCV}J11?N0ZH
zJs*E$82(^WAT{3NuiKvfGMgrT=B^J7BYyHH_?vNDu0i}IL}}j@kH_aWaGE+;`#V;e
zI#&BOD@`4${dZQHI#T;1R+>6c``uQWI!^m7R+>6YdzF=@fYd(6N>j&apJJt{!?d4g
zrKzK|53|zLLE2BS($q29`&elTZ0)I5I)l>R{AAXbI!600D@`4u{T(Y!9ie@jm8K5R
z{yQs84}$HFSZV4A?RQ&g>HzJxnCbY*17Q8R8OMz`*#7a8ul~C;eVHqLu`7LnD}9bD
zeU>Xd*p(jON+0V=_j9EWb)|c{(m(BV>i?Z9{go^InJfLFEB&4;{gx}e!<Bx~m442Z
ze#(&^`sKvX+gJNTyZm*ZbmmR-4Q(3wsy{OJHMCOv@O!|zXYSyP<CY?c4ip)?6&QcS
z^E`o(U4g^VwHDJoy4Hd5wv6LyiSK2B;J=Ic&%B+$z@Pk~PXE@g&h>BY>fuk>;eY$5
zKwk)$ECSNwZORXHe(Ha<V}r1-QFGdKf8E$0KESO%^l6}%KRk8-vc>-RpLjf01aIEq
znFYR-S;%XaPx;%g2a#^3Bj32`<EBmZFWK!!r!De_(@xH2dA`=6P0?WM-gulkb2vhG
z{z$L^vY)5!9(v0kipJ)mCw`NW>3ME7!QR0ZkSYC`q+2C@ucX_Mh7@9(7}`E=3(1}o
z`gl^PV^XMXQs@gQ!LOw69j2tu(7BZkl_Vq-GyobJ%pB3!MF<1_!e)PD1#?7#nas$F
z-h3K{F7Qg;ba&nicitQ;@A;HB8r+Q1p{~)s6@TVteBJa-#;J__CgX}=8;E3pb%0^U
zrZo8rTTr4>;ytp~Y6yaLm<h~=W~^&U>Bd_LUR8+2r<jyxEbyWPOr|g!--$N9I;EW|
zdo;IjM*Zn<2!D75)j|w9*Pl_o?Rg6HFH)sR{e#iiiI~V8UL;Op`V6reBB<~esdWjr
z_Ego5u?N^o*ke9X_rVw&F4MD9(w$0$7UX}P!mdAZ$RF+}G2Dz#{b>4+KXUl9OkhhC
zgAffiAv5wA9hFdlM1biYiz%0Khqi^8FSNrS`fKd(3We@FpZOS>)t&EIlh1GQb^Z{K
z*Rik^B~zJm(Jj&7_5_+_TADnEoU94)DNUxDC3LK$`m!c>bmu$G<a^QLo6DMzFla(R
zYhu~qe&%LljQ}_KA=&zyjH{&$1~r9(JAsJ?oAH;-*ghF8s6CyK$P`fxcEwim_AcPy
z5e$^U*=@MZmF6()5tf=S{hP$Up~ZuMK0wI?ouvYC$REy>3Yc;ynQ~vc&ot9K$n}R_
z*0Rhlkjb5x>+EH52FYpihdzp>nR2eT<QxY%bxI*6OZSh<&_ANV7N_Er)QXe8`$JsP
zbEhO!{2tbE8w}FZD)6Z;QC!I~6}O3-$Kou-FEZu4c&}-IxsX%G`l0<vmR)hn2Uc(n
z)^a#<P}61%4CX=ixf$;TXES6}rJ!o5TH&!1pz$OLo{<RgBgnFjk!LeG#RCHwH#+W*
zIuuMqD2N8%)kb@PTbq(9j<FbJvbq5rAP^X?5NFhp)MDr26#F!jeTFTTCS)CGvL=_z
zHBgd&I9V%VNv`86q`-;|R8_>YUFa4g8Jn@XX=zhN@MH>~dT@!x&N%@M6Jfg&`w%4S
zxKp8Vs2h#uewJ~^!(<ByRN(vPca-#evs^W6#MAID-9=-|Kp^Xp&=%3*6K3W(ODwM+
z&s0^FXl%1eYK33%V!&?oho`p|`A_T1BYeivry#I>E&k9<0KLanftytJJSnRj$&Ldo
zHm$>K=wQd^2>&@Q{!GCSaN!#?9_smB`UO0(x4%{9o`_;%+bOYRJIzwA8aH#?tXVJX
z2}~oZU?ffYLpOE#Lp7cLu&>i%(%1$UD(vf;^)f%>(A0>yLN$9r(>oFDd@+dV3Qyk?
z%2YR<p}aJ@Ls0a^z>u2`Y4*I7A?6SHx*F`o)a}mX(vg!It_*c=c-5BAMc)qBveRj@
zR<}C`BAP=r+e6cv>~pr*&?c0L8PN2<`a{#(8XBOR=cs#l)b+K7r*HQce&df!{wo+-
zsc_5-F)N}Rbxm1>SitiDUo%)kc{xN0Pj3q44d=VuoM2N%Xa}tQ5{=BUyZ%M(1HbY7
z0h_5jVto{wNl4Tij;5xPXvp+Eg!2@<O<WWKFL}%4p9C7UB-EHrnUr@T)1O&7W_7}V
z`69*bNkC5u{ljuQoAzr_9j*;(^8B$>1o^x}>P;f`TR^J0L(kbntlORg2XnS$7dX4Z
zY>=*S?(mGKx7p~bMZ9Q{Sg7U`n4O%ZHSGH&*tGD(u&)iEKb3_1K#ttD_)s&|Hgem|
zqm?nof1{0gOM_{g3_^xI*)4=2!}WX9q#Z`el7mGSW}!`6(WY(wi0>1$L+o2rzT+q|
zt5~fc1Yw3vP5dLttlRG8O6oqO9s=ri&p<6!qPsNMy$VkP{_w1oD6D}545H{3@~uN*
zkHfs{;AtC?ZUmhmd0-=8Ghh>7O9L*QcN6@^AKJ=UQ6ZYteH8ORAaS7JXza2R4P#>H
z6;6h;biPioP*p^Q6-Z7BwfjSVn-uztat%W+=mH7nrIRR%bK-s@JBCp$$x)?<A1S(Z
z4>xoENi7hK{S7cSof381XSiaG*>l5rSV2J#4&xDSn}6#MJ^YQoU9T=byT|{;vfKY}
zTQ+F7>>CL!JD0JhWe-NuVcB*6jb(qu6=+3ESOX39|4wDuTEN(kU;j6j4YkmNv8%T&
z+1-{(O}NF+1IV+v3|5R_5TQ|MQYe@WFh0~w)6^{7E(@N7zjn9gU>Q_-qp<)YAGt_S
z$&AMSgL(GImupS}N(qj}^4vV{Gf&`v#uWH<hlfX^rA>iLRF}T)E2=id$3NARx|q>_
z6dOZGSKNs)&NJ=};-YRo<W-Y@5X>ddfxZ@-dRNn906pwZC#)KI`4MS!f8>>FNL0TP
zs8Dbd>R-2o{u&ueZ^!~y1QJ8RjaYZ09?CTj=jLdskzgk%^5AtYMBo{CCgsM}PHQ1L
z%L>B!3*V9X@7-X<xP$+g#L=1-W|?y{hVXrrnC7xCNivz{)v#IB;|b|9&6|w#40xTm
z$TWSMP5$068x3$HVO@HRp~9$8nr?(yRW;F6)!<q0QA#&v0V}3uq<f04Np8+aMr71`
zX&{VHKnpgqeatopvmyP3od~)c+5C9MCvJp}myV!Frm{8te6}3PwoI}$ptKgw=Er1`
ziNR)vn2om5Bg_#&@a1-l#>PR6jXoKgz&S7vm14#n4butlDk_pxr83)enQhdNp<t`C
zOuu%G;auwobJ@y$70Z{2%2hRp#$Lt#kS_N`E;q{08th1K_W)7cHIkPVW{MwyoS%Qo
zp>i0$OY2C<x%|YHn})~NeX<=7Huy_!Iyp%#>KF|cAp@&{nYLDg2Y4=#mI{a?rG*?R
zEU|(e>B%E4CtnFsqMXW0YV0HLb+)`~kQX`yNyaxBGlMFveRww2hgXr5ExG8$WKJ#K
zv{bGVYV&N?+|p|#S0$sqAG|@FIT(ZdXs`r-*$6A}R~o=w=z+RWVm1qX9Z>|@=fI%+
z9GE2Y8_<n4c4WRoWrlz&L~ATAK>9ZsGk9@<?(0}NtA7q3$%u^l>8J(Sjhb<8MmECy
z75JaYHG&;kfQkc_4KukPunqgDvQ2AggLI<IXs`@_*&sWUc?EH3uTY}{i@gut4K47$
zcW_xUuSk;jDqG$L<V|ABT4>I;Br#?~oToCwvopD1awQT1v%nOY5vrHAE8W*|9UXQh
zc^UPGid`i`6V)UW6uUM#mK|S1*QYXx1+0jtWNtj>5*W>qGNb+&JmyAu<&}+kP8ux>
z1i-+_en@KbcLC|>=9Prd!Jq(@q+rmzPp;9#MZw?=Hyagc3hOJvTK38H6@@ku_Ac0>
z!G-wCN*80m539vwcTf2US-63S*(~m1Z22h9n87w($bL&}$i0IGw>Bv<n(J0GIn3ti
z*7KJp6n%k1bY_Ia>9$s)NqG@HJ&EXn2}O7GWv$7rJRdBjd*x2<BFF`(M%0xRO?wTu
z6`RO53NKe;Nu1g9sp+-WbYI8Dc6cZmG^0L<a-zXSxaXFbpS&fe!!X<u#B8?25w<!V
zVAiR3uo7~$AEx6T>uAU}n%yXAi+lrN-HX_S{XeU*Gb1EU*G-95EkYhzldMJVODOsZ
zC7N4gVx83@?joo~s77RBMbj<9-NM}>siwyJY7w%dqeTdjQGXMcletATVec)Oz}h=U
zo)s^)p&YiCqc1MS{wWmZjOY*}>e&4eMTkpBkycE2>$uB-P-!D<1fg~d&F+oBK~(Q7
z+;*htw#<fhn%ocM2$2CjeQr_avsiP$>Q}S37;YOHM24@$KE1(wi>6iTVfamKC1YM(
zOQqv#{{rslh+sr9eec((C`GU)LfR)i4z3%Bi-OK}u<2@KLZN7IsV?Vf6ebeXoP$Kt
zq<}aQj7<N*iVZ5A4f8%p?c>Nx<?JKxR+X0r7s{*0*Al2i_EzwUCb&5MXGTa>?e276
zr<Aga9Lb1``q47j5YxXh79Y}3OGClsw!xe2!p>?Nyr(ODP@gM;)Ve5hh3M6S`tg03
zn?yxW+jw=9Eo;utXQejgfqfTF1X#uN&a7kca70p2duSR2cJmnhgqBT4SDRS(<G2BY
zd7inMVDI1v<ckKEfq`7819qZ&rMs=~+zQ>f?=V#lihiXT1kGSU5QtHjSfCvNrQM?S
z{>Taz#{SKfiqo@IWI8<sv`9TKz|&?lSTCxykH^>?=46N$ztuf!Mvq1;<!dOwYEdrJ
z)1Ogw#M<)WL*8FZ%{q;nH4AlBQn1$%3NA;U_Qz1`FyA^QuSh8Qa+~CvMKV2JlH`p0
zupA$lqJ(LcsSKy!F$o3#gszNcVU-8CRIX$7U{MmL+uN_)*K;5<D-9Nm&>gl7oH}g4
z306=VO`A<X`N3T{mhu8MdHbrKWPt{jO=b)%QYoj}LDU=%&50V}8YX>6&!Cr3^iW$B
z)N#zFJr31#<<_m9#w5-?nsakga&Fzq2XX<3FOF7z9W@}6kr&S}TQ(G2i8^%n5-GZs
zi-H_tF}<bElyf!9QBF)OFgXEn;wSAQwe}Yz$gKF-#a1JG`y8Gn(5=&?!?Ze%YVA4L
zs@7~&i<)$9#^4~`-`K~V%2-N=4OMBO;2J9GHumQ37K}no?kB`$);weubp?wjOHwQg
z2fHg9OekT3DPg8<8cv14b_BG$&V#!qvR_YAKynqdt^bB&5~{(i!a7nK>R4NpM@sAR
z>S3)q_7@Py9-6Qo1GefJbuq+%wIH?AYYkz(RSl#IEHw-49rUt?5j!{RI?7ke)+U^@
zVXr`?*xJNpTKi}vEelqDP+6JD@O0fVIi&4Tr&_3{5jC)=hf7jG4}NrC7o_Z{9RXdt
zaupRGRLr^@t)ZiwdQ}dq0+q7ro+P%Ex-A5Zj8F&4u!j?9=?8^+dH&~AV_RIwVFIrJ
zj^usU4I~3s`zf?mYM*Qn#WYDTn1rSzjf70f^%*qfDamHAg@Y`?ZM7FstPTdb&^#L4
zs8zU)TUY1OYg=sVjgZU@Ma-sFRi-R8r6742?s*9D<K9xiA*?W=u#=TAo--f5kd#zU
zF?OMOER>BvaZi>$S;Nn88d25jiXfG(yQo-8O}{87O`)h3ditfBgk?Np%9vqxQk=k{
zD!Yrj-ekQZNLnQ<j&km!xHC){R&jMoH%sf0jL4`jL?LzDr0`^FBkjpi+`oX9GZ*jX
zVy&+3$CR1_7~A3D!OPDRifF79WhNpvkh=~_oKqG#K~J37T)OO)gs!G`(HOlomY{HR
zVRl0jdMD~m`qe9Xdm*Z8+cx{?J+*D-+C&`jSCwlcppE+(=Ke?f*Dx8OQS+DEci9tL
zB*9DHG%`nHeNZwsqdL+!2WMH<oohGra&mQCri<tpOLsPrFM-+GAC=~L4QFocNN$!D
zBv$vJXzVfY*w%~hQ%P;(62+W}_(qCf;VeaZ3|66ut^3An8jM5P76D?j!MXAJ`CmX>
zvYmEyy6wIG{4Toeay&)_%dYxnn9#m!ZtmMfK@hfRF5-fDkI6N%SjPcqmpz;Ibg>)S
zhAqxke`qp>iCIvGc3gbGanGg^k#;o0)SP-p^ANZzZG!p3liR4SGU3a`pww}!ZY{<~
zV-tuM_JVC@lNrLZx?VNUHpo^#1o@aF9V#oqQ?UPtP2cc=&<paXcVerx3#3j}9_#is
zc00({ob@BjF<}xaozFJZ?e=o@SPdU#V-dVp3xUztPSng{L;J~ua9$>Ipg`XL<XyTn
zsz2k@)~K4~Hj{m%RoXs8+dI!X<Uj|rcE{47&1U;0wVPqD-R1B~TkY)o+3V1PYha<3
zuoPKionLL<0_JA=M{dhlx<<J{1J(LPZclTs_(3Gq#xq1jV|Q?Eu;(3S4Iz4RBSbgR
ze)ptMaf?4R%dAbn%nEcgHq{i|Ov&+_+yQ->Z~zuN*@S!pI~1Z~Zn{6hHbxnF=^dAX
zk@Y*4rK<gL<oFLpJez)B@c>BLBU?1q!z^Uo<WS5iCxvE`!gDRn>=W#CEC1+%@j6k%
z7}^E@CzGE5$McN)kke*!vyVCV#+7f_c5u7*EY+*XaBb47mU5?{Ue#*#sz2~n5l%U<
z%d&@8;z_PskNTGQRF69Joo+qKIuFF&OFd@mE*!mXvHCvOM4cH*%G13TiQ_{be%5rw
zhr>8jb&C%R6V+z2#8Wh9?%UmJqmBZZK9@zK$uI6fryr}_4K|L(KBf3)iw_Cyl(r8$
zrE~N_bK^`Tra)WUVAN(?yKDb&*cm?6{ftz1+Y%F1OU2v=$YsM0M|cycZjP{=hbpd}
zr$w92I-!+3o^?CVkubDvVKt~bL}LS;@dt6+i~8bpk#(THi;mHt6GbS{viJU^1fWk%
z@3J3#YJDpnx3xqvS#<UX$51SJPbHDJ%qfpr7QNWk4(`4ln%oxK&>D|pG37|s+1c?M
z$=F#52v@>^-9F?f>E~K@3iTFe%LWs5ik;u1IaL=w4V6=a<}Ybkb)F<)b1vYrRdX(a
zd{o3P@fWn`b4o(D_Dp~Cf7YIJlgMj)!y)gNwdYPuyppshN6|#>`4=c)Z%^H0I5zTB
z1J2K`{Ao8%wiivFy7d9-@X^>Tb1Akr&pz4+=@%qL1w8oBlLtCWG?ruG+XzpCBy}0{
zh~cBJlS%%|_S&7qzB5>ud#04A9?t%^I*GjWMDk#{q$6v<X-(=iBM?qn{h_z%b)gVu
z`>$cj(S(7y*{&8HX^IdUPc)<pov=~Kd7P916>|+9z#mciV)SqxlAQ6H?ou`z<U#?=
zTxuK#PC2IWF~2sH^bvHTfZhh!$)`(ziN+qr>vI0lzUGX(n;PJOC%W6N{Z$kf@f=k`
z8b@OnQj$(}x}xGX;JZadn-x{h{fy33^L!jZj$#QEB0EQ8AyNY}`HZ05SET>=fAO;c
znj=qJ15MEAue+(q2;{TUIPeJA1Pj2dd=Rn?uth9`7Szt}>xzx~Gj~Zk56T)gG-KKH
z2-Z;rTyzv}sE<xWKXk;S?tT83V1DsPvYl;3syauebD*KE4X8|Wo|MVefXzp4tL{nn
z9clP$KTl15?6(`v?Yq?KXsHq^9lk5cRdn=w;L9{eCd*>Rem5=idy#S+-+egBj?+jY
zJnEjsT}AmVag#WS=80h59-#>)N3c_9vH<N<sEw%2IPY=9Jkr-z)kkAqM<{|fw^dWK
zG0z`?;kqK1vm<4&7WM}^GC>wh5TnRQ6(D6FB9VO96+I^!yOWc!z~AU>sXSZpW8r@p
z-+og4yIU(R++lA;_4*$_1BJFM<SEm$l?+ytFo?_sz=_Hk0Nq+F$T=d1M~ZAOfgQ}t
zDtKTCD>BR)!tq|6!m~}tw?-#XV}5@k<XeU&!GBp5;#S$NB(2lTVQg2a_WBh^G;Bku
zW5<o)AO*>QKX43y{{%^M!n_9zKPClLm7+0vNea!ijza3zkKw5}N0;)pKfFR&fF9{4
zH$%-9Jl4S@W>I5t>pZAMk>_ANLzhK;JQ|zNNqVfq^PqmL`xd(l4gRRF5mRh5w6Y19
z2TNXE<7jL-&){-c8$PZ4J_)7a0IDF)_!={9`M<(KI>&f(9c>!tM;Qo8VS4K2{KIvA
z-2keR;VGH^)9_fl^#@dc@=A#{N03m>2&06|5=khYMNzi~%<koJA6COtzf>tNvjJ2`
zr|g9n7_hWM?&Uafj((7Xet>hrt{Jj2>qM>^&2W7&^WDNnsCE=UWmd44YwL_qt6#SJ
zHg&fdC<cnxpeobX*^5(eOMn!OHIt;#zKtrfOh6?VegAi4V2qmd#18>-c(RobrNSE4
z?%LBNK*;BQg^dYX8`Wa65a%uF3pIKbPhu&|abdZfq#+tkiGGj$xIe|BgcOFi`C%4K
zG7!}1%^JOj;~C{co1<$fW#PNg*uC`p&&_sTddDEeK?u|aXIItO@;w`sR&JmL_qhsS
zy0zo@ZKQ}jl)<!_Fm0DP0-(SW)<u?qP!iS)R4H#!Dc0coe`Q|rILX|{yyC8{P&wk+
zmJc@Q_DvI;5_WTX%r#)MjcM*@Aq-)Z`$c+fBH_H^PG{BZF*=7l9QJ8}bpd%;X#tEO
z-Nv5GBLKZ2q&T9nHZs0_cH*$IW6u4#S#T<HchSp|tSom?B*_(EfBOS@q;HDwWIE^d
zdC(LtQ`7Xnna^B<c_Rj9b3W7bQj+=1;m0JJ&#0M1r&*6o*K%wYbc{jAHdFyH8pHAh
zoGJ@R7!z+ZaT4>7mot_(xqP+T?8r8!M)Rod1OxbD9cQB-qp_kfI;WxL4P4qnPVz1}
zhiTy&OXxaZ3@_pEu^?pSUUVLYp1RJIrA;+YlfE6J$>&Mzg)fpH(!7+W56rt3>v6GE
zSWEG|92<apdA_}fZrvR($20|2rg!*$GIsdl)W2HM<-|NZal8x4IeeQkLc{;YBO7Dg
zo`o|Zr3+HfRt}GxO19u$p4cOaD9ddsMuae8IP}YdWLV{Y=ZCv6?Xvsfh%HI{@O7MO
z?mn;nf14j3$&N?k1p8qZpIKl(>`N5!!!3k{A7VjhUw-(ru9N~-LXha@N>r9DF6p^^
zBN}UCtP(RySo|#LxRHE(HofG-Q*O|su}e8gPerqu`CS?A81DCGkhu{BLjZS*nY@Xj
z<YhYLr6_qVvfK{Hp%sqpi}BlLj&Z76-?zM%o^T{;+M^AIHm}K)c=7uzn$y|r!R-9F
zV~%Z7E*>gutDx2cfHWu8hQw6dx`U`0dF>Q^nW|xpCrfrWP=pKJv<x<{^@n&CXP?lh
zr*TlMnRm#yu>p2%01mb#W1<!4De5$&@n#hfRssQ$(bzWH@Eh%0$+Mu0rJt)Q43qAp
zDNl$x?Mi8$kEsp95uPrGr`KYBWXf602UReQ5xG;;d}*2NngG(SRWqV4wH)dRXa&QO
zSi>fr!G@=S@P%j}f_?l0F;o9{4_^9sPvH*ohrW>sMk7yKInz3xv(hca8_aKMd7o5A
zO?YesMIho&dxx!><+S!d7PyC=FzK~d@InEprVqB|xO$E{ilbz*w~m7C+Se#i(gIXo
zG<GzJRQ}lpNHbb8dMB#Li@`{+fZaHGCDlfOlj&BM*24Q@O57WG0_R!{q)Ff!r9m|I
zbqAF~lR#ZL2zXXK%S2-zs*N@1qh616ES+7`=$ilJz{R@F%fZA~hSY`nTBl!Qk5e_{
z3Za%<p{-mfH31c8zSsNXA6&(G9X*Yfo`+(t3G*jfdR_&g374MV2f;a%WNNvwcQC_)
zJbakPF<N~<vJP`0d!S_<Ba$U1oLI~!iNy4Bh|$}T*<@LC-WHy4geEtky^!9a-WQxm
z^HmO-P2@Pk@fa~FoDG&{N*;#f_^=mA<c`MDkPI7hCuWqtGCs76-j@0(Hl78vVmB{4
z(R-_j#x*Ot=y|5hcTeI6Fuae8+S%;UJ(kw(&PA=DV)vCnS{BP#x=M8laBz@D-MY<x
zTVq2oIY$#+Mh5vKG8hzWw(d&vZ;g$i4=H)%s}iU?S**FP4Kpk95a%-RL(k$3(~<Z?
za>z`xaNhy8$%rz(&gYe6?!rTGzP_PBUfOg!>1D`ftF?PLfRn0;maHy{&F;tJmLpe=
zZtw0<8v0Pzz&;r&`TgH$$BgU};V#rEU1%(=e$e8es}KEQ6RBslUBZ!u-Jdi|uvc$?
zqgFqOlV7^^jQZNxWKmyCU?)SG9z<x?%{@I!J!ZBjqch4wD0(BE-IY<_U~ihDnj`pp
z`Fm$g^nRwEq0$5GY4CXZIu`j)-A!#qV7w|Q8vFNWWFMNUOi4$Bz=TQ9Li_{%Or?XD
zMxDHLXRz?HwWx<+xF<f`;9(3CNAsZ%Eu(_}HK>TAnH`xSzmsYywt2|SoI^h0wsYfj
zb$Pgw?7I|Q<&AO-bEa!(n-}6ZhjJlDbbau5Kj*lyKW|PNUB^P%gwb^iwVk8Rnc85n
zfRg8qt}l@+cXVCvw1)QE|7PVq7X|Ml+T0EQg!%U!ZMMF^CYVhAz|rP;yj5rTzu$G8
zjx+lTG9#Zska>5b6=b?_pE$_$!%BA2AoEXTOWcdGubZWOD3gF~r?z|i)i$JArk;9^
zyG)Nb)JzD3H7&6>pXWMzA+UvfdnO$vLXc%=;|@xgj_H_nBEyF-kws$9Arsb3$EhVa
z$$0|j+%YNid92?{sQC$0EWX*`Tl!t#U}Po2J;*pIgdP)(-A<OO+n&io(zvTFEq}o*
z`{GWQJO51Uul^;i|MDN%5|>le)mRhh`wB8*-W?nJUko-wpN1d2@s#BUow!fz2e)8t
zBB>v=BU@5GKwP6(@;~zf>tO?{Cb8EsTf?A99)KtkjqRoo!XAKjVh<op2hBKu*zppY
z*@$gICN(MHJdNOxL%uz_JxY3YOrRi&IEep_14DmCW-Ex0a@oj%vaqB>C+v7c!52zM
zFD&a|>DN?~2TSrxjX{idJ{_6;AUEA|F)Cw(?gEZU7mos5>4$L4l>;pI1bnTojnbG(
zlm1wUkongG%C%x0=c+}TXl%&_X?lKsp^=9t7K8C%6g%@tYcb~v+{<FlV!CxK=5)7$
zw9ZVj0?!873X?fW6MR@fuMS_xmU2AoCYY+kK7NiHKGA&o5lBcF@&5sWJ>rvjT@y&O
ziF>P02OyZ8#yP8L*`<74>|79pFSfANCH(Na{u2mOH@__fs~BDBJkr--L&n$rIHV~y
z$x_8^=x+HLbTJ1j>Ydb`qOsrc-b*xAOeW+4i7?vNS@U;V5i%<x^|mcVCYHAfuS${J
z5|PIp_Ls^dTXmlk$P?EA&N+c#={ZbK7twpzlP}@vBKnT=i7T|;9z<=QD>6GCA6-)u
z<|v+H)qz4tjm8>jNx<^LCpZ~}5iy2rorEu>hCWoshTUHjLXEm$H0K=E<v<+OI^|&;
zt-=rGlvc*0#X+kp!|YxX%3etErS7IqqlPw`yE;bUFLs3_ic>>IdZnrkOs&n`vW8T5
zv!%4ynpzdW&J}wK^HO<aY(p*}*}`)mq$5k*&Q7=+1e@D*k2~CNu?#HH6(`2JC@N3~
zXqJy%oI{wp`7P7|u$)|XQ;WeJz_xaL=sJoY6qu;BSfvu|QN?xuufo#Hu`h^6osG(P
zg4kX0!O=03tQ((%>NqTupa+%keibT0hD8rjGnT|X2u)(OWP;hrq;PR7KINn)9pf;E
zh0i%B9SEF2@?-A92xq9EbKb!pg8C?SH1f*4qYv33;k<*q$e|H6SC$#C?8D!)nCsbw
zKg=BPLI%I^hUXDHOW19jG?d@ZvB6xxy`7V;P<|UB9pc#89cr2y(qIV>5KYhl=yU=O
zOl8v7=x}O^mw~AoIHyqaiR1Hg-Rj=Gm_!kR{Vf_RfR?uCkn612P$X4MpwKaaiTGxZ
z>8f)HlPFNg$bwdZ4O}|}t{C9(Ueyik!^#J|V@tgXU6zNHPQtK3B+4tRyakqhjx0YV
zTL^y+$BP|(!x@&kPkUD2TVjq3sxzT{GSf<kvqg?>VUB8I?zVSIr@wdYzC<p>w@vLL
zyR~`u@TAtF5Qz|?D4HU=L}T;<kS+N0+fls6*knyXrqW^SI$vuh*_h&XE1a&SW;3^d
z)1Tb|yt}0iLxFb1Z4sH};T4CDV{ylZ>)b=y;j3J%fpgyQ0WmpjPK^YYz)X{u5OS5g
zXly-8fkcs-s_KJn6q<)c{1k49h`c<EG^?!#iomgM1wb#gf}mowWAghkzT4`^;P8Ss
zY0=w3?(S8No!k)lxORuz9wFJ*Sli9gP~RFIb*@V}mt&>_BiQ0Je`?Y)oJ1Y6`4yN9
z+v32XWHf7*5JzRKIB+gaoT0822d*Ye!Z_e4zk6ir-Z{EGW2{BlHaqGG18ikg>=%fc
z1-EdDaZW{YOm|XNfqTG*@T|nw0Tg(#i<0qN6P_nCR?ud`Q6@EmsMVg>U28CM_s1W0
zHSXil*aoDXj*y3<&@p98l+PAMW4%#LI9a1SX@QQg$!`Fu&XLY7V)qfkG@zs=YQHb(
zBf=^>dO93k9y-oJuyjm+W$qli6LUyZg0}X#^Zf>ICFsetJSpA|7I|CM-U52|Eg4V1
zSy<H1?yE^`X)cK+w57Q;rfli^HEh}P5Z9{BdFBDty&P1hQInLZnlH{Rl(hYhllFTX
z#l>cFnXn-3*`cW2NIQ$lWIv85yZ!59QqgH2FEdEwhz-Y_4VF&yutvQu;lmm&df5x@
z7VzQmN)2uWX|VS(K}yhII!-FbZo~2`1|VL3?dmuV?N9Rz_#RC^^i%`!9}jHvyD)RT
zsmr*T&S|zfx|`eF4ylwWCF9r9TLQ<kkD1{L&(%B}arFJ^L9DPG#Tja7ZP7jvuBNC$
z^)s_#EOJcnyO|~7ybq@@jo6mQ(M}xE;7!pO&HL1Iis28Tou{UEoBf%Mh)^RI;>nmZ
zZsdWjHB|GiUW;%o1WR-HI>Wwq)pr>2I7AN!T>IHLUz3=lNjS~{N7T0)H89$j;7{1M
zn_e(x1M<_tw_t#Fco(|&<VKT<0+{-vqE2oEIXyi6T`<VY%;p?!lVZsP$8<{o%4Y%3
zE9!I-kXeV^kTBZ!Zbp4I3`o((vH0J)${u9tM=0ooB);o8gUlUzHjlvyKY-m%>cgFi
zCmNd$FAfFEz(c0N=gcel_B~&%O8f8?pZ9!g@U_MUKYkek#PGAk?GKx87tj1jXZCF*
zW_;{{B>7q>f!L@HmWIcA$6#EeLw@SZkC4X)WnG^=pYmIJKb?wDABV?F^;DcP5PcyP
zU)%$N+vrhhBXuT~-UFwdVYXuxHjSm3BDr9;cpTC$Qf$n^O=c6dQAC}hc&Ncvu&5QJ
zni43DYge$VnM-C?ZbTM|H^WKi(Oj*J`iZ!Qwk^~(E`5dXQCu|UQ}?JvG&Yj&&6BC8
zQWC+#dTFDyV~#wsYEeCHqJF@+(QfZ6e@cf*t<$paQIej*oTskuzn{<;BOgF~uBU`!
z9;(hedwGD|LceAJPvalH2(6$WIqB|ciYFTDc$7SCCg!N>>!K-5A^y%?c*ShOMd&Y_
zg@ma7T8=ezL6ANlBN+|u0h!vqV?>xgoEm0K%C>NXD31Jtj^xEwkAEaV`mPVLpe+cD
zW=$47FJ4a{GoX+7(<cK2HCs@Xfc{8?lIQ`%7=D&&fwEM+qp>S#w>Qk+-q)W3KN&}Q
zLj280(KEt%BEDKxxg+oaJwH-Zvjezh^fM6b)&1y|MI}vs9K!rKYz?GRbVPN6UC@D4
zrLXtUz5Y1t$orrSVsFH==PU?P5B+I`boh@awvln318azjJ`Vf+bteBF(4xV;qEbhp
zt{rKMZ{1})%|Bj2-%uc)l$H>Gy9BDOAXTWd(9bA@SFA=V9HGBdSylDrs5)^Hhw39N
z!&byve0pvqOXgn)s993S#iiI-u4NXonf!>rYt%5xB_c(tyfv!44fG+qh;I#<dNqBh
zFCquq`D1(5XUdw?=StOAT4!?~o!$iIT55UZ_2PU0f|kyl4)o7wUL%?R(WEj{4DpBf
zb4xh28VPz;I@2ypl_36vf>+SD><T;Kgv=dTF<S+YCerHmCe)i9O|j%!iZ@Bww{gE$
zQ`e8d-hfZ8888uh+u5|LAZ76vWQk&aNn{XW3Vq+Co{&koDDv?4O&a#e_7U_z!>cdI
zHiMPimt2`X022+S;V-N7p49=UhWFyDcW^jTfgFz5ROF2WsW(cXUW}9Lx@)w7MQaNI
z)0F^HZXW{1+62VF3SmJKL>~iH>E6Lkg?~`N-Vd^qvn|z!NR-8S4C=?xRrEFO*^09{
z5X>1-^DHVv38N3dWk$#n`r~hOZ>z<fIN{XI4C)(THm*{|<*cjvq?A>b`iQ3Lq4Y_v
zaD*EjeMI$`Z(uOumL5v?@(t8XPwH@@(HDJsN0fw>2_$S(5|{&=>2<2vY>GBvZ+9eP
zr2`*?wxmLvA<q6yT4fUTO<K3TRqtYZFGlaQ>#TiiBg936>G;dO^%?%!v={{~Y(^zE
z?OU@g-#S6bM!nT<blC*_8}nTV(DqIufO;L2V*#xwBb?Z0cA*@E;xMag`pjCD8Iw-5
z2r`pHk`VnN9;%`C8M?3I?Dk+e4N8t=tl0Vov9)Av;)+qgw&_)CtH08~^oKfT!$?YQ
zGg`ik{09tzdQ7GOOoKuRpcOH_km!h*Oy<Bg+lpFkTy8Y>3{Dv!Q1yZcYPpV6!+ftg
znquOH558mu5)ARg4#fz_5Z@f-Zw9f9(lFmE8MX?JgA8gP`rh8iq1I;<m4nmBtukug
zuod4^WwqHRQ>j2e*=A8Fyn?D4jwpNhnp8JC4BOg%dBd~^nkX9V3oceP5asW1^8M8C
ziY(4eRPf6%IvF{jvlngmsM6EHC1sqVxR?W+-a3{G3lXze=+|{zFpyM&LT1$8h$e{!
z`vb#TEQ$ub`u?i$3c3$RhzgA)Y`lQ_K%;Dw^Q7H!#6>eS%0u;4wT~!n=0uL{I+hP5
zh)p!RuZ|S}l4NL4t76Sg0){oaDaxM(<olW771_XtBSf_{J6@HQgL0m=Yerny>r$C4
z)xN=DZB&F=ktL^&3xF0RTU5KZj(-vXND`t|yAG<!{L$ds_tZy}A}c6~5u81T+nk?C
ze+$LbX>R$n|F0ro<JsHR)8QRz_I3dwU9-1u80Wd@TH>PF+sG1=|ExQxEIm=l=5B{a
z5HbmW^i1_OnR~Dv4^d~cvg9Pol1sHv?RTx}pMxNkOy52p2hOAXQwrP?=&m_jU<<^0
zIU9G^_mE9uGrB9Wz=Q-wvx1AzU59It^j#^xebzw~GcGo4CSCN`V4FaqnaUz!2{V?b
zB(+FK`8Oz7Oa5S#HMJUr^O*?Wl!@Z*2tbNkOO+7)=+aklktjRYGNi*nGQeo{N!H+N
zC_^iZi3fcHsGD>Zd}ec$V~cFZVIO!KKVp(|+61gp0-ObR6HuoFr~v{3)JOL0gZxa^
zl&q&Cn5{*|tL*UjnPwDg{|9QK>qhm=2)^yC8-A?&7u1cGe(XWYRyR7~2IKrp-5ys0
z9Cf28ea~q+O8??|&Qzit^{i7(Zc{58YK>&9jFoSp_I2!&a8xp(?(1`K58wV5HCc$i
z9%~M6{N+g9<7nc}Opz69R2J@k@Q=4P@enr#Sa!}E-2P4!)8E%Xe-zY6xG)3q_cB|O
zzIt4Vbd-N<fknohbLk6lDhWoXOytSAfaLE1B}DuCNs5a^*|`=Xt$l)WWCS;pm&kKC
z>8icUu=@LFe^5g!W++XFrR-t$uc#|qa7TE-Vl^Gn&T5m|V6j?K6DVSnKFi8tldgI%
z)hr|U#?RL#O9>%&^mJvrX2Sf<b?Kd!0Y1fkJJ{iNGi>EjiHg-$tLGIfOMk#Eec!da
zIYB9Ps(o$FeG!h=jAX1h_s3A9F33$6W}uzB283vEJpPg!bzBkV`)-v>SH+G%%WmO;
z)yC$vZ16D-gex0ZA*PO5(Wj^o3I6xf3JYb^kGk~G$^+Cba7o8NIptRB4YbVBG{7AA
zjv=ILpnR2ao)e0Qiw4Tf0+auc+o+a)UCY_>1yBB{B<rEp6Hid;n-N;OJZ0qR19=h5
zY^_~wgrQMk+ZqS)qOt^J264AJ-r}uB9F(Zzp#(h2Cuf2)qkcV3wM2uHa8K>fPUrZe
z{L_fsEEr_-KvK<Ov-fofEY=`PED%e;8f2%5$d1|J6(l|!A&ftwCv#unTncJ{CscXN
z75^hH-OX(!#&P1OdkZsjI7mP_)*@6oNei!m$s8?QxfJ?v3->(PY_ZXVbhYs3jPvBq
z(JeeU-{e0nNcNin1=wKouo_L(bhmJ>Qs0Z(K5CyJl4WS>N{ykirr_j>t)Zh>K0&=X
z6Eb6dP4Z!F0@BdoI&MH9Nt{Av)SpQ+04!l}FNwzdI1Y=XGAY)7RnidZshm_xIMe9F
zP=tSWh?Yk(6lW7pD6mR}nt-}SlK-Rww$>WfE>8N^P{v*?M=e1bN~W5XL}M?gT)84-
z110T7&sh2q9I^c`_(O}(w3m$+XuiIMP7nQ~y-d(p$bPx~LVMz5NpQ2O+T@XJ=NCLX
z(NrXs^S>(zDI+XpEV1!)Ot2|&jbgAZe#<-<-)O@rsE(s;yytZ1)y?ro;<f!~r*4;r
zU3lF<AtzqdZ9P`W?Lykbo-@IWMro4dd^#m%HQ70eS}W8cF3H?>bZWyUSvBHlCz8L2
zO%46!29~c|^FvB@U-y4_38AC0BVm--a!M@OPRsnx?@q`jAb#k~eL4}lQ}~##9qZUN
z#W$4@!d-jUnY``CyQ=u62z=d6H@6qn??RFTnr}M9qI7r){QyWTxnn;OCy$XIA3qCE
z{)Dh<*f<qD>ZBXFoQ?T?Y%`G&kT09+>e%Cu6Am#|uzgEIy(1b6PyZy8N#anR`W;i8
z5b>u=$i=}DA}NO4H2k0;=5P@@VSpo5e~PuDLA!0{omlHQgF<!Brp-=!;n=y;CA6Ug
zys4%teix#>s-B4&#whxw$Tk}E)YmZnNYhPH&Durs#Ma-Op!VD@>bG0#ZrWokJO;VC
z!p2D7o}2p6!O?}i7?GPc($~2t8)NEfd`tjGTA#<`EMk-ASx)Z2-A8;EjlH~>ilOag
z^?e0An`J!h+Y{P~{oa&jbB@~x+c*!7sFH2l;id<sCGs^nBg@9`;x_6Gs~?(`-<xHl
z(J8sQZSWeNcitIc$D_a?-*&b9QcS%52?q;pwl-5$@gs^Hp`TT8W5o!hTup}ILh(dn
zCxME|Hs!F8Cn7nLk?N$&LG<ktqy67%U0%t>`-^u_8)M4OxmVI>ocLUfaKFynyw{61
zZ<30ANFgLF<E?LvVAs^sSjKW_b2~^n3+ZSK1DIX_!8(jb_gDM8q2M$i!~7c<;Rx?6
zn+rMHF{shdPmg8&(cJpSDi%@>7RDc(pMhk@)mj9lNK@5Km)JzSkFQ&Z2;WM`^{u2G
zE)urjNKRsy<)qqJR+?eh1p^Jc0He8bi<X1i^Ba~X`Ndeba<!;JqglO-rN2RSbwy_a
z-!TzWJU~o}@YmAweSX$^SreUh*vv$J#o~;OG@T;}P>F!3^aSQYB#?Kjb$e`IPxi+T
zQ?NJ(=?NyW$Tke~+IY@#$D>@bKkVXLW;6I~l+-a8+pB=?Hp?{gT<u$ij97{xHfT#g
zwB4RarG8LJl_oiDB^DuX`*&nZaTG#W)?4+X&f448V9Q2(;~iMJBj{Fio|)$gUjwy#
z4lxO<Q~Vf{btZGEYLQS>i-1(?-bB?p7ad$x%U({9OK>zvKa<g33h|*70;-gZ`Yv?7
zI&M=CsKqp4J#4S~AOC;@ohNAjm>rOAoxZVdomQ*2uT~w4;LcPD&W^cZbs!_c`OMBV
z{0Gj%b6K{QIz`~_>yu5<nGs@Bn>v}kTD5$H^6-06z(aciV!V17X+BtbKdD4(l^tQ^
z8yx=uAG3fpyY5M1!!I)sz%MiO0nneuM=!vyRIgQjLiaUL-#t6ISWWTNw2^Zhi5&I`
zP!nYxg{%o?Hc<o*BA<H$W;V}LBH?I{ktT-Ie4T(8s^zOfz(iwv9^vS3KXs=@2sPU9
zk-n;Bkc;E{>Kj-m@mPnfR}q?qn}Kwi5S%>X&{y6&MrfY1i3cO8%Bl`<B{<5>IeTw+
z4Me}}n}DCt$`a3jnyEss;JNpgd=oHoJ!wy$wu;97xq$CEe~|K9;udfc6B6e)0S}`m
z6I8_cO~8r7JktJ6zzL)r9Yi$033w(j9cd^T^Bm{tlpk3O$GdAZSMp=71TFEAvAUZ!
z;;s2FVPLIzE3Xt_P~;D!@Y^ws{HZTA34b1t-i>b7+|N_a(Y~gtej2lmFsC6uK9*JO
z`mtj0Gy}h}>I}`j7V&|mTwEAlzqURVb|5yGQ5~pxUV8f^tsv~9K6<Hi;tzV@>td8W
za`;?2uAqiU+8zZbP5i)#SHqPj9k+wgbdrx->14Bb99`)33Jv2R#r*WxO5ZQx8R*U1
zNE4M|55j=;zFsTPE!5iYtBh0>{!gJ#-QhKI{7^T)C(cVUOR*NlQqV;FiX~1<P#IVq
zu+9*oWMvEWdQw|rQl|A<;57kLD(Y&!7I*{-iyd2Iy{B^??qvc$54V`t+FvGdp4g1W
z);&ht(b%-jj`^kgq<4}p6Tlm7XHFBn;9+|OY|%UNu|%4B<CBI+s;&YfMPpZU()9`$
z*0QY=-By&LnXb%d`7<gMK3wl}<kB+&n9yeUq#a&EuuneK!%7Q$w^fdyV%Ce<`{I(=
zA()Qim~1Y3Y%>OEsK(I+PeN$Y$!JG98w#m>^idsHhx6efhgcB{*gK4l!C=7hw)y55
zdeLO4!|rhx4lRNV6r!K{Mm%mEuiFm>i#6M)emr7d^}+KG3q&vIn5b3DMnF{K0-HNR
znn6Q~lkC<s8P*R#LAEoUwv~5fM{_-39(w8GNr;5YIpa;ZifZAAH&C$)thS^68biTO
zo^QBAB;m0=%(y>=D+kPJH5ZyRCOe<bdZSuAQgO=>27Q2P8;$ifBMshkvYk)Awgnw!
zpC_HoXKwfuY(cFp$DP0Um9n!Ob;n+W%$IswuX3qn8#E)1GjC6S87l3+_FG`T1@>ED
zzXkSNV7~?STVTHh_FG`T1@>EDzXkSN;QxyjNHJ(F$hyk&=ND907gu}d*Hj0*bBev^
zjP>S#Tv$<F9jGcOEf080%Zo}2!BJ5Y@K((ARuz=bD>kn4R#bTxc&kfqEcVVXt)5>H
zC@e8ZlqCpq2$5f1Syfs-FCW<}YXXA<3j;>LYb-RpHyB=H0pNlga1`_Ms?tE9xZImK
z$3aG6L3w#az*|^VTo5SsRtJhkjapD#7=RLG1y%EktGt1d0?NHGpH#{oXejEaQTdbe
zk*BPzqA<U-yt=q5V5F$avVmcAo-3)Q2kxiqRh`yMwfg3TEq{IgqeUN#)oH9E&~>v;
zuR87FTURaZDfG5;f7SP?2_N6MRODsmD!!8h8o$tvhEY^eGpDS0fOm31psIA?s8JP_
z#Z?8Ue)hm@w9z0mQeYs-9#T><zj(+s6$@@CC?7Iz>iMT%GTwK3VOcR!#S4e!<X2ae
z)dWf_%7>uEAZTz&Wu;Mi&e$C9fC1jpF;xVvk>oXF3Jv4Dg6d*#LCw7R#pQwGA}_Kp
zDE7`RC@n*xwA_1PL1D$5(t>hB-*^jA!2EJ2V|LMXtQ_?F8NLOY?|;+YMa6RqYRUrn
z1(lV><wgI`w0FPDK7Z)x9`E1{VY(*frX1a4^dcN6{|c$bneq5W+>f|A9&ZKo19k#7
z=EvhJ0UySeWh+i2&nb<^=@(wF1Iz}j1@r^n3s?g91mH5j&4B9wy8xR3Gq1tYGGGp1
z`hkX#2j~afc5OUf3AhWe0q`;GUNr)~H9sEz1kfmt$J0=5c11j%1DFSx2Y5~>9$yG}
z8Q@C5TLBvZ8v)aBlKh<8<MBa&D*^KWUjwWJ>>rNDmjf;UYy@nqkH^~pzW_AwLF7I-
zrr-r^0Q3WH0xSV+1zZMrHI4{u1Z)I+7jP%w9>9a{jK}-pyXgG^hXW1=oCf#+;3B~9
z0M`JX*AS040p1PR2Dlc`z?%?z0lk2S-W8AM0tNs}0Cxb^1NON)9^U{s2k;G|1MUWV
z1F#nkgnS1$2ynqYI35PL4X_Nb&vN7k91pkwa0g%u;EWY$U%*EIGx7S$yMXiyc9-1?
zdjXaJRs!A#*Z^1$xDjwCU<+Wc`;Z?nV<qa1_q#3w91i#h;55LjRcIf;#egdT|F$|F
z-wb%{gYo!Iz>R==0e=AOkJssPABxAv0Img`2{_=_up8h6z}0}a0&WIe3Aht*>Ke2&
z-hZnHJPGg}!0~{C9>&=az^4G00{#hbE#RTpUEB`n1^fi?A;5IJ^4SWQ4S36MU^l?!
zfMtNs0@ee@05<^s0Qd%A=33Yt@It^|c;|H^_B;jw9``u%16~hU2KXXiJ)j3WKN|pV
z1$-Bf_L}zqz6ID98&7S3!vVKH0lNYI02lx)S`R-3yb*8{;3I(V0uKHy@&m2~%)&dq
z9|Mj6Jaj`mJ_GP3z=eQ+0bB{#|4H~c;KhKgfTunck9ScTFbl6l&juU;SOYi%@aU&u
zH^51NYXOICgxvry1N;QA1TYQneBT6k5@0)^AMhv~uPXs80bB;S7;qh+_jm9YzzV=U
zfKkA{_(_ZJ0EYuk{ypjqcne?v@Fl?IfbRfq0?gQidIO#SxCfAqVf8&4aRqP$VEVJr
z8*n1vLcsNaD*?X)Yy`aXIrKBY?SMvq!$`pvmlyCbz+Aw40LuU$1*`|`0NemLsu6kv
zP6F%%yb~}J$6Ou;%mMs8U>@M{SfdXBP6k{KNUu_C0&D|(7qB<p``81R1K1bmc8UOp
z1Jdgx(*Rch1^^Fw0eS<D0c->e0=5Ev2G|971oqUjjx&t207n4Q7ma5CJ^{E8@CCq?
zfCIOnp8$>q+zB`ta4+Cu!2VwNH{ck+R{&=Mz6-br@Z1;C&j4Qp+ze>Eg#3VBz`cOW
z0s9|s7;(TcfZitL2Mho%0=yM)HQ+OVn*n=lMSei~ApKsz2Lbz^0Dl1-1K4XD>~RwO
z@nzTn@NT@_ya=%2@A3F-&>sV=1>6j{25=`}6X0IJHoyfRqW_)<KLE@I419$C2lx|U
z8DO6_v?pLT;0B@tz5#e2;BLU8&(IDi?_R*QfZosH=YS{0FiruE_yX;HGU7d84&ZXY
zJixtx0l;HA(B6Q%0XGqSH`)vEF~Bas*8sC{X8t3<5r9{JiS`1l1Y8J67s3c%DK}0r
zQWj>W9Np`H^oA6LhszmRGvaY(9e)5KEp)^G;dC<{wgI1UXyyfnW?h(Z@b&4n#<@q0
zJoSu|U>TKvCg6<APzOTDMdbzXKM(jy$}bm{RgeEu3UC;naK1w`Z%sY_ke(MnAtZ^u
z0sqJCgZ>8SIiMpnS@|bh`F8_70Ca?2i+-U+?*)C11RbH>qEEEwgFx>E`e-}7%A(U&
ze>Ug{QC9v-EP5H}UeM7MEc#^@z5ZwDlr81Pyh+?r2dtWZ212E7FKQS1Z$SQakdt=)
zF;*E9>U-3s^(aU|QDnzGpkFvAu^uF&4F8F~9Waf4gG#pr%Sqit8fSyH9REK9UpAHZ
z10-v{iIE=lX?30+{isCMb|tBpUlqpV!;r`1D^+zTS#9{g2XvOTZQrssK~`r`JbnuD
zn6j=`vPgewr!LUHM66G{-6rcow!`0!1S{ELFXX(qIC*>Z?_n6vfj-1u&RkUv<sSq3
z4$za;X%qC=ihi;cHb^V9=`l&{vmu>@k<M-4-2hp);y&#f8?UdfN9saVrWdqy=zP%4
z@%WX*H^s)6dMPuJUhhJ$T<{FVy=k8kOU5L~m;(BxB%_aAhM$?dz*mB&R+sY)1~1*V
zQV!`nCJpuh&w0?@r0cfNvD&@}d@Z$!?L_)61$`Ij$=Z|J=?l;ogE#FOn=WLVN>wkC
z^9JPPF2S4t_ohBqS@hkYk559UJVmgZA9QYmKCW_XZBP%s$H2#J@B=0UF58eUGdvhC
zl9WaCg`l^Aemd^W{6&_oD?$GX^klJ!J~&MI6U7>;OAhMV3VJc_)2_7XNH)7%mE#3%
z2Kf5jf^n4i&av^OPGu(2^`xGdtAS?{?oC}&&o}AgLBA37JO_P(NiPC@J?P2mvJ~{y
zpwDpRSAmntUkm!XN%B)&`@<GHK<BzHMyJ>9;i~I+@TJv>-_Nn}r7FLtvNG|UISf3>
z>Y4-k)u1P<YaZx#fS#<bm7v#xo~*77pf`eks@)a^s=Y|Rji7G>{boBob%AN?7SK;v
znq2=*&@To(nf{rGRf|DS6w|yYGY9kr&~LGqPj(JiI!*)6SKztZ&XXE4bqs($8?S3k
zbkK86`f|{32R)GvWP?qhuLgaIBfsjPM1L3bpFmI6275s7+y}icp80p}gFYPecR^2P
z!)c(W-I{pZ@It=;=zT%&VUL?+!*4Act_07&z;l7Uj^LqMQXOf1;;7paw=<Q|3i<`0
zFF@=x`-2+)3R6YKUhu5MTE$$jm^`VoSP3ss{jrwuA?Pz*diJ>3itV}J=@-UxuU*Ek
zta{7_eH7@)e4!Tf4WLi7=TEhKVGZc-f$p=@7g_R~K;H{`k)58Zf<D=)4fNdl<i28H
z-Q^L`kGJQaVafM`{u|KGwbRiK*MWuP=YqZs^hCZ!v5DGg6X-ACKJ8za{n}&GlU6y)
zAZJ1ZFNoO7v5jr(K%WhIGCMSbek<rSCYfc}<^(a&n?O(2XVQBiZrqXF4%wie2zoL*
z_(4Ap^h9>>LZuSWhl5UIxTzocyseJ);JE`liEKbJHh{hk^!08Tt1UaWfM+n)xf1C?
z?bQjo7xZN9or(3Z<3S&0FGJ?3ls^Y_T31UZKM(W)pksN(s^=t2ze><)ea=xw*x_37
zrv}i^0)4K%-}abAU6!ALHiEtg>v0u!`KfABO8T{c{yON%#+Oded)yt5Pq61-Z0VPY
z^}JJ)(8-^3K))1phabtDFSWvwGXs3<!I#X=^eeF&Kp$Y&Lxmo$=St9j2YNC)H-f$v
z^iS;hQ$Jt@$PTTbm)sMNpJk`dxAf}*eKF{zc6#b;Gk+EyLYqNP){Y}Ue-ZRk?D^#x
zgvy@*`VP>;c6#b9EZ++pwbQWWh|joB`##h1l~ko9$yf~;OTjZ1_hz55jkB9Ue;D-B
z?R485awq6dfnH&!+k9m&=>GvdnXmMRT4%0E?ki(Jp9y-hzA_W^a?n3;l>d%t<3*sK
zdT;Xi`fAVzgPzO>HiPa3Jy9EFqfGie_rpPd4EJgGA)#aMMR)Xwq}6-sdZyk@%8;$o
zu?~DEcoRJ{5j`99HK2crds9y8PO~n4(C6Nlye=i6Ujurwx-0{ICg_Rk;zg0`K))39
zGJE+HKW#qu26*lV&rmy$Joix@c7whi^vQNQWZaBe5WN?aYXv>g`U&;@rLgx~pg)59
zw5!m8v^`0W<!lPW3)(cu@vn@>FTuToXPn}pvKE4;8a&B-Zzbrz1$~HJhV9wA5%lLl
zzuZnwz1VDzR?z<m`k8imnN@xl=soXG-nX)_NOU6T$<~TSfY5Ir`DcKB#y;{d1bqPL
z6?XlkZ+d}S33?6a^XzoB{=!dhWW&wiX#@{E+p@E5y=*7w>p&l8r^|CJ<=+eXtDqOy
z>8Wb+L-hWbt{n70;yEVy!*ba0EYR=AecH7cSnd80wrpJlIgf)cSz9axeKY9E;@n!$
z-v=GVS!Kw&9QE`5sK@J|*Wy0yM@)3I9#%i+mZv&(Le_Ds63ZfbCOTkm&=bwOy`blS
zem3a)^6hEhnX`{F0-#R={d~wXb-mHD*K*LW-$(vUpqD10laB9#eii8DcKOP8I9gCW
zyTJ1(cm~;d3N0P75Con9J=uJ61n3>0JLWOAx!erU(^e;sMGHYc9Q0&sp({b}3;J-o
zel$r!n)Gi3J$oPdTR}es^h7@6MgA_(j|9C2_huVV9GhpA(I0zM*MMi3oyRs890U3y
z(33s8%mn>W(3ADAMWBBMda`)E8uaf$PiCXdpnnH?vVOA@^u7-!?{|Aa9|(Ff8}-k^
z0yF6Q@}pev6ep2E?KB(o%lARA1$`pu$!xF&^eaI}b6M?VThng>J#QcR+dwY>Jz0!2
zj#T-twaZVP!%jf@dqH1?{5L!3)_O}W=(K-)o}GS!<wLVU@BdKpHmntTz@9%<IXacU
z2J}kgPo`fJ=r4eNygk3|`Lzx7&7e=S(^D@p>t|reuM_k{KEU+{eHZAb+4C#&a6ili
z{Y%iN*y*V%ICJ}he%!CIAM2pgj6?O~TF`F;Jz4o{K)(U>N%s8cr}W6;1+EG7M?pW)
zPQOywpHQU3C*a9`A@SUb=xJE$J$4`TlR)nada`~vejjuiCpV)FDF2OA);ugi>hX!<
zjcra+4>@zew*-79k1YOsf!Y9iGw6%#bdpi7>PvNL0grccJbt^KCv}Nw?@rKf2OYzp
zRfcj0wpAvCECwCJgGIMJzvh5W`@W9$u&o8>fxZUxMD0PgXhvK72J|;!hO~KURvG@f
z9z8aDOg&dZPAB@+u_-n^dK}IRPaqkM_>;XYaonJCa!}8=;Fq-Tly<bMoXh!fn)l0Q
zfbY<U<ME#m3)9kVd}^(%;|OR(<z-_V?2E05?dk>H5BfCdlWa|oblQ%xhQAEklTN?2
zm4!C!(NpO}WzinK_m$+&#<aIT0Q9rKYx;>i+j@bbJ^wMF?`!VZ1)f^)B#Rqa*zaEg
z`k(A&r0(GMp)y8*p0gt!f80(dU%a1L*q3I4XA^jm_3cHVKL$G4#;k{Jzh*V)>p@TE
zi<?3JHR#D=^G?uz+DG|&LGJ`T(Oi#I!j}yCP4nzbF&<Cx{3pfuYl`QtRHG~9DyAGb
z$MbNCv3M*eGMA>npQ9<B&r*zgQgMr{iEuN)@<opEeF|;$?&{%LIn=m2&2!%w##)c(
z>7m949?#~X#v?sF9}hLQ_4K?t)Og?k&uznu=MV6FJ=D1ONYCBFjMt8dr0f`Ge0r?s
znPJ8|$NxQj^)Ta}p?`!+QK3U<kK>V)JbbPCiB!+WnZ`3|%Tiv=G~V<)*YlZ7<KteQ
z+cS;3GLFUl6TOw5y@sGmUgeo%{7R)sjQ-#2G|;Act~9EX^QMpTj5DsZ@;cH+eASUD
z8RI=SrYui6=%Ey2BiV_%G+k2AA!C87^jvQ&CnDij9g}j{X}F)_nUzwT;t8f0_c`*d
zIy~i&F`gMIRR=9H?yxA3mp;LBsZoxsbbpa&icz8N`#nW$+fzIZ2OA%ycz!&{*m5us
z%-4HKif472@u!p%e(Yhirl}0eQ?5gZT$MWFi6O?{Qa#Iu7+cU>gN!eGyq$u?D;`gL
zu(714=jlPli#<J?2O0Mr;Q4qEwbZMFjLuBY*Mp3A`goonY<$?q^XOpXFa11`!N!mM
zJbMQjzdhn?+&5%-zCGRe^Rb?LPB(r!$@9$V#@drT51wwkdota(Wqba9x^e43&#R{!
z&kdye*bt>yqUQSFH`Bh`Y1Q#5{hm&_(lGv*>Upb2%0GK}zUyHuBTMO~+(%pfd|OdF
z?7#L~V7~?STVTHh_FG`T1@>EDzXkSNV7~?STVTHh_FG`T1^yQn;DuhSlVgu`UzdK6
z|B@DxaOpIiy|$+h!r5oKu-mIHoC%-{$65IDKCB>?y!mS0tss^@`J(+hy0EUqSBubT
z-IFd&|Mn-fHNH{G<HZ`#GY?=kqo)E!o6vF0kFPr<ja^{Au>HdquOZ4k0bw(YuN6|N
zX=KZdn9Y#l3@i`x)hZR&czS=6F0Hp$42NTXeChJB)X10S`%$+3!Op0kBps8A#3ilu
z?3DCFLjSjmF5>^Mflg@`x4;}}?_7a-0%r@X6j&>;LEsvJ8wEBAY!TQduv4Icvnq6D
z3iJxh5tu75PvC5Ul>%!8HV9PG{`<e_oz6TH&Od*YH+%Y=n({!6cjy^|&lsF@`dKxc
z9JYAa@WDC52MXGm&z&MSNi+T#cjL)#Qb3`14CwOmU%V>_n24YJD%Hp|@?8C!@)5q)
zg+D{^?s!0Z*eO`G&-*8C_+G*3e1C+Y`>DcW-y1h1-+X~g2+NqipP~D`=BIsvMEY-L
z{ys*JXB4M&AMTbZMjs>1g+B!hg!j1cvjyMNg~ysR^B>^Czb*K57d{RBpX49t!f!~T
z|JmSAR4+g9WS>Bdsu%BL;a1o8U%yLS-#sq8uJ5-lysqzeF1)Vq_b$AyZ<h<N>-%pP
zKAFE&vwaX9|EBb}|4n3vCEzFTE&08j6MI}N=SagHXC7ocMhA(@I@j-kKLPffU7|3&
zpO4!Q1wZT@g}+oX9EScw{424~MHlbg0*({>)uoI!?pMILS@6TwD1;s_=$Ac6&PjJE
zyq5Et;E%an;fE<;9EEK?;$K#!5COqY5&VV;3UQ0zmk9nt(VyR?0_`oq_pVfoeT4rQ
z41^^A#(NY(>zO0?zZWPxoq43ISnyN%0D)m#qR__g1wZ~gh2S%!xc#f(R|~#a_z%T^
zOXYUVR|u`oSi$e~Df|rKe_Ze%UZ4<@1ixMIUrkX6EvGjIRFeNMF_^~B06x<=+Q@Rn
z;e6rWF;2<B<^*4Lf`4(0N)HkIgMxRr;}*dOE>w)Xe~a561z+@#!XGbk24b`(J#WoZ
zh`R+}D0sI%w+X)V8pWvVbutcAcu_CIRj)UNf9!0<KSAVwEBG%ibILgd14eJeD`TU=
z!)^FF3wYA=g{dk%Qt-b4Uh5zz2F*$E--w(SCn|28cNFF!B!8j!zm`8!@NWAr5d4oW
zJ8S@6%e3qBs_+jIe(baIm5%uqmFvw_>0t^O0|mcR`o)QYA0hbKixpz7;7b`V2^&}{
z{L5(I!?joe<0HYl{oxSI2T7l=#NV_&xq{#2vRjSdUo2FDb=~g*z7OOaC=*Y5XOymc
z8L#f`f1ejQJ1Z3SOd)<EcthgJP{E&q2|DSyRQk1^m(COXg7Jz`_xF0iFRNDgX(Fdl
z@V}CFsTF)b90w-({`m@_%gqN~*HKs*goJ;*E3Q5w_}__N@p}-+@rB^OkOtKLa3lr-
zuGefOUEBX^!T(3}sZnI(H^BE!J=$>3>oyAi-d`(5t@DS1&y_fHtH|k<smfjUfI{fF
zai-uul7OW9Fa3xw={abY;^(s)xV=a4UzRI;fda;dg6}2mqT}k7y_K96@gE)k?-l%G
z;)l9@w+p_qL<yE^7zdz&q>p>t93%L3mn!}u(dTBtpCseyXu&@y_=Xb{;uOI@FZeYN
zD#QT6e<1j|(oe<Rjjsgn_RqnGDLofTxqAF96nvxL>794F77Ko<_`e<(HVFRl>lEM3
z3K;YY=wyelsukii!H<Swgnz%kLck69ngKji?RHfO|M%A_lID3B_~YSknVkwR-P+h9
z{9oZT30=o4VDv$QQn`1FBb+4os|0_lI8>hC7YIH}Dq11<hXkJ|{YdNcx!^CYQH(lH
zo`VCHRIYozR3`Y;^A-P0Eno0O;-6anJA%JK`kijC&w<xGB7(sIN2qfDDuGA)`MJRN
zN$qXu^#q;AC;X>NJL-0sCHRJW6z3$#P$BqxuU3c!f~W7&P<?|BDa4-y-xD1tk)9_4
zPy88DFFoE}EchW3mxhR(BEioV|3s3n#|6Jq<O~=5XTT>a_sAnvx$gKgLGbSQIa~1O
ziGxV<7<UN%jajNdxB*{uK9uT}dznhF7kpgshk6x)zRN(@DMu;(Dj7$#&hrKTocOKA
z-!FLYSe0ML&*uey=v@l0_1P)-wGt0y_%u$zREhL_&D9?-5PZMsN{;SFLBa2pdTIR2
zf?qmY@efnLphJEn|HfQ}SS<Jff}bbxLCaYv_-D%$<CVhyu;82g3ZeD?li=NPEDioa
z<(?&iwLXIcf3@^G?a$K%Kj11QUym=fz|;KUhlL7H=Naj068;BdywLIFN5MZfR`F^5
z`yQLv4^IJ}^mN;EAOa?p>qQ);OUL=*Byyfef`38ee^#XAJfeWHNAUic3h{~Hha<3P
z9}^UViAnI~z?1$z-LJTBmrV77KTz6H%X~uc{l_UrZMSWLe?#O96*--PzpGLqw46h{
zs@xx>9W{Q6;P*^b{POr@EET+a{Q8~XU%W{1Yk&Ae@Fi6W4>kDe1%IOY7D@lQQSkkN
z*E$G_!8O94b*aK?zkO8jn`B&*Y8X8+-jn<}!mste5cov$iwU3Fiyr12*R>*N=Xiw{
zaYk71XG_06S8}~4c(>i?J4`gMb3Z5c1)lVD$KlHb|AuRvx>@iyN`>?|yGrox@w!v+
z2Z_OkiJl|iFjQ`)_^s|2<$~WM{967)g8xkX2g4;_FA2V-NToG?m*5YPcDX?K2cN9U
zy?U-fTrT)41;1&ILVPOtpx|#2`I80zzTi)prx4P;jdWCm>h<&#h1cy;AoyoR|Dhr$
zBKWRcg@D?8JudjGFHq^51%Li2O1^u(Q6u=)HHuNP87~R`4$%kh%2%&!dM@s7<aVlb
zW{QF*08je6*Eg;ZeEc58N9WV&x>N9m^wSp<+W0~6bHu=U{5p1^l7DSLF)kDS8o_rp
zD1_!;Dfs3BCw`aUM@>_B9iI<7RmmTJp~CC=#z4Ve?`p4W1^<1i;y+UX<F|spO$5&n
z{AYrHZni>vAovpz=V=|ry<U+6JlS(fu3|)U@HI#9?(wu%@So-@K3(pg1b^yr3NOI;
z68KEC<BWeQy#D)*@E<L4Tc!)fF@uyogMErq$H~!xclXme!S8rb@t-9H{7&%e&sT^%
z!M_iDqWG3|x+>Q_|2$Rj7fOY;i=3-~Pb4Rh1pl<iaX;_8CV2Na{tv<bTl_(QF<`LL
z^PsDhB4N>|MDV?&A1x95Z-FQK>wY9?;}61rbA`g__Sz}<I*Btn4$Oh0lAlb>SNu?q
zuLlG_N)(joh_O@fv+q`Xi-i9x!S@n5n*Wd-C4a$m#i(sNN$_V$9M<@U1@9ieJ{7#D
zM#-5Z<&H;1NdKMHPWd6=wM=1U@T~AZQ=+iay^Ze$KWCQ0OSd#84pZ`D{S{uv`AY@=
z;av)^+hwlcPpnk<as`Z+1%LfT3ZdiV*=H#E?&tUE!1s~7c2JrGzf|Px68&|5e^l`E
zWnQZFOveLGBKg_ClRXDisZ!6A!u^78nWzvt?@fZgae~4R6aH5P?~ecd5a>w0`?=$6
z!5<_I%iqU=tfzq2Wr=78uL!?;e)6ft-=nxO4d81}5;+GUu#i4S1{B{E;V%&UvvU;!
z+4;It@DEj}wD$AYf%htu<L~FfU%yJB=^Z1wdY`SzT_F8M#2Mp(PgLKlg#UKwkD7m_
z;9rxts`I`s_}_>hYW(Md-&>{hxK;rpV}#OY`80*lesYfBhl|5v7~-o~@R!Q`1l@<P
z4+K9({6xz+ex#D`UjHl-{9wPzf49iFNARCrtPuRIBiwEg{7zxKUHIP={3B8!UEhO8
zsdByI$a<bLO7IibC;>N%oKnH}yi6e=maiSa)AQ8b3sjokU!&_k!rw;%hK@_8j#lON
zK1T6rea;uWdtJ9g@E1$NYJ0vc_+`aP&Ls*M9|^un0?aVM{|9)l+}lB~F-jlzI^-z9
z?-f7M<t_$Z>ui^^T=;+Luds&+@j<~Kx<(<iouj~eg~tv)7XFgs6;`if{3Q4>*D1XA
z&ynb8)K5cY3O`7MRSSOag9;(t!+2Qm?)8T@!S7h3_;nroo}=V{TBz_+jB&Q$8&6Pp
z`gSE<cL0C9k!7^*R_QDSjE%xS?bizNxZqRIRr1}>ea6(ns=&~}6-Iu3!JN|kK*2l%
zi0VMi+_{4bjiTbJ;(4Xjf#RzC!2JBevWoKJYH$`+<j*Usm{U-eUxZKSSLYYhEW{5U
z%&#mf#y9Q<=OpIHpIcg9nqN>=Rd7Q-K89a)gE6<NV199aQO*4MHz12Gg<l#d#pma3
ztVPB1EBKcd<kt`e7vj77`Bz>%H829|6bJA@{h`C@4nMk3Qy3`4xBe$i4GcXa|2zmP
zh5q!df1l5tWu!ApektnkOY$WsY9trMKl|`MDDW5MJ|ia|mI)N&=Nj?@75RlF1+aZ-
zb$(5Gb?LnF;-ZPybgSXdW|{xrXSo4c=HquM=GK(M(iP>>7L$hNR9BXj2Brq^3lmc=
zni@Du{e;BCqNxQFi+sM)DN~2$PaU3*roLdxxXHeJ-^JteDK+8Z>G?jtApPT~82RI`
zxOm*;iRT;n6DD19-ndEmmt1hcRNu7xY2(hD<U@`t(Xu(*)D<`67X&5_9Wfq0T2NkC
ze7^as8@>g3(})!wGIUt}W&BeY|EIO9hjApS!h<;RBLoLTCpd|f5Yg$Zu{|?8lilr1
z!+B?C*RluQX00A~?@qJ+!}fS~B!mb_h)D>zh=Al$NQelLE`|&Vi3}ph5Z`<CURQNh
z+3mSI>-O4Xcm2KJ@4b5MO0RGjL-cOUaJZi)$yqyDn?^eMSl@d0sks{?kPyzm2bS9x
z<#?P<d;Nd{lVK;tGC+gN{d91C+2#qJLkM3^Z_?50*X@UCI-M;hP%M?%UO!(ad7;zt
z)*_^>CW3kJ=vnV+Q?J47k|a;onB7B~+P>265Hl)nQ$7HMbO_p^q>;gsWBIa3CjE1d
zd~#1VOhBb0B2Sr(alptT9fM^Mi`}W+?iA3@Y*c`aqgTDhgA#-sK(LYlcy~5`#{6b>
zrxPNdVRsWD&hv0Z332JzaOcRJ7;=DfIhM=?jIf^?L4&0U>G2q{4?eR1(yW-2!xcK1
z-!-x&I-7o;pchQ({d9ODj8P^GQ`Ik$$~ML=Uni5O;0NoZ7Bth-PBOuyyVSLzANZv7
z>&G;J=+iN`cRHyEzTs@1(n8Z_3EZ&M+FA#gBGkl_5)rDyEBL0V(TpY~3e6E{)x(mB
z23^n~IUwU841V}xwz$m}dDK=U5VQfAm7@im(z?L$I4|HPVSSkX2dlezfe9CRw#w?#
z9r8-;O&e0STn_o5pWz++?c}V}pz`v)v#=PWXnADVU^gz{FpANubX-hHQAaelCL^&<
zU|Jv=#!^`U3ReQtHIxC^2=XYb35_%`D;cgTs-sz8WVR6fFin)`5Z~kUj6lHbE@FV$
zzL5vQeFwz59_+`nI4>`?*Jmv0y=N&7O)979&9cb3gZ8np_paDC>vym+^xlIZBSsyN
z9439b8ht-ahmS-l;Tcxfi`gxVT5hcI`n?}L={-7q{ygor4h)go-397TOMt3kv6wBu
zJMh`Pt<`DEoxA(Q_6bDiWwA;x=hh8~){z!OjCvQx2AMk|f~`)|VK<ntS*Kv3l)dng
zS;|_Uj_AOw_pti+ANA69t6MEgxKEh0_vC6nNfhJ7C4xobh=>d^P@^ga<_J0oU`57}
zSpHO8fhw)Nf1BpPu8dw0F?jO8!0i7FQ_@bW(>g@gL`N4we4f5y2OaOYIv$4@&~E`z
zgppG+Zg3mq?Ony)%1GF8Wh5=Qjff-97sYZpdjTNOhXlY>;mEUcD#TJ;kruB<#hjpK
z$nXH4<OyLzZJPA+xHH_wGD`tkt1L4Fl9vA>FQmidPwVZixY*Abh)OGHDS2Ok2^7V!
z17+8eby$Y`=Q&}3HsMCH6_uwpr_2F{5DX6Hqe$fJ^5t@RJ6iYGPs;rSKw@4l=cDn%
zycmtw*|>*Zjo~>W7zF@mv?28Df^45$wXsN0-UGb(1ZWJ%pzGq>;R>gwiS2?@c)7YZ
z#>ulxW=Kx~1=og}iNNk6HQLFF4gvviVd%q@#uN8lfoKkEH5S-vAfy{6@O?NQ(GIn9
z#L-28^YaiErCHkUMG+OnM&hfD?PoR*I7UeG<t)YVeEGN_GBsfx1Pm6;IJ66$wgA62
z5Wj(QPeacOp^YGinx8dsgO3rmY8X~q5d|I(Vht$Pg$2-FI&gS(|Ej0bO+i8<frxfQ
z0;}&3E+L{-8D#4eit(-hHBhLiulC%v3t5{u6@$QeL#$_w2pOj);}S93hM|Pf$%vEX
zXCxm=`!)t{gr_0R)F?hAIpX6dfuv@O>?Ptw66e@3Q2erFpBoC~0Uc0T;SbMZ9P0^|
za)U;1Ku#ul3zxZh#uY|lN^b(>vH7bitM3S55WXqPy3yO#k?<LA6YjjSCbO%bAhCg1
zE7}xFB^HHpA$^z?V@}BVc50p@e~i?}u1=!OPC}!<Hu6v0S2kUx1-!`(%v?@z2j&^4
zg{E}YWr%ia&ObJLg9l&@&OU4*z-l2!^7?g(Lpzr<LQt!_bd5Y?V+0fH+A>^>E=A1}
z=onRKfJ~uGqN7?cIiDN(vqOoqx5zm73V>*c6sI|WmDJMYU@(|f`Njm+7O;+fK=le+
zFt8wi42OAyGimeLB+W)Rrxqzi$(NGbBrv0%7TMok&Yo7}X?OWmMF<uXkU>F|T9|PC
zLdwlcb)6G@6DF(Zdr=@Xii1gzVN)i9;g{wmj9<nqO<sbM+8_hg<z^&x)GB6xK?6tQ
zVFr-Y1u#*z1U!HaA$00Xgy|!PJWpW1PKs%U{B~Nt=sjO9FmK!jExamMw<Y=z>p-{k
zF4J{#NJ?42$yR|BJeK*7eHFkT$TKdlMzG5nG?ox}rLkQKEwQ>-uq&{XQ&UV9zO_3k
zr@aZ53oqP}G*M`Eqlzi!%F4Uv;sUTA>&3(WP$P0PAQRw%6GHRm0;M($D6K`)t<DLW
zVAAScBGAd8b_Y7yyA{}19z(m4FFI{7Tp^1MpN%_g!VIw`+o4^HW|4$9{=xD#n<Hzg
zSWCZ-t`cHv&~T`Tc34@M>h3nxtjB#p7sl=@{??f(MVaWiwT+=)Jzma{B0ei8YJi)7
zBr*h)zTX8%c3ID&-mcLR#h@OHB9^j~%ZVhZO>5<$)fx5?0bMKBL?V?<a*7e$$Q0($
z%?rm?beT4!6cM0tv}ue=nDdC46h{w54#2Prv(e#dk7Q{A7ZcSOF*O=tIxaobf;i#~
z?{gB;t_zCBdmODA)}OaK7sFxtL)lJiAJSIp&8pC&zDY<bOC%H+2(TqH)r3|eva=DN
z2+qvM{hC4CVVKA$#_6$y4p-wPZLGFw(=uHxvU0WTjcDrzo3xPFa+J=HwJowqZ-mS%
z#3alQOm8P{F0*c-g)Yc7ATdCv)pN8xHM<c#&JQ3ogiF#~pQkX}gajtbcFI<o=reJW
zQ7!QoUILb=**IlvBXC4xycEGLXZMOG&VDqy+KpR1swcGwMr57!!_#DU4398@=v9_v
zb6z-5!T5aG{27#MN7=>*#e}=vT~o&zJhSa(V%2W3s1+=qMrUoxrI2{OQ2C6AF-Qw}
zC0R~;vt{~hUQ8#myx7e9(0FXJX~s(f_373w5=evt9jynf_aGrTSwO<&C>v)B&hH_e
zVsPL(fz{<bD#+C_Wqx==Bt&Qdkt)XfQiVRqVH14B{?h3BRXykff+RC-B-oQKp}(dv
z?4pXFlF|lqNRq3;`O{$<+bKtZ03|ZbmPxptxC}BbCmBpHFHW^2;ht3kc1=#A!1Vwz
znXW`GH10M?wDgEAIO<p|$y_YxLXAK>W78vM^TuHWFPO}xn=9PbgO`%A^V`;_A^}fU
ztkvxzn?v|vtRQiSmJRkHTpHVivR<3|@bVqN3in8PbUEcA8;9{?56XQ*p*Tffm39P_
zRv8Q&il^U}NYVlUrK|CgIuVtAQfbZ_ixAh--ALR+rt(5|NNeeCD{QQM!5px-T9RW2
zRXn4J7gVTkYEb@m9|kkBso@HhEM1%&c5EqZ!A=oW+Yf<Z(vZPOdyg?`Dxq0nrYqW^
zfDv5Xpe_yZ?JEk0VIEc;%31ODN+lGgUJU!LXmzaLn*9ZiqhTYFB9cfN>2<cB0}7(K
z9w{_7A@QJ3v^QiEdA>;AM<AUXT!UEjL-XSE(ZIAr!zz@i+^j;sWlh}n@B)2Rr6lc#
z%h`BcJSnF|wlGx<gL84PF-U715jYTr1)pM(J8Y|yutiOWgB*ypk+fO6DQ$+3(xlpY
z=kV5uYWI<WrQ#|;Tk?eGVd#1?y_rxMNFkZ(rc6LHXKe<+<Dc504LSMYs*6NqJc+Z_
zp2SSL*_adK+1ame>fEnZ&g8mcJs<}Tcn?a~Y%u4ypmkB`u~9_>xX&9UCOO8evn^xm
zRnKYt4`e8s$S@h+?TZSUQV}6p5-il#5xNVFNY+7KPM%Xj1j$8Xkdex$GQptTeeAKP
z92FR3!?2AYk-aFu5-K4G2?QRv8-%%8G#3bv@>r^bK)Qksq`JF+_e0b*Q|Xs)^=vEv
zYsE?%>TIWt8iq*qDeqo!#mA!Hq@xooiZt#rwO9ZdP69?(qZLoiBwzv|5LQ;(M$nZg
zpFnd#eXv$6U$iCbf(f^d*4hxiFa(2Lq~xq+hY`$^HP?m3a#8xKA`IHzcZ)dC1H$9<
z3Y!z0qh=wtm0m$d6}X0Sq57b1F-Y)P;uC~xn)u@nKZTn)0Ma;Ox*ZWjK$@MdhJHyp
z6acg>327{sHC!Nq*;<GKIIo~7#z)8CYRS?8DsE@2Y9N)`+$dyibUKlk%&9hLY95=f
z<sOg;i2(1%Ii0fjx}s-W_<~aj7)4?x=;2&4by1<cO*P|>IpW!QBecU&fpjnBgt7JQ
zP+=&Y0GT3tK!%j|V;0%sjw9!qWomUhEd3}#HYw1l_&zH^g#RJ<TXywG9X~%-P0D19
z9+98xvo#mPsfjJNO<+L8=QJu@MB1=Brln9-J+uv7Cgld>R=HqT$Pi0xNhP!o^YVq%
z_L`Il9KlICJT=ZB^3(w&jx7JAm{5FS9EukCu{VGNj+QPu9!*60c$8r$0~_6<w!6qL
zO5(90b)P`ufMu8<X=H!B?z6x_x9**4254*5DRH+Io#nQI&Uzi-0hy!5y4jc<n6e}1
zaRn;{(QHXbV^FIW(Hetc0D53!@Ff+3LIm!Uvcya-;CVSE4P~a12=~#2rl_7vqd0Cf
z&o{6TZ2%ON?PDY+Vx%ck(MkPtNKZ4AKH>q3Be70niGYoDOiVBC53vp>+sOylJ@8f!
zgh>SZya6-(O<u+ay-Pw3`otRYdGx&6B?a(g?}9#<HM$L(&5^Us^~ni^Q6aiyVCq(B
z5Vra8^tOaz4~pf@1X_Q3ijr)uPO)Rg9D|~*pwA7PdcxAJyQ|(NodiT?{UKfR=)*f3
zf<+&cab<0lmce2un}iJ=C7#JhNxZuSh*2@=eSuia9>6bnb@LPf)U{$O8~g=A(YZqH
ze!Wx!G6a!asilfCal`WxzHQOl4`4=EZA?~*O%ZWb^m;Uw5TMDcM+oO2EyqM|qg0iW
zgDBdtqN+yAWzu2US*(iWQ)7VoBT@b?>b~rv4n7!0H&9Jb0<o;>nDs#pH3@ix55=UK
zPyn$Z2S~iqW*t3#DNka?B}6D-d`9Ik!U`j?g#4fasi(1%0_-ABuuKs2bA9Vky~f%+
zT_!128@%zPVV;fT@Wv5UNmJDdLKJfPli5_tei+mQqOS5+lj_QgY>uuXN?mgfh?&IC
zk|)YNPel8xCgg7L>8N!!d)Z|BceeZ{<5^kRz}>`TKeUvbv(NH1J$Oo+RbyB`wt0=%
zo2hIShay18h_Rq1bVN0DrwY9rXb{^bGb`k{+j%}?>*E>N?QtK^sAE0eFR8)3SO&AJ
zO7}hr3CHx%HJ;g6p4x|UBWYg<^Z;vxG+a?`>XH)o^~abz*}(UHU0gqJFe0Gt8mWJF
zQHH=Qe*?*FXr_nrD0{8t-DH(r;ksIw>$SckonOrNTG(MIT6k!;HDAn7le)TdKDxRo
z$N9U60?b`_KIvV0s-ADZ&X(7Et^96^A<T8PFyE|E*$QIS{z&m1k~SGNkazR(YOlq+
zsV%&1y`14sdb2D>d#zRR8h>&{Vrwzu=MP)OwLDmVoufDX3&V^?QVEGFPeMrCt9j<$
z^r7#mADRZb<SA#95@VU(k&xMI!O%|dK)?LZz-PRC7wx}*fAaGddvATwbg0+2z5eN5
z_eH<A@@4$f_Q%p*ulO0C+UqN|zxMX<b1Aj<*V10E`nwX^><xV*SNhozcYHmsL9Y+I
z`~CJG;`{&L3=f^Zo^zsCo&T4lAAkNCKK~m2X?r~fMX&p^9-1T3PTTA6N6^oR&@I|t
z&sEW@o}+?W_~p}|el~;7DAD$ME{R^xq@B)R@6+qg@jab+qJQhTCwl!v+SB}Lo;rW|
zc<)zuLp0U)dJc<TAIOAtd~L7m|FyJ#BpvFxE_&5-V5t3f@Xv4m5k8|Kw150$h<VAC
z<lBAu{QnKUblX3Wc6$AV%wPNPy5IYq*Z#NPGI#1#@88t^W3T<k(q6CghVlR4wb$SO
z)a(C<LC(vc&!6yJZT%maoAvj8zwWf9w?6&;jL)dO@?U@dUazXh)RtcU_<zA?ZhJkS
zLa#p~!E;{z_<zH9Zu@`!(cG-px4-8!##@yi{q!Gr<F<d}ujU)Q`t$e4|1WO;2L6ef
zSLdzhxhwv7`nO)`_sZXN+Uxl)de!^PtnB>t^Ec6+=C9-H@6+g2^~`Utf4_~!q&wPP
z&jHcvH-)jv1|3)V_<OW<$FI%{`In49Upg;suh$>o`&#>d%gu6an*Td!OnvG6_4o1g
z_ebCI#(&S53%%W!@%O#Ywf#HZ=h~fntz_T1_XC;#FCUl>NesV_f4Xj6*H`hG&fVN;
i{{M;mQ0BMsJ3{VD$JNisT*TV{{h7J*#B1RFx%YobT91bS

literal 0
HcmV?d00001

diff --git a/ex20_solution/build/mass_spring_output.txt b/ex20_solution/build/mass_spring_output.txt
new file mode 100644
index 000000000..6fbe51291
--- /dev/null
+++ b/ex20_solution/build/mass_spring_output.txt
@@ -0,0 +1,402 @@
+t x0 y0 x1 y1 x2 y2 vx0 vy0 vx1 vy1 vx2 vy2 
+0 0 0 1 0 2 0 0 0 0 0.5 0 0 
+0.01 2.5e-05 0 1 0.005 1.99998 0 0.0025 0 -2.77556e-19 0.5 -0.0025 0 
+0.02 7.49869e-05 1.24938e-07 1 0.00999975 1.99993 1.24938e-07 0.00499869 1.24938e-05 3.33067e-18 0.499975 -0.00499869 1.24938e-05 
+0.03 0.000149942 4.99568e-07 1 0.014999 1.99985 4.99568e-07 0.00749553 3.74631e-05 3.33067e-18 0.499925 -0.00749553 3.74631e-05 
+0.04 0.000249842 1.24838e-06 1 0.0199975 1.99975 1.24838e-06 0.00998997 7.48816e-05 3.60822e-18 0.49985 -0.00998997 7.48816e-05 
+0.05 0.000374657 2.49554e-06 1 0.024995 1.99963 2.49554e-06 0.0124815 0.000124715 7.21645e-18 0.499751 -0.0124815 0.000124715 
+0.06 0.000524352 4.36475e-06 1 0.0299913 1.99948 4.36475e-06 0.0149696 0.000186921 1.08247e-17 0.499626 -0.0149696 0.000186921 
+0.07 0.000698889 6.97925e-06 1 0.034986 1.9993 6.97925e-06 0.0174536 0.00026145 1.41553e-17 0.499477 -0.0174536 0.00026145 
+0.08 0.00089822 1.04617e-05 1 0.0399791 1.9991 1.04617e-05 0.0199332 0.000348243 1.38778e-17 0.499304 -0.0199332 0.000348243 
+0.09 0.0011223 1.4934e-05 1 0.0449701 1.99888 1.4934e-05 0.0224077 0.000447236 9.99201e-18 0.499106 -0.0224077 0.000447236 
+0.1 0.00137106 2.05176e-05 1 0.049959 1.99863 2.05176e-05 0.0248767 0.000558354 9.4369e-18 0.498883 -0.0248767 0.000558354 
+0.11 0.00164446 2.73328e-05 1 0.0549453 1.99836 2.73328e-05 0.0273396 0.000681518 5.55112e-18 0.498637 -0.0273396 0.000681518 
+0.12 0.00194242 3.54992e-05 1 0.059929 1.99806 3.54992e-05 0.029796 0.000816639 1.94289e-18 0.498367 -0.029796 0.000816639 
+0.13 0.00226487 4.51354e-05 1 0.0649097 1.99774 4.51354e-05 0.0322453 0.000963624 1.94289e-18 0.498073 -0.0322453 0.000963624 
+0.14 0.00261175 5.63591e-05 1 0.0698873 1.99739 5.63591e-05 0.0346871 0.00112237 1.94289e-18 0.497755 -0.0346871 0.00112237 
+0.15 0.00298295 6.92868e-05 1 0.0748614 1.99702 6.92868e-05 0.0371209 0.00129277 1.94289e-18 0.497414 -0.0371209 0.00129277 
+0.16 0.00337842 8.40339e-05 1 0.0798319 1.99662 8.40339e-05 0.0395462 0.00147471 1.66533e-18 0.497051 -0.0395462 0.00147471 
+0.17 0.00379804 0.000100714 1 0.0847986 1.9962 0.000100714 0.0419626 0.00166806 1.66533e-18 0.496664 -0.0419626 0.00166806 
+0.18 0.00424174 0.000119442 1 0.0897611 1.99576 0.000119442 0.0443696 0.00187271 1.66533e-18 0.496255 -0.0443696 0.00187271 
+0.19 0.00470941 0.000140327 1 0.0947193 1.99529 0.000140327 0.0467668 0.00208851 1.66533e-18 0.495823 -0.0467668 0.00208851 
+0.2 0.00520095 0.00016348 1 0.099673 1.9948 0.00016348 0.0491537 0.00231533 1.66533e-18 0.495369 -0.0491537 0.00231533 
+0.21 0.00571625 0.00018901 1 0.104622 1.99428 0.00018901 0.05153 0.00255303 1.94289e-18 0.494894 -0.05153 0.00255303 
+0.22 0.0062552 0.000217025 1 0.109566 1.99374 0.000217025 0.0538952 0.00280145 1.94289e-18 0.494397 -0.0538952 0.00280145 
+0.23 0.00681769 0.000247629 1 0.114505 1.99318 0.000247629 0.0562489 0.00306045 1.94289e-18 0.493879 -0.0562489 0.00306045 
+0.24 0.00740359 0.000280928 1 0.119438 1.9926 0.000280928 0.0585908 0.00332986 1.94289e-18 0.49334 -0.0585908 0.00332986 
+0.25 0.0080128 0.000317023 1 0.124366 1.99199 0.000317023 0.0609204 0.00360952 2.77556e-19 0.492781 -0.0609204 0.00360952 
+0.26 0.00864517 0.000356016 1 0.129288 1.99135 0.000356016 0.0632374 0.00389927 -3.33067e-18 0.492201 -0.0632374 0.00389927 
+0.27 0.00930059 0.000398005 1 0.134204 1.9907 0.000398005 0.0655416 0.00419894 -6.93889e-18 0.491602 -0.0655416 0.00419894 
+0.28 0.00997891 0.000443088 1 0.139114 1.99002 0.000443088 0.0678324 0.00450834 -1.36002e-17 0.490983 -0.0678324 0.00450834 
+0.29 0.01068 0.000491362 1 0.144017 1.98932 0.000491362 0.0701097 0.00482732 -1.66533e-17 0.490345 -0.0701097 0.00482732 
+0.3 0.0114037 0.000542918 1 0.148914 1.9886 0.000542918 0.0723731 0.00515568 -2.33147e-17 0.489689 -0.0723731 0.00515568 
+0.31 0.01215 0.000597851 1 0.153804 1.98785 0.000597851 0.0746223 0.00549324 -2.63678e-17 0.489014 -0.0746223 0.00549324 
+0.32 0.0129185 0.000656249 1 0.158688 1.98708 0.000656249 0.076857 0.00583983 -2.94209e-17 0.48832 -0.076857 0.00583983 
+0.33 0.0137093 0.000718201 1 0.163564 1.98629 0.000718201 0.0790769 0.00619524 -2.88658e-17 0.48761 -0.0790769 0.00619524 
+0.34 0.0145221 0.000783794 1 0.168432 1.98548 0.000783794 0.0812819 0.0065593 -2.47025e-17 0.486881 -0.0812819 0.0065593 
+0.35 0.0153568 0.000853113 1 0.173294 1.98464 0.000853113 0.0834716 0.00693181 -2.41474e-17 0.486136 -0.0834716 0.00693181 
+0.36 0.0162133 0.000926238 1 0.178148 1.98379 0.000926238 0.0856459 0.00731259 -2.33147e-17 0.485375 -0.0856459 0.00731259 
+0.37 0.0170913 0.00100325 1 0.182993 1.98291 0.00100325 0.0878044 0.00770143 -2.30371e-17 0.484597 -0.0878044 0.00770143 
+0.38 0.0179908 0.00108423 1 0.187832 1.98201 0.00108423 0.089947 0.00809815 -2.2482e-17 0.483804 -0.089947 0.00809815 
+0.39 0.0189115 0.00116926 1 0.192661 1.98109 0.00116926 0.0920736 0.00850255 -2.19269e-17 0.482995 -0.0920736 0.00850255 
+0.4 0.0198534 0.0012584 1 0.197483 1.98015 0.0012584 0.0941839 0.00891444 -2.13718e-17 0.482171 -0.0941839 0.00891444 
+0.41 0.0208162 0.00135174 1 0.202297 1.97918 0.00135174 0.0962777 0.00933363 -2.10942e-17 0.481333 -0.0962777 0.00933363 
+0.42 0.0217997 0.00144934 1 0.207101 1.9782 0.00144934 0.0983549 0.00975991 -2.05391e-17 0.48048 -0.0983549 0.00975991 
+0.43 0.0228039 0.00155127 1 0.211897 1.9772 0.00155127 0.100415 0.0101931 -1.69309e-17 0.479614 -0.100415 0.0101931 
+0.44 0.0238285 0.0016576 1 0.216685 1.97617 0.0016576 0.102459 0.010633 -1.66533e-17 0.478734 -0.102459 0.010633 
+0.45 0.0248733 0.00176839 1 0.221463 1.97513 0.00176839 0.104486 0.0110794 -1.66533e-17 0.477841 -0.104486 0.0110794 
+0.46 0.0259383 0.00188372 1 0.226233 1.97406 0.00188372 0.106495 0.0115321 -1.63758e-17 0.476936 -0.106495 0.0115321 
+0.47 0.0270231 0.00200363 1 0.230993 1.97298 0.00200363 0.108487 0.011991 -1.249e-17 0.476018 -0.108487 0.011991 
+0.48 0.0281278 0.00212818 1 0.235744 1.97187 0.00212818 0.110462 0.0124558 -8.88178e-18 0.475088 -0.110462 0.0124558 
+0.49 0.029252 0.00225745 1 0.240485 1.97075 0.00225745 0.11242 0.0129264 -3.05311e-18 0.474147 -0.11242 0.0129264 
+0.5 0.0303956 0.00239147 1 0.245217 1.9696 0.00239147 0.11436 0.0134025 4.16334e-18 0.473195 -0.11436 0.0134025 
+0.51 0.0315584 0.00253031 1 0.249939 1.96844 0.00253031 0.116283 0.013884 1.11022e-17 0.472232 -0.116283 0.013884 
+0.52 0.0327403 0.00267402 1 0.254652 1.96726 0.00267402 0.118188 0.0143707 1.80411e-17 0.471259 -0.118188 0.0143707 
+0.53 0.033941 0.00282265 1 0.259355 1.96606 0.00282265 0.120076 0.0148625 2.47025e-17 0.470275 -0.120076 0.0148625 
+0.54 0.0351605 0.00297624 1 0.264048 1.96484 0.00297624 0.121946 0.015359 2.77556e-17 0.469282 -0.121946 0.015359 
+0.55 0.0363985 0.00313484 1 0.26873 1.9636 0.00313484 0.123798 0.0158603 2.69229e-17 0.468279 -0.123798 0.0158603 
+0.56 0.0376548 0.0032985 1 0.273403 1.96235 0.0032985 0.125633 0.016366 2.66454e-17 0.467268 -0.125633 0.016366 
+0.57 0.0389293 0.00346726 1 0.278065 1.96107 0.00346726 0.12745 0.016876 2.2482e-17 0.466248 -0.12745 0.016876 
+0.58 0.0402218 0.00364116 1 0.282718 1.95978 0.00364116 0.129249 0.0173902 1.52656e-17 0.46522 -0.129249 0.0173902 
+0.59 0.0415321 0.00382024 1 0.28736 1.95847 0.00382024 0.131031 0.0179083 1.27676e-17 0.464183 -0.131031 0.0179083 
+0.6 0.04286 0.00400454 1 0.291991 1.95714 0.00400454 0.132796 0.0184302 9.15934e-18 0.46314 -0.132796 0.0184302 
+0.61 0.0442055 0.0041941 1 0.296612 1.95579 0.0041941 0.134542 0.0189558 5.27356e-18 0.462088 -0.134542 0.0189558 
+0.62 0.0455682 0.00438895 1 0.301222 1.95443 0.00438895 0.136272 0.0194848 1.66533e-18 0.46103 -0.136272 0.0194848 
+0.63 0.046948 0.00458912 1 0.305822 1.95305 0.00458912 0.137983 0.0200172 -5.55112e-18 0.459966 -0.137983 0.0200172 
+0.64 0.0483448 0.00479465 1 0.310411 1.95166 0.00479465 0.139678 0.0205528 -1.66533e-17 0.458894 -0.139678 0.0205528 
+0.65 0.0497583 0.00500556 1 0.314989 1.95024 0.00500556 0.141355 0.0210913 -2.35922e-17 0.457817 -0.141355 0.0210913 
+0.66 0.0511885 0.00522189 1 0.319556 1.94881 0.00522189 0.143015 0.0216328 -2.69229e-17 0.456734 -0.143015 0.0216328 
+0.67 0.0526351 0.00544366 1 0.324113 1.94736 0.00544366 0.144657 0.0221769 -3.19189e-17 0.455646 -0.144657 0.0221769 
+0.68 0.0540979 0.0056709 1 0.328658 1.9459 0.0056709 0.146283 0.0227237 -3.4972e-17 0.454553 -0.146283 0.0227237 
+0.69 0.0555768 0.00590363 1 0.333193 1.94442 0.00590363 0.147891 0.0232729 -3.44169e-17 0.453454 -0.147891 0.0232729 
+0.7 0.0570716 0.00614187 1 0.337716 1.94293 0.00614187 0.149482 0.0238243 -3.41394e-17 0.452351 -0.149482 0.0238243 
+0.71 0.0585822 0.00638565 1 0.342229 1.94142 0.00638565 0.151057 0.024378 -3.35842e-17 0.451244 -0.151057 0.024378 
+0.72 0.0601083 0.00663499 1 0.34673 1.93989 0.00663499 0.152614 0.0249337 -2.94209e-17 0.450133 -0.152614 0.0249337 
+0.73 0.0616499 0.0068899 1 0.35122 1.93835 0.0068899 0.154155 0.0254913 -2.85882e-17 0.449017 -0.154155 0.0254913 
+0.74 0.0632067 0.00715041 1 0.355699 1.93679 0.00715041 0.15568 0.0260506 -2.44249e-17 0.447899 -0.15568 0.0260506 
+0.75 0.0647786 0.00741652 1 0.360167 1.93522 0.00741652 0.157188 0.0266117 -2.38698e-17 0.446777 -0.157188 0.0266117 
+0.76 0.0663654 0.00768827 1 0.364623 1.93363 0.00768827 0.158679 0.0271742 -2.33147e-17 0.445652 -0.158679 0.0271742 
+0.77 0.0679669 0.00796565 1 0.369069 1.93203 0.00796565 0.160154 0.0277382 -2.27596e-17 0.444524 -0.160154 0.0277382 
+0.78 0.069583 0.00824868 1 0.373503 1.93042 0.00824868 0.161613 0.0283035 -2.22045e-17 0.443393 -0.161613 0.0283035 
+0.79 0.0712136 0.00853738 1 0.377925 1.92879 0.00853738 0.163056 0.02887 -2.16493e-17 0.44226 -0.163056 0.02887 
+0.8 0.0728584 0.00883176 1 0.382336 1.92714 0.00883176 0.164484 0.0294376 -1.41553e-17 0.441125 -0.164484 0.0294376 
+0.81 0.0745174 0.00913182 1 0.386736 1.92548 0.00913182 0.165895 0.0300062 -9.99201e-18 0.439988 -0.165895 0.0300062 
+0.82 0.0761903 0.00943758 1 0.391125 1.92381 0.00943758 0.167291 0.0305757 -6.38378e-18 0.438849 -0.167291 0.0305757 
+0.83 0.077877 0.00974904 1 0.395502 1.92212 0.00974904 0.168671 0.0311459 -6.38378e-18 0.437708 -0.168671 0.0311459 
+0.84 0.0795774 0.0100662 1 0.399868 1.92042 0.0100662 0.170036 0.0317168 -6.66134e-18 0.436566 -0.170036 0.0317168 
+0.85 0.0812912 0.0103891 1 0.404222 1.91871 0.0103891 0.171385 0.0322883 -6.38378e-18 0.435423 -0.171385 0.0322883 
+0.86 0.0830184 0.0107177 1 0.408565 1.91698 0.0107177 0.172719 0.0328603 -9.71445e-18 0.434279 -0.172719 0.0328603 
+0.87 0.0847588 0.011052 1 0.412896 1.91524 0.011052 0.174039 0.0334328 -1.63758e-17 0.433134 -0.174039 0.0334328 
+0.88 0.0865122 0.0113921 1 0.417216 1.91349 0.0113921 0.175343 0.0340055 -1.91513e-17 0.431989 -0.175343 0.0340055 
+0.89 0.0882785 0.0117379 1 0.421524 1.91172 0.0117379 0.176633 0.0345785 -2.58127e-17 0.430843 -0.176633 0.0345785 
+0.9 0.0900576 0.0120894 1 0.425821 1.90994 0.0120894 0.177908 0.0351516 -3.2474e-17 0.429697 -0.177908 0.0351516 
+0.91 0.0918493 0.0124466 1 0.430107 1.90815 0.0124466 0.179169 0.0357248 -3.71925e-17 0.42855 -0.179169 0.0357248 
+0.92 0.0936535 0.0128096 1 0.434381 1.90635 0.0128096 0.180415 0.036298 -4.01068e-17 0.427404 -0.180415 0.036298 
+0.93 0.0954699 0.0131783 1 0.438643 1.90453 0.0131783 0.181647 0.0368712 -3.91354e-17 0.426258 -0.181647 0.0368712 
+0.94 0.0972986 0.0135528 1 0.442894 1.9027 0.0135528 0.182866 0.0374442 -3.84415e-17 0.425112 -0.182866 0.0374442 
+0.95 0.0991393 0.0139329 1 0.447134 1.90086 0.0139329 0.18407 0.0380169 -3.747e-17 0.423966 -0.18407 0.0380169 
+0.96 0.100992 0.0143188 1 0.451362 1.89901 0.0143188 0.18526 0.0385894 -3.6221e-17 0.422821 -0.18526 0.0385894 
+0.97 0.102856 0.0147104 1 0.455579 1.89714 0.0147104 0.186437 0.0391616 -3.88578e-17 0.421677 -0.186437 0.0391616 
+0.98 0.104732 0.0151078 1 0.459784 1.89527 0.0151078 0.187601 0.0397333 -3.9968e-17 0.420533 -0.187601 0.0397333 
+0.99 0.10662 0.0155108 1 0.463978 1.89338 0.0155108 0.188751 0.0403045 -4.64906e-17 0.419391 -0.188751 0.0403045 
+1 0.108519 0.0159196 1 0.468161 1.89148 0.0159196 0.189888 0.0408753 -5.09315e-17 0.418249 -0.189888 0.0408753 
+1.01 0.110429 0.016334 1 0.472332 1.88957 0.016334 0.191012 0.0414454 -5.38458e-17 0.417109 -0.191012 0.0414454 
+1.02 0.11235 0.0167542 1 0.476492 1.88765 0.0167542 0.192123 0.0420149 -5.98133e-17 0.41597 -0.192123 0.0420149 
+1.03 0.114282 0.01718 1 0.48064 1.88572 0.01718 0.193221 0.0425836 -6.73073e-17 0.414833 -0.193221 0.0425836 
+1.04 0.116225 0.0176115 1 0.484777 1.88377 0.0176115 0.194306 0.0431517 -7.70217e-17 0.413697 -0.194306 0.0431517 
+1.05 0.118179 0.0180487 1 0.488903 1.88182 0.0180487 0.195379 0.0437189 -8.46545e-17 0.412562 -0.195379 0.0437189 
+1.06 0.120143 0.0184916 1 0.493017 1.87986 0.0184916 0.19644 0.0442853 -9.71445e-17 0.411429 -0.19644 0.0442853 
+1.07 0.122118 0.0189401 1 0.49712 1.87788 0.0189401 0.197489 0.0448507 -1.04361e-16 0.410299 -0.197489 0.0448507 
+1.08 0.124104 0.0193942 1 0.501212 1.8759 0.0193942 0.198525 0.0454153 -1.15047e-16 0.409169 -0.198525 0.0454153 
+1.09 0.126099 0.019854 1 0.505292 1.8739 0.019854 0.199549 0.0459788 -1.25733e-16 0.408042 -0.199549 0.0459788 
+1.1 0.128105 0.0203194 1 0.509361 1.8719 0.0203194 0.200562 0.0465414 -1.35586e-16 0.406917 -0.200562 0.0465414 
+1.11 0.13012 0.0207905 1 0.513419 1.86988 0.0207905 0.201563 0.0471028 -1.45439e-16 0.405794 -0.201563 0.0471028 
+1.12 0.132146 0.0212671 1 0.517466 1.86785 0.0212671 0.202553 0.0476632 -1.5557e-16 0.404674 -0.202553 0.0476632 
+1.13 0.134181 0.0217493 1 0.521501 1.86582 0.0217493 0.203531 0.0482224 -1.65146e-16 0.403555 -0.203531 0.0482224 
+1.14 0.136226 0.0222371 1 0.525526 1.86377 0.0222371 0.204497 0.0487804 -1.74583e-16 0.402439 -0.204497 0.0487804 
+1.15 0.138281 0.0227305 1 0.529539 1.86172 0.0227305 0.205453 0.0493373 -1.85824e-16 0.401325 -0.205453 0.0493373 
+1.16 0.140345 0.0232294 1 0.533541 1.85966 0.0232294 0.206398 0.0498929 -1.93179e-16 0.400214 -0.206398 0.0498929 
+1.17 0.142418 0.0237339 1 0.537532 1.85758 0.0237339 0.207332 0.0504472 -1.98452e-16 0.399106 -0.207332 0.0504472 
+1.18 0.144501 0.0242439 1 0.541512 1.8555 0.0242439 0.208255 0.0510002 -2.02338e-16 0.398 -0.208255 0.0510002 
+1.19 0.146592 0.0247594 1 0.545481 1.85341 0.0247594 0.209167 0.0515519 -2.05946e-16 0.396896 -0.209167 0.0515519 
+1.2 0.148693 0.0252804 1 0.549439 1.85131 0.0252804 0.210069 0.0521022 -2.0775e-16 0.395796 -0.210069 0.0521022 
+1.21 0.150803 0.0258069 1 0.553386 1.8492 0.0258069 0.210961 0.0526511 -2.11636e-16 0.394698 -0.210961 0.0526511 
+1.22 0.152921 0.0263389 1 0.557322 1.84708 0.0263389 0.211842 0.0531987 -2.14828e-16 0.393603 -0.211842 0.0531987 
+1.23 0.155048 0.0268764 1 0.561247 1.84495 0.0268764 0.212713 0.0537448 -2.17742e-16 0.39251 -0.212713 0.0537448 
+1.24 0.157184 0.0274193 1 0.565161 1.84282 0.0274193 0.213574 0.0542894 -2.17049e-16 0.391421 -0.213574 0.0542894 
+1.25 0.159328 0.0279676 1 0.569065 1.84067 0.0279676 0.214426 0.0548326 -2.20518e-16 0.390335 -0.214426 0.0548326 
+1.26 0.161481 0.0285213 1 0.572957 1.83852 0.0285213 0.215267 0.0553742 -2.22461e-16 0.389252 -0.215267 0.0553742 
+1.27 0.163642 0.0290805 1 0.576839 1.83636 0.0290805 0.216099 0.0559144 -2.23571e-16 0.388171 -0.216099 0.0559144 
+1.28 0.165811 0.029645 1 0.58071 1.83419 0.029645 0.216921 0.056453 -2.24543e-16 0.387094 -0.216921 0.056453 
+1.29 0.167988 0.0302149 1 0.58457 1.83201 0.0302149 0.217734 0.05699 -2.27596e-16 0.38602 -0.217734 0.05699 
+1.3 0.170174 0.0307902 1 0.58842 1.82983 0.0307902 0.218538 0.0575255 -2.26624e-16 0.384949 -0.218538 0.0575255 
+1.31 0.172367 0.0313708 1 0.592258 1.82763 0.0313708 0.219333 0.0580594 -2.35229e-16 0.383881 -0.219333 0.0580594 
+1.32 0.174568 0.0319567 1 0.596087 1.82543 0.0319567 0.220118 0.0585917 -2.42167e-16 0.382817 -0.220118 0.0585917 
+1.33 0.176777 0.0325479 1 0.599904 1.82322 0.0325479 0.220894 0.0591223 -2.48274e-16 0.381755 -0.220894 0.0591223 
+1.34 0.178994 0.0331444 1 0.603711 1.82101 0.0331444 0.221662 0.0596514 -2.54796e-16 0.380697 -0.221662 0.0596514 
+1.35 0.181218 0.0337462 1 0.607508 1.81878 0.0337462 0.222421 0.0601787 -2.57433e-16 0.379643 -0.222421 0.0601787 
+1.36 0.18345 0.0343532 1 0.611294 1.81655 0.0343532 0.223171 0.0607045 -2.59931e-16 0.378591 -0.223171 0.0607045 
+1.37 0.185689 0.0349655 1 0.615069 1.81431 0.0349655 0.223913 0.0612285 -2.62568e-16 0.377543 -0.223913 0.0612285 
+1.38 0.187935 0.035583 1 0.618834 1.81206 0.035583 0.224646 0.0617509 -2.65066e-16 0.376498 -0.224646 0.0617509 
+1.39 0.190189 0.0362058 1 0.622588 1.80981 0.0362058 0.225371 0.0622716 -2.69229e-16 0.375457 -0.225371 0.0622716 
+1.4 0.19245 0.0368337 1 0.626333 1.80755 0.0368337 0.226088 0.0627907 -2.71588e-16 0.374419 -0.226088 0.0627907 
+1.41 0.194718 0.0374667 1 0.630067 1.80528 0.0374667 0.226797 0.063308 -2.72005e-16 0.373384 -0.226797 0.063308 
+1.42 0.196993 0.038105 1 0.63379 1.80301 0.038105 0.227497 0.0638236 -2.74641e-16 0.372353 -0.227497 0.0638236 
+1.43 0.199275 0.0387484 1 0.637503 1.80073 0.0387484 0.22819 0.0643375 -2.82968e-16 0.371325 -0.22819 0.0643375 
+1.44 0.201563 0.0393968 1 0.641206 1.79844 0.0393968 0.228875 0.0648496 -2.85605e-16 0.370301 -0.228875 0.0648496 
+1.45 0.203859 0.0400504 1 0.644899 1.79614 0.0400504 0.229552 0.06536 -2.9185e-16 0.36928 -0.229552 0.06536 
+1.46 0.206161 0.0407091 1 0.648582 1.79384 0.0407091 0.230222 0.0658687 -2.97679e-16 0.368263 -0.230222 0.0658687 
+1.47 0.20847 0.0413729 1 0.652254 1.79153 0.0413729 0.230884 0.0663757 -3.03091e-16 0.367249 -0.230884 0.0663757 
+1.48 0.210785 0.0420417 1 0.655917 1.78921 0.0420417 0.231538 0.0668809 -3.1225e-16 0.366238 -0.231538 0.0668809 
+1.49 0.213107 0.0427155 1 0.659569 1.78689 0.0427155 0.232186 0.0673844 -3.29459e-16 0.365231 -0.232186 0.0673844 
+1.5 0.215435 0.0433944 1 0.663211 1.78456 0.0433944 0.232826 0.0678861 -3.42781e-16 0.364228 -0.232826 0.0678861 
+1.51 0.21777 0.0440783 1 0.666843 1.78223 0.0440783 0.233458 0.0683861 -3.55271e-16 0.363228 -0.233458 0.0683861 
+1.52 0.220111 0.0447671 1 0.670466 1.77989 0.0447671 0.234084 0.0688843 -3.71508e-16 0.362231 -0.234084 0.0688843 
+1.53 0.222458 0.0454609 1 0.674078 1.77754 0.0454609 0.234703 0.0693808 -3.87537e-16 0.361238 -0.234703 0.0693808 
+1.54 0.224811 0.0461597 1 0.677681 1.77519 0.0461597 0.235315 0.0698755 -3.97737e-16 0.360249 -0.235315 0.0698755 
+1.55 0.22717 0.0468634 1 0.681273 1.77283 0.0468634 0.23592 0.0703684 -4.10089e-16 0.359263 -0.23592 0.0703684 
+1.56 0.229535 0.047572 1 0.684856 1.77046 0.047572 0.236518 0.0708596 -4.18277e-16 0.358281 -0.236518 0.0708596 
+1.57 0.231907 0.0482854 1 0.688429 1.76809 0.0482854 0.23711 0.0713491 -4.24938e-16 0.357302 -0.23711 0.0713491 
+1.58 0.234284 0.0490038 1 0.691992 1.76572 0.0490038 0.237695 0.0718368 -4.27575e-16 0.356326 -0.237695 0.0718368 
+1.59 0.236666 0.049727 1 0.695546 1.76333 0.049727 0.238274 0.0723227 -4.29795e-16 0.355355 -0.238274 0.0723227 
+1.6 0.239055 0.0504551 1 0.69909 1.76095 0.0504551 0.238846 0.0728069 -4.30489e-16 0.354386 -0.238846 0.0728069 
+1.61 0.241449 0.051188 1 0.702624 1.75855 0.051188 0.239412 0.0732893 -4.30628e-16 0.353421 -0.239412 0.0732893 
+1.62 0.243849 0.0519257 1 0.706149 1.75615 0.0519257 0.239972 0.07377 -4.27158e-16 0.35246 -0.239972 0.07377 
+1.63 0.246254 0.0526682 1 0.709664 1.75375 0.0526682 0.240526 0.0742489 -4.29587e-16 0.351502 -0.240526 0.0742489 
+1.64 0.248665 0.0534155 1 0.713169 1.75134 0.0534155 0.241073 0.0747261 -4.32085e-16 0.350548 -0.241073 0.0747261 
+1.65 0.251081 0.0541675 1 0.716665 1.74892 0.0541675 0.241615 0.0752016 -4.39718e-16 0.349597 -0.241615 0.0752016 
+1.66 0.253502 0.0549242 1 0.720152 1.7465 0.0549242 0.24215 0.0756753 -4.42008e-16 0.348649 -0.24215 0.0756753 
+1.67 0.255929 0.0556857 1 0.723629 1.74407 0.0556857 0.24268 0.0761473 -4.44297e-16 0.347705 -0.24268 0.0761473 
+1.68 0.258361 0.0564519 1 0.727096 1.74164 0.0564519 0.243204 0.0766176 -4.44297e-16 0.346765 -0.243204 0.0766176 
+1.69 0.260798 0.0572227 1 0.730555 1.7392 0.0572227 0.243722 0.0770861 -4.48391e-16 0.345828 -0.243722 0.0770861 
+1.7 0.263241 0.0579983 1 0.734003 1.73676 0.0579983 0.244234 0.077553 -4.50126e-16 0.344894 -0.244234 0.077553 
+1.71 0.265688 0.0587784 1 0.737443 1.73431 0.0587784 0.244741 0.0780181 -4.52416e-16 0.343964 -0.244741 0.0780181 
+1.72 0.26814 0.0595633 1 0.740873 1.73186 0.0595633 0.245243 0.0784815 -4.54428e-16 0.343037 -0.245243 0.0784815 
+1.73 0.270598 0.0603527 1 0.744295 1.7294 0.0603527 0.245738 0.0789432 -4.54775e-16 0.342114 -0.245738 0.0789432 
+1.74 0.27306 0.0611467 1 0.747707 1.72694 0.0611467 0.246229 0.0794032 -4.57134e-16 0.341194 -0.246229 0.0794032 
+1.75 0.275527 0.0619453 1 0.751109 1.72447 0.0619453 0.246714 0.0798615 -4.55816e-16 0.340277 -0.246714 0.0798615 
+1.76 0.277999 0.0627485 1 0.754503 1.722 0.0627485 0.247194 0.0803181 -4.54359e-16 0.339364 -0.247194 0.0803181 
+1.77 0.280476 0.0635562 1 0.757888 1.71952 0.0635562 0.247669 0.0807731 -4.52902e-16 0.338454 -0.247669 0.0807731 
+1.78 0.282957 0.0643685 1 0.761263 1.71704 0.0643685 0.248139 0.0812264 -4.45408e-16 0.337547 -0.248139 0.0812264 
+1.79 0.285443 0.0651853 1 0.764629 1.71456 0.0651853 0.248604 0.081678 -4.38399e-16 0.336644 -0.248604 0.081678 
+1.8 0.287934 0.0660066 1 0.767987 1.71207 0.0660066 0.249063 0.082128 -4.31391e-16 0.335744 -0.249063 0.082128 
+1.81 0.290429 0.0668323 1 0.771335 1.70957 0.0668323 0.249518 0.0825763 -4.20705e-16 0.334847 -0.249518 0.0825763 
+1.82 0.292929 0.0676626 1 0.774675 1.70707 0.0676626 0.249968 0.0830229 -4.0884e-16 0.333954 -0.249968 0.0830229 
+1.83 0.295433 0.0684972 1 0.778006 1.70457 0.0684972 0.250413 0.083468 -3.98917e-16 0.333064 -0.250413 0.083468 
+1.84 0.297941 0.0693364 1 0.781327 1.70206 0.0693364 0.250853 0.0839114 -3.86982e-16 0.332177 -0.250853 0.0839114 
+1.85 0.300454 0.0701799 1 0.78464 1.69955 0.0701799 0.251289 0.0843532 -3.75255e-16 0.331294 -0.251289 0.0843532 
+1.86 0.302972 0.0710278 1 0.787944 1.69703 0.0710278 0.25172 0.0847934 -3.65957e-16 0.330413 -0.25172 0.0847934 
+1.87 0.305493 0.0718801 1 0.79124 1.69451 0.0718801 0.252146 0.0852319 -3.52982e-16 0.329536 -0.252146 0.0852319 
+1.88 0.308019 0.0727368 1 0.794526 1.69198 0.0727368 0.252568 0.0856689 -3.42504e-16 0.328662 -0.252568 0.0856689 
+1.89 0.310549 0.0735979 1 0.797804 1.68945 0.0735979 0.252986 0.0861043 -3.31818e-16 0.327791 -0.252986 0.0861043 
+1.9 0.313083 0.0744633 1 0.801073 1.68692 0.0744633 0.253399 0.0865381 -3.23908e-16 0.326924 -0.253399 0.0865381 
+1.91 0.315621 0.075333 1 0.804334 1.68438 0.075333 0.253807 0.0869704 -3.13846e-16 0.326059 -0.253807 0.0869704 
+1.92 0.318163 0.076207 1 0.807586 1.68184 0.076207 0.254212 0.087401 -2.98858e-16 0.325198 -0.254212 0.087401 
+1.93 0.320709 0.0770853 1 0.810829 1.67929 0.0770853 0.254612 0.0878302 -2.91434e-16 0.32434 -0.254612 0.0878302 
+1.94 0.323259 0.0779678 1 0.814064 1.67674 0.0779678 0.255008 0.0882578 -2.76584e-16 0.323484 -0.255008 0.0882578 
+1.95 0.325813 0.0788547 1 0.817291 1.67419 0.0788547 0.255399 0.0886838 -2.64094e-16 0.322632 -0.255399 0.0886838 
+1.96 0.328371 0.0797458 1 0.820508 1.67163 0.0797458 0.255787 0.0891084 -2.49453e-16 0.321783 -0.255787 0.0891084 
+1.97 0.330932 0.0806411 1 0.823718 1.66907 0.0806411 0.25617 0.0895314 -2.37171e-16 0.320937 -0.25617 0.0895314 
+1.98 0.333498 0.0815406 1 0.826919 1.6665 0.0815406 0.25655 0.0899529 -2.23085e-16 0.320094 -0.25655 0.0899529 
+1.99 0.336067 0.0824443 1 0.830111 1.66393 0.0824443 0.256925 0.0903729 -2.09346e-16 0.319254 -0.256925 0.0903729 
+2 0.33864 0.0833523 1 0.833295 1.66136 0.0833523 0.257297 0.0907914 -1.97897e-16 0.318417 -0.257297 0.0907914 
+2.01 0.341217 0.0842643 1 0.836471 1.65878 0.0842643 0.257665 0.0912085 -1.86448e-16 0.317583 -0.257665 0.0912085 
+2.02 0.343797 0.0851806 1 0.839639 1.6562 0.0851806 0.258029 0.0916241 -1.73611e-16 0.316752 -0.258029 0.0916241 
+2.03 0.346381 0.086101 1 0.842798 1.65362 0.086101 0.258389 0.0920382 -1.66603e-16 0.315924 -0.258389 0.0920382 
+2.04 0.348969 0.0870255 1 0.845949 1.65103 0.0870255 0.258746 0.0924509 -1.55639e-16 0.315098 -0.258746 0.0924509 
+2.05 0.351559 0.0879541 1 0.849092 1.64844 0.0879541 0.259098 0.0928621 -1.39333e-16 0.314276 -0.259098 0.0928621 
+2.06 0.354154 0.0888868 1 0.852226 1.64585 0.0888868 0.259447 0.0932719 -1.23165e-16 0.313456 -0.259447 0.0932719 
+2.07 0.356752 0.0898236 1 0.855353 1.64325 0.0898236 0.259793 0.0936803 -1.07622e-16 0.312639 -0.259793 0.0936803 
+2.08 0.359353 0.0907645 1 0.858471 1.64065 0.0907645 0.260135 0.0940873 -9.61731e-17 0.311825 -0.260135 0.0940873 
+2.09 0.361958 0.0917094 1 0.861581 1.63804 0.0917094 0.260473 0.0944929 -8.25728e-17 0.311014 -0.260473 0.0944929 
+2.1 0.364566 0.0926584 1 0.864683 1.63543 0.0926584 0.260808 0.0948971 -6.77236e-17 0.310206 -0.260808 0.0948971 
+2.11 0.367177 0.0936114 1 0.867777 1.63282 0.0936114 0.26114 0.0953 -5.29438e-17 0.3094 -0.26114 0.0953 
+2.12 0.369792 0.0945684 1 0.870863 1.63021 0.0945684 0.261468 0.0957014 -3.84415e-17 0.308597 -0.261468 0.0957014 
+2.13 0.37241 0.0955294 1 0.873941 1.62759 0.0955294 0.261793 0.0961015 -2.76168e-17 0.307797 -0.261793 0.0961015 
+2.14 0.375031 0.0964944 1 0.877011 1.62497 0.0964944 0.262114 0.0965003 -1.70003e-17 0.306999 -0.262114 0.0965003 
+2.15 0.377656 0.0974634 1 0.880073 1.62234 0.0974634 0.262433 0.0968977 -8.39606e-18 0.306205 -0.262433 0.0968977 
+2.16 0.380283 0.0984363 1 0.883127 1.61972 0.0984363 0.262748 0.0972938 -3.46945e-19 0.305412 -0.262748 0.0972938 
+2.17 0.382914 0.0994132 1 0.886174 1.61709 0.0994132 0.263059 0.0976886 1.11369e-17 0.304623 -0.263059 0.0976886 
+2.18 0.385547 0.100394 1 0.889212 1.61445 0.100394 0.263368 0.098082 2.43208e-17 0.303836 -0.263368 0.098082 
+2.19 0.388184 0.101379 1 0.892242 1.61182 0.101379 0.263674 0.0984742 3.71925e-17 0.303052 -0.263674 0.0984742 
+2.2 0.390824 0.102367 1 0.895265 1.60918 0.102367 0.263976 0.0988651 4.97172e-17 0.30227 -0.263976 0.0988651 
+2.21 0.393467 0.10336 1 0.89828 1.60653 0.10336 0.264275 0.0992547 6.03337e-17 0.301491 -0.264275 0.0992547 
+2.22 0.396112 0.104356 1 0.901287 1.60389 0.104356 0.264572 0.099643 7.07767e-17 0.300714 -0.264572 0.099643 
+2.23 0.398761 0.105357 1 0.904287 1.60124 0.105357 0.264865 0.10003 8.30239e-17 0.29994 -0.264865 0.10003 
+2.24 0.401412 0.106361 1 0.907278 1.59859 0.106361 0.265155 0.100416 9.12811e-17 0.299168 -0.265155 0.100416 
+2.25 0.404067 0.107369 1 0.910262 1.59593 0.107369 0.265443 0.100801 9.36057e-17 0.298399 -0.265443 0.100801 
+2.26 0.406724 0.108381 1 0.913239 1.59328 0.108381 0.265727 0.101184 9.56527e-17 0.297632 -0.265727 0.101184 
+2.27 0.409384 0.109396 1 0.916207 1.59062 0.109396 0.266009 0.101566 9.9816e-17 0.296868 -0.266009 0.101566 
+2.28 0.412047 0.110416 1 0.919168 1.58795 0.110416 0.266288 0.101947 1.05853e-16 0.296106 -0.266288 0.101947 
+2.29 0.414713 0.111439 1 0.922122 1.58529 0.111439 0.266564 0.102327 1.11855e-16 0.295346 -0.266564 0.102327 
+2.3 0.417381 0.112466 1 0.925068 1.58262 0.112466 0.266837 0.102705 1.19592e-16 0.294589 -0.266837 0.102705 
+2.31 0.420052 0.113497 1 0.928006 1.57995 0.113497 0.267108 0.103083 1.23374e-16 0.293834 -0.267108 0.103083 
+2.32 0.422726 0.114532 1 0.930937 1.57727 0.114532 0.267376 0.103459 1.28647e-16 0.293082 -0.267376 0.103459 
+2.33 0.425402 0.11557 1 0.93386 1.5746 0.11557 0.267641 0.103834 1.30486e-16 0.292332 -0.267641 0.103834 
+2.34 0.428081 0.116612 1 0.936776 1.57192 0.116612 0.267904 0.104208 1.30659e-16 0.291584 -0.267904 0.104208 
+2.35 0.430763 0.117658 1 0.939684 1.56924 0.117658 0.268164 0.104581 1.30902e-16 0.290838 -0.268164 0.104581 
+2.36 0.433447 0.118707 1 0.942585 1.56655 0.118707 0.268421 0.104953 1.2719e-16 0.290095 -0.268421 0.104953 
+2.37 0.436134 0.119761 1 0.945479 1.56387 0.119761 0.268676 0.105323 1.25455e-16 0.289353 -0.268676 0.105323 
+2.38 0.438823 0.120818 1 0.948365 1.56118 0.120818 0.268928 0.105693 1.25525e-16 0.288615 -0.268928 0.105693 
+2.39 0.441515 0.121878 1 0.951244 1.55848 0.121878 0.269178 0.106061 1.21916e-16 0.287878 -0.269178 0.106061 
+2.4 0.444209 0.122942 1 0.954115 1.55579 0.122942 0.269425 0.106428 1.20147e-16 0.287143 -0.269425 0.106428 
+2.41 0.446906 0.12401 1 0.956979 1.55309 0.12401 0.26967 0.106795 1.2209e-16 0.286411 -0.26967 0.106795 
+2.42 0.449605 0.125082 1 0.959836 1.55039 0.125082 0.269913 0.10716 1.25629e-16 0.28568 -0.269913 0.10716 
+2.43 0.452307 0.126157 1 0.962686 1.54769 0.126157 0.270153 0.107524 1.29376e-16 0.284952 -0.270153 0.107524 
+2.44 0.455011 0.127236 1 0.965528 1.54499 0.127236 0.27039 0.107887 1.3118e-16 0.284226 -0.27039 0.107887 
+2.45 0.457717 0.128319 1 0.968363 1.54228 0.128319 0.270626 0.108249 1.32845e-16 0.283502 -0.270626 0.108249 
+2.46 0.460425 0.129405 1 0.971191 1.53957 0.129405 0.270859 0.10861 1.32463e-16 0.28278 -0.270859 0.10861 
+2.47 0.463136 0.130494 1 0.974011 1.53686 0.130494 0.271089 0.10897 1.32151e-16 0.28206 -0.271089 0.10897 
+2.48 0.46585 0.131588 1 0.976825 1.53415 0.131588 0.271318 0.109329 1.33886e-16 0.281342 -0.271318 0.109329 
+2.49 0.468565 0.132685 1 0.979631 1.53144 0.132685 0.271544 0.109687 1.35655e-16 0.280626 -0.271544 0.109687 
+2.5 0.471283 0.133785 1 0.98243 1.52872 0.133785 0.271768 0.110044 1.33747e-16 0.279913 -0.271768 0.110044 
+2.51 0.474003 0.134889 1 0.985222 1.526 0.134889 0.27199 0.1104 1.33504e-16 0.279201 -0.27199 0.1104 
+2.52 0.476725 0.135996 1 0.988007 1.52328 0.135996 0.272209 0.110755 1.33331e-16 0.278491 -0.272209 0.110755 
+2.53 0.479449 0.137108 1 0.990785 1.52055 0.137108 0.272427 0.111109 1.32984e-16 0.277782 -0.272427 0.111109 
+2.54 0.482175 0.138222 1 0.993556 1.51782 0.138222 0.272642 0.111462 1.3288e-16 0.277076 -0.272642 0.111462 
+2.55 0.484904 0.13934 1 0.996319 1.5151 0.13934 0.272855 0.111814 1.32741e-16 0.276372 -0.272855 0.111814 
+2.56 0.487635 0.140462 1 0.999076 1.51237 0.140462 0.273067 0.112165 1.32533e-16 0.27567 -0.273067 0.112165 
+2.57 0.490367 0.141587 1 1.00183 1.50963 0.141587 0.273276 0.112515 1.3229e-16 0.274969 -0.273276 0.112515 
+2.58 0.493102 0.142716 1 1.00457 1.5069 0.142716 0.273483 0.112865 1.32498e-16 0.27427 -0.273483 0.112865 
+2.59 0.495839 0.143848 1 1.0073 1.50416 0.143848 0.273687 0.113213 1.32637e-16 0.273573 -0.273687 0.113213 
+2.6 0.498578 0.144984 1 1.01003 1.50142 0.144984 0.27389 0.113561 1.29202e-16 0.272878 -0.27389 0.113561 
+2.61 0.501319 0.146123 1 1.01275 1.49868 0.146123 0.274091 0.113907 1.29133e-16 0.272185 -0.274091 0.113907 
+2.62 0.504062 0.147265 1 1.01547 1.49594 0.147265 0.27429 0.114253 1.29063e-16 0.271493 -0.27429 0.114253 
+2.63 0.506807 0.148411 1 1.01818 1.49319 0.148411 0.274487 0.114598 1.30833e-16 0.270804 -0.274487 0.114598 
+2.64 0.509553 0.149561 1 1.02088 1.49045 0.149561 0.274682 0.114942 1.30486e-16 0.270116 -0.274682 0.114942 
+2.65 0.512302 0.150713 1 1.02357 1.4877 0.150713 0.274876 0.115285 1.33678e-16 0.269429 -0.274876 0.115285 
+2.66 0.515053 0.15187 1 1.02626 1.48495 0.15187 0.275067 0.115628 1.36627e-16 0.268745 -0.275067 0.115628 
+2.67 0.517805 0.153029 1 1.02894 1.48219 0.153029 0.275256 0.115969 1.43011e-16 0.268062 -0.275256 0.115969 
+2.68 0.52056 0.154192 1 1.03162 1.47944 0.154192 0.275444 0.11631 1.43947e-16 0.267381 -0.275444 0.11631 
+2.69 0.523316 0.155359 1 1.03428 1.47668 0.155359 0.275629 0.11665 1.4648e-16 0.266701 -0.275629 0.11665 
+2.7 0.526074 0.156529 1 1.03694 1.47393 0.156529 0.275813 0.116989 1.47243e-16 0.266023 -0.275813 0.116989 
+2.71 0.528834 0.157702 1 1.0396 1.47117 0.157702 0.275995 0.117327 1.51545e-16 0.265347 -0.275995 0.117327 
+2.72 0.531596 0.158879 1 1.04224 1.4684 0.158879 0.276175 0.117664 1.57756e-16 0.264672 -0.276175 0.117664 
+2.73 0.534359 0.160059 1 1.04488 1.46564 0.160059 0.276354 0.118001 1.58762e-16 0.263999 -0.276354 0.118001 
+2.74 0.537125 0.161242 1 1.04752 1.46288 0.161242 0.276531 0.118336 1.58068e-16 0.263327 -0.276531 0.118336 
+2.75 0.539892 0.162429 1 1.05014 1.46011 0.162429 0.276706 0.118671 1.59039e-16 0.262657 -0.276706 0.118671 
+2.76 0.542661 0.163619 1 1.05276 1.45734 0.163619 0.276879 0.119006 1.63411e-16 0.261989 -0.276879 0.119006 
+2.77 0.545431 0.164812 1 1.05538 1.45457 0.164812 0.27705 0.119339 1.62197e-16 0.261322 -0.27705 0.119339 
+2.78 0.548203 0.166009 1 1.05798 1.4518 0.166009 0.27722 0.119672 1.64868e-16 0.260656 -0.27722 0.119672 
+2.79 0.550977 0.167209 1 1.06058 1.44902 0.167209 0.277388 0.120004 1.62197e-16 0.259993 -0.277388 0.120004 
+2.8 0.553753 0.168412 1 1.06318 1.44625 0.168412 0.277555 0.120335 1.6126e-16 0.25933 -0.277555 0.120335 
+2.81 0.55653 0.169619 1 1.06576 1.44347 0.169619 0.27772 0.120665 1.5668e-16 0.258669 -0.27772 0.120665 
+2.82 0.559309 0.170829 1 1.06834 1.44069 0.170829 0.277883 0.120995 1.56056e-16 0.25801 -0.277883 0.120995 
+2.83 0.562089 0.172042 1 1.07092 1.43791 0.172042 0.278044 0.121324 1.56923e-16 0.257352 -0.278044 0.121324 
+2.84 0.564871 0.173259 1 1.07348 1.43513 0.173259 0.278204 0.121652 1.50886e-16 0.256695 -0.278204 0.121652 
+2.85 0.567655 0.174479 1 1.07604 1.43235 0.174479 0.278363 0.12198 1.50435e-16 0.25604 -0.278363 0.12198 
+2.86 0.57044 0.175702 1 1.0786 1.42956 0.175702 0.278519 0.122307 1.48145e-16 0.255386 -0.278519 0.122307 
+2.87 0.573227 0.176928 1 1.08114 1.42677 0.176928 0.278675 0.122633 1.44398e-16 0.254734 -0.278675 0.122633 
+2.88 0.576015 0.178158 1 1.08368 1.42398 0.178158 0.278828 0.122959 1.40634e-16 0.254083 -0.278828 0.122959 
+2.89 0.578805 0.17939 1 1.08622 1.4212 0.17939 0.27898 0.123283 1.35118e-16 0.253433 -0.27898 0.123283 
+2.9 0.581596 0.180626 1 1.08875 1.4184 0.180626 0.279131 0.123608 1.3314e-16 0.252785 -0.279131 0.123608 
+2.91 0.584389 0.181866 1 1.09127 1.41561 0.181866 0.27928 0.123931 1.32394e-16 0.252138 -0.27928 0.123931 
+2.92 0.587183 0.183108 1 1.09378 1.41282 0.183108 0.279427 0.124254 1.30243e-16 0.251492 -0.279427 0.124254 
+2.93 0.589979 0.184354 1 1.09629 1.41002 0.184354 0.279573 0.124576 1.29965e-16 0.250848 -0.279573 0.124576 
+2.94 0.592776 0.185603 1 1.09879 1.40722 0.185603 0.279718 0.124898 1.27988e-16 0.250205 -0.279718 0.124898 
+2.95 0.595575 0.186855 1 1.10129 1.40443 0.186855 0.279861 0.125218 1.27537e-16 0.249563 -0.279861 0.125218 
+2.96 0.598375 0.188111 1 1.10378 1.40163 0.188111 0.280003 0.125539 1.3059e-16 0.248923 -0.280003 0.125539 
+2.97 0.601176 0.189369 1 1.10626 1.39882 0.189369 0.280143 0.125858 1.26756e-16 0.248284 -0.280143 0.125858 
+2.98 0.603979 0.190631 1 1.10874 1.39602 0.190631 0.280282 0.126177 1.23235e-16 0.247646 -0.280282 0.126177 
+2.99 0.606783 0.191896 1 1.11121 1.39322 0.191896 0.280419 0.126496 1.21465e-16 0.247009 -0.280419 0.126496 
+3 0.609589 0.193164 1 1.11367 1.39041 0.193164 0.280555 0.126813 1.19869e-16 0.246373 -0.280555 0.126813 
+3.01 0.612396 0.194435 1 1.11613 1.3876 0.194435 0.280689 0.12713 1.15238e-16 0.245739 -0.280689 0.12713 
+3.02 0.615204 0.19571 1 1.11858 1.3848 0.19571 0.280822 0.127447 1.09079e-16 0.245106 -0.280822 0.127447 
+3.03 0.618014 0.196987 1 1.12103 1.38199 0.196987 0.280954 0.127763 1.01464e-16 0.244474 -0.280954 0.127763 
+3.04 0.620824 0.198268 1 1.12346 1.37918 0.198268 0.281085 0.128078 8.91301e-17 0.243843 -0.281085 0.128078 
+3.05 0.623636 0.199552 1 1.1259 1.37636 0.199552 0.281214 0.128393 7.70911e-17 0.243214 -0.281214 0.128393 
+3.06 0.62645 0.200839 1 1.12832 1.37355 0.200839 0.281341 0.128707 7.0239e-17 0.242585 -0.281341 0.128707 
+3.07 0.629265 0.202129 1 1.13074 1.37074 0.202129 0.281468 0.129021 6.1999e-17 0.241958 -0.281468 0.129021 
+3.08 0.632081 0.203423 1 1.13315 1.36792 0.203423 0.281593 0.129334 5.38805e-17 0.241332 -0.281593 0.129334 
+3.09 0.634898 0.204719 1 1.13556 1.3651 0.204719 0.281716 0.129647 4.27609e-17 0.240707 -0.281716 0.129647 
+3.1 0.637716 0.206019 1 1.13796 1.36228 0.206019 0.281839 0.129958 3.49894e-17 0.240083 -0.281839 0.129958 
+3.11 0.640536 0.207322 1 1.14036 1.35946 0.207322 0.28196 0.13027 3.07046e-17 0.23946 -0.28196 0.13027 
+3.12 0.643356 0.208627 1 1.14275 1.35664 0.208627 0.282079 0.130581 2.32626e-17 0.238838 -0.282079 0.130581 
+3.13 0.646178 0.209936 1 1.14513 1.35382 0.209936 0.282198 0.130891 1.77289e-17 0.238218 -0.282198 0.130891 
+3.14 0.649002 0.211248 1 1.1475 1.351 0.211248 0.282315 0.131201 1.08073e-17 0.237598 -0.282315 0.131201 
+3.15 0.651826 0.212563 1 1.14987 1.34817 0.212563 0.282431 0.13151 4.11129e-18 0.23698 -0.282431 0.13151 
+3.16 0.654651 0.213882 1 1.15224 1.34535 0.213882 0.282546 0.131819 -5.67255e-18 0.236362 -0.282546 0.131819 
+3.17 0.657478 0.215203 1 1.15459 1.34252 0.215203 0.282659 0.132127 -1.22125e-17 0.235746 -0.282659 0.132127 
+3.18 0.660306 0.216527 1 1.15695 1.33969 0.216527 0.282771 0.132435 -1.99493e-17 0.23513 -0.282771 0.132435 
+3.19 0.663134 0.217855 1 1.15929 1.33687 0.217855 0.282882 0.132742 -2.60035e-17 0.234516 -0.282882 0.132742 
+3.2 0.665964 0.219185 1 1.16163 1.33404 0.219185 0.282992 0.133049 -3.46945e-17 0.233902 -0.282992 0.133049 
+3.21 0.668795 0.220519 1 1.16396 1.3312 0.220519 0.283101 0.133355 -4.29344e-17 0.23329 -0.283101 0.133355 
+3.22 0.671627 0.221855 1 1.16629 1.32837 0.221855 0.283208 0.133661 -5.10529e-17 0.232678 -0.283208 0.133661 
+3.23 0.674461 0.223195 1 1.16861 1.32554 0.223195 0.283314 0.133966 -5.72632e-17 0.232068 -0.283314 0.133966 
+3.24 0.677295 0.224538 1 1.17092 1.32271 0.224538 0.283419 0.134271 -6.79838e-17 0.231458 -0.283419 0.134271 
+3.25 0.68013 0.225883 1 1.17323 1.31987 0.225883 0.283523 0.134575 -7.97279e-17 0.23085 -0.283523 0.134575 
+3.26 0.682966 0.227232 1 1.17554 1.31703 0.227232 0.283625 0.134879 -8.83495e-17 0.230242 -0.283625 0.134879 
+3.27 0.685804 0.228584 1 1.17783 1.3142 0.228584 0.283727 0.135182 -9.65721e-17 0.229636 -0.283727 0.135182 
+3.28 0.688642 0.229939 1 1.18012 1.31136 0.229939 0.283827 0.135485 -1.0764e-16 0.22903 -0.283827 0.135485 
+3.29 0.691481 0.231297 1 1.18241 1.30852 0.231297 0.283926 0.135788 -1.19939e-16 0.228425 -0.283926 0.135788 
+3.3 0.694321 0.232658 1 1.18468 1.30568 0.232658 0.284024 0.13609 -1.27624e-16 0.227821 -0.284024 0.13609 
+3.31 0.697163 0.234022 1 1.18696 1.30284 0.234022 0.284121 0.136391 -1.35256e-16 0.227218 -0.284121 0.136391 
+3.32 0.700005 0.235388 1 1.18922 1.3 0.235388 0.284217 0.136692 -1.42802e-16 0.226616 -0.284217 0.136692 
+3.33 0.702848 0.236758 1 1.19148 1.29715 0.236758 0.284311 0.136993 -1.49047e-16 0.226014 -0.284311 0.136993 
+3.34 0.705692 0.238131 1 1.19374 1.29431 0.238131 0.284405 0.137293 -1.55015e-16 0.225414 -0.284405 0.137293 
+3.35 0.708537 0.239507 1 1.19599 1.29146 0.239507 0.284497 0.137593 -1.59352e-16 0.224814 -0.284497 0.137593 
+3.36 0.711383 0.240886 1 1.19823 1.28862 0.240886 0.284588 0.137892 -1.64851e-16 0.224216 -0.284588 0.137892 
+3.37 0.71423 0.242268 1 1.20046 1.28577 0.242268 0.284678 0.138191 -1.71634e-16 0.223618 -0.284678 0.138191 
+3.38 0.717077 0.243653 1 1.20269 1.28292 0.243653 0.284767 0.13849 -1.76994e-16 0.22302 -0.284767 0.13849 
+3.39 0.719926 0.245041 1 1.20492 1.28007 0.245041 0.284855 0.138788 -1.82198e-16 0.222424 -0.284855 0.138788 
+3.4 0.722775 0.246432 1 1.20714 1.27722 0.246432 0.284942 0.139086 -1.87263e-16 0.221829 -0.284942 0.139086 
+3.41 0.725625 0.247826 1 1.20935 1.27437 0.247826 0.285028 0.139383 -1.91999e-16 0.221234 -0.285028 0.139383 
+3.42 0.728477 0.249222 1 1.21156 1.27152 0.249222 0.285113 0.13968 -1.94098e-16 0.22064 -0.285113 0.13968 
+3.43 0.731329 0.250622 1 1.21376 1.26867 0.250622 0.285196 0.139976 -1.98782e-16 0.220047 -0.285196 0.139976 
+3.44 0.734181 0.252025 1 1.21595 1.26582 0.252025 0.285279 0.140273 -2.03206e-16 0.219455 -0.285279 0.140273 
+3.45 0.737035 0.25343 1 1.21814 1.26297 0.25343 0.285361 0.140568 -2.07369e-16 0.218863 -0.285361 0.140568 
+3.46 0.739889 0.254839 1 1.22032 1.26011 0.254839 0.285441 0.140864 -2.11532e-16 0.218272 -0.285441 0.140864 
+3.47 0.742745 0.256251 1 1.2225 1.25726 0.256251 0.285521 0.141159 -2.13007e-16 0.217682 -0.285521 0.141159 
+3.48 0.745601 0.257665 1 1.22467 1.2544 0.257665 0.285599 0.141453 -2.17031e-16 0.217093 -0.285599 0.141453 
+3.49 0.748457 0.259083 1 1.22683 1.25154 0.259083 0.285676 0.141748 -2.19633e-16 0.216504 -0.285676 0.141748 
+3.5 0.751315 0.260503 1 1.22899 1.24869 0.260503 0.285753 0.142042 -2.20978e-16 0.215917 -0.285753 0.142042 
+3.51 0.754173 0.261927 1 1.23115 1.24583 0.261927 0.285828 0.142335 -2.23493e-16 0.215329 -0.285828 0.142335 
+3.52 0.757032 0.263353 1 1.23329 1.24297 0.263353 0.285903 0.142629 -2.2247e-16 0.214743 -0.285903 0.142629 
+3.53 0.759892 0.264782 1 1.23544 1.24011 0.264782 0.285976 0.142921 -2.21559e-16 0.214157 -0.285976 0.142921 
+3.54 0.762752 0.266214 1 1.23757 1.23725 0.266214 0.286048 0.143214 -2.23068e-16 0.213572 -0.286048 0.143214 
+3.55 0.765614 0.267649 1 1.2397 1.23439 0.267649 0.28612 0.143506 -2.22036e-16 0.212988 -0.28612 0.143506 
+3.56 0.768475 0.269087 1 1.24183 1.23152 0.269087 0.28619 0.143798 -2.22149e-16 0.212404 -0.28619 0.143798 
+3.57 0.771338 0.270528 1 1.24394 1.22866 0.270528 0.286259 0.14409 -2.21108e-16 0.211821 -0.286259 0.14409 
+3.58 0.774201 0.271972 1 1.24606 1.2258 0.271972 0.286328 0.144381 -2.2247e-16 0.211239 -0.286328 0.144381 
+3.59 0.777065 0.273419 1 1.24816 1.22293 0.273419 0.286395 0.144672 -2.2142e-16 0.210657 -0.286395 0.144672 
+3.6 0.77993 0.274868 1 1.25026 1.22007 0.274868 0.286462 0.144962 -2.20501e-16 0.210076 -0.286462 0.144962 
+3.61 0.782795 0.276321 1 1.25236 1.2172 0.276321 0.286527 0.145252 -2.21732e-16 0.209495 -0.286527 0.145252 
+3.62 0.785661 0.277776 1 1.25445 1.21434 0.277776 0.286592 0.145542 -2.20527e-16 0.208915 -0.286592 0.145542 
+3.63 0.788528 0.279234 1 1.25653 1.21147 0.279234 0.286655 0.145832 -2.20553e-16 0.208336 -0.286655 0.145832 
+3.64 0.791395 0.280696 1 1.25861 1.20861 0.280696 0.286718 0.146121 -2.19607e-16 0.207757 -0.286718 0.146121 
+3.65 0.794263 0.28216 1 1.26068 1.20574 0.28216 0.28678 0.14641 -2.16528e-16 0.207179 -0.28678 0.14641 
+3.66 0.797131 0.283627 1 1.26275 1.20287 0.283627 0.28684 0.146699 -2.1776e-16 0.206602 -0.28684 0.146699 
+3.67 0.8 0.285097 1 1.26481 1.2 0.285097 0.2869 0.146988 -2.16606e-16 0.206025 -0.2869 0.146988 
+3.68 0.80287 0.286569 1 1.26686 1.19713 0.286569 0.286959 0.147276 -2.15505e-16 0.205449 -0.286959 0.147276 
+3.69 0.80574 0.288045 1 1.26891 1.19426 0.288045 0.287017 0.147564 -2.17413e-16 0.204873 -0.287017 0.147564 
+3.7 0.808611 0.289524 1 1.27095 1.19139 0.289524 0.287074 0.147851 -2.17161e-16 0.204298 -0.287074 0.147851 
+3.71 0.811482 0.291005 1 1.27299 1.18852 0.291005 0.28713 0.148139 -2.16927e-16 0.203723 -0.28713 0.148139 
+3.72 0.814354 0.292489 1 1.27502 1.18565 0.292489 0.287185 0.148426 -2.16632e-16 0.203149 -0.287185 0.148426 
+3.73 0.817226 0.293976 1 1.27705 1.18277 0.293976 0.287239 0.148712 -2.14412e-16 0.202575 -0.287239 0.148712 
+3.74 0.820099 0.295466 1 1.27907 1.1799 0.295466 0.287292 0.148999 -2.1416e-16 0.202002 -0.287292 0.148999 
+3.75 0.822972 0.296959 1 1.28108 1.17703 0.296959 0.287345 0.149285 -2.13969e-16 0.201429 -0.287345 0.149285 
+3.76 0.825846 0.298455 1 1.28309 1.17415 0.298455 0.287396 0.149571 -2.11914e-16 0.200857 -0.287396 0.149571 
+3.77 0.828721 0.299953 1 1.28509 1.17128 0.299953 0.287447 0.149857 -2.10014e-16 0.200286 -0.287447 0.149857 
+3.78 0.831596 0.301455 1 1.28709 1.1684 0.301455 0.287496 0.150143 -2.09893e-16 0.199715 -0.287496 0.150143 
+3.79 0.834471 0.302959 1 1.28908 1.16553 0.302959 0.287545 0.150428 -2.09954e-16 0.199144 -0.287545 0.150428 
+3.8 0.837347 0.304466 1 1.29107 1.16265 0.304466 0.287593 0.150713 -2.07386e-16 0.198574 -0.287593 0.150713 
+3.81 0.840224 0.305976 1 1.29305 1.15978 0.305976 0.28764 0.150998 -2.05756e-16 0.198004 -0.28764 0.150998 
+3.82 0.8431 0.307489 1 1.29502 1.1569 0.307489 0.287686 0.151283 -2.04151e-16 0.197435 -0.287686 0.151283 
+3.83 0.845978 0.309005 1 1.29699 1.15402 0.309005 0.287731 0.151567 -2.02607e-16 0.196866 -0.287731 0.151567 
+3.84 0.848856 0.310523 1 1.29895 1.15114 0.310523 0.287775 0.151851 -2.00352e-16 0.196298 -0.287775 0.151851 
+3.85 0.851734 0.312045 1 1.30091 1.14827 0.312045 0.287819 0.152135 -1.9827e-16 0.19573 -0.287819 0.152135 
+3.86 0.854612 0.313569 1 1.30286 1.14539 0.313569 0.287861 0.152419 -1.94749e-16 0.195162 -0.287861 0.152419 
+3.87 0.857491 0.315096 1 1.30481 1.14251 0.315096 0.287903 0.152702 -1.90663e-16 0.194595 -0.287903 0.152702 
+3.88 0.860371 0.316626 1 1.30675 1.13963 0.316626 0.287944 0.152986 -1.88929e-16 0.194029 -0.287944 0.152986 
+3.89 0.863251 0.318158 1 1.30868 1.13675 0.318158 0.287984 0.153269 -1.87133e-16 0.193462 -0.287984 0.153269 
+3.9 0.866131 0.319694 1 1.31061 1.13387 0.319694 0.288023 0.153552 -1.84674e-16 0.192897 -0.288023 0.153552 
+3.91 0.869011 0.321232 1 1.31254 1.13099 0.321232 0.288061 0.153834 -1.8166e-16 0.192331 -0.288061 0.153834 
+3.92 0.871892 0.322773 1 1.31445 1.12811 0.322773 0.288098 0.154117 -1.78742e-16 0.191766 -0.288098 0.154117 
+3.93 0.874774 0.324317 1 1.31637 1.12523 0.324317 0.288135 0.154399 -1.75966e-16 0.191201 -0.288135 0.154399 
+3.94 0.877656 0.325864 1 1.31827 1.12234 0.325864 0.288171 0.154682 -1.74713e-16 0.190637 -0.288171 0.154682 
+3.95 0.880538 0.327414 1 1.32017 1.11946 0.327414 0.288205 0.154964 -1.73511e-16 0.190073 -0.288205 0.154964 
+3.96 0.88342 0.328966 1 1.32207 1.11658 0.328966 0.288239 0.155245 -1.7113e-16 0.189509 -0.288239 0.155245 
+3.97 0.886303 0.330522 1 1.32396 1.1137 0.330522 0.288272 0.155527 -1.6826e-16 0.188946 -0.288272 0.155527 
+3.98 0.889186 0.33208 1 1.32584 1.11081 0.33208 0.288305 0.155809 -1.67301e-16 0.188383 -0.288305 0.155809 
+3.99 0.892069 0.333641 1 1.32772 1.10793 0.333641 0.288336 0.15609 -1.65133e-16 0.18782 -0.288336 0.15609 
+4 0.894953 0.335204 1 1.32959 1.10505 0.335204 0.288366 0.156371 -1.63051e-16 0.187258 -0.288366 0.156371 
diff --git a/ex20_solution/demo_mass_spring.cpp b/ex20_solution/demo_mass_spring.cpp
new file mode 100644
index 000000000..073259abc
--- /dev/null
+++ b/ex20_solution/demo_mass_spring.cpp
@@ -0,0 +1,66 @@
+#include "mass_spring.hpp"
+#include "mss_function.hpp"
+#include <iostream>
+#include <fstream>
+#include <cmath>
+
+// simple integrator (symplectic explicit) just for demo output
+int main(){
+    // Build a 3-mass chain (like double pendulum with 3 masses)
+    int n_masses = 3;
+    MassSpringSystem sys(n_masses, 2);
+    sys.mass = {1.0, 1.0, 1.0};
+
+    // positions: equilateral triangle for spinning top demo OR chain initial positions
+    // We'll build a chain along x-axis with spacing 1.0 and then also create constraints
+    double spacing = 1.0;
+    VectorD q(sys.dimX()), v(sys.dimX());
+    for(int i=0;i<n_masses;++i){
+        q[i*2 + 0] = i * spacing; // x
+        q[i*2 + 1] = 0.0;         // y
+        v[i*2 + 0] = 0.0;
+        v[i*2 + 1] = 0.0;
+    }
+
+    // add distance constraints between consecutive masses (chain)
+    sys.addDistanceConstraint(0,1, spacing);
+    sys.addDistanceConstraint(1,2, spacing);
+
+    // set initial velocities: small upward velocity on middle mass to excite
+    v[1*2 + 1] = 0.5;
+
+    // Time stepping
+    double dt = 0.01;
+    double T = 4.0;
+    std::ofstream ofs("mass_spring_output.txt");
+    ofs << "t ";
+    for(int i=0;i<n_masses;++i) ofs << "x" << i << " y" << i << " ";
+    for(int i=0;i<n_masses;++i) ofs << "vx" << i << " vy" << i << " ";
+    ofs << "\n";
+
+    int steps = int(T/dt);
+    for(int s=0;s<=steps;++s){
+        double t = s * dt;
+        ofs << t << " ";
+        for(int i=0;i<n_masses;++i){
+            ofs << q[i*2 + 0] << " " << q[i*2 + 1] << " ";
+        }
+        for(int i=0;i<n_masses;++i){
+            ofs << v[i*2 + 0] << " " << v[i*2 + 1] << " ";
+        }
+        ofs << "\n";
+
+        // compute acceleration via augmented constraint solver
+        VectorD qdd, lambda;
+        sys.computeAccelerationsConstraint(q, v, qdd, lambda, true, 10.0); // with small stabilization
+
+        // explicit symplectic Euler (simple)
+        for(int i=0;i<sys.dimX();++i){
+            v[i] += qdd[i] * dt;
+            q[i] += v[i] * dt;
+        }
+    }
+    ofs.close();
+    std::cout<<"Written mass_spring_output.txt\n";
+    return 0;
+}
diff --git a/ex20_solution/linear_solve.hpp b/ex20_solution/linear_solve.hpp
new file mode 100644
index 000000000..231cfa787
--- /dev/null
+++ b/ex20_solution/linear_solve.hpp
@@ -0,0 +1,49 @@
+#pragma once
+#include "matrix.hpp"
+#include "vector.hpp"
+#include <cmath>
+#include <algorithm>
+#include <stdexcept>
+
+// Simple dense Gaussian elimination with partial pivoting.
+
+inline bool solveLinearSystem(const Matrix& A_in, const VectorD& b_in, VectorD& x_out) {
+    int N = A_in.rows();
+    if(A_in.cols() != N) return false;
+    if(b_in.size() != N) return false;
+    Matrix A = A_in; // copy
+    VectorD b = b_in; // copy
+    x_out.resize(N);
+
+    // make sure b has contiguous data
+    for(int k=0;k<N;++k){
+        // pivot
+        int piv = k;
+        double maxv = std::fabs(A(k,k));
+        for(int i=k+1;i<N;++i){
+            double v = std::fabs(A(i,k));
+            if(v > maxv){ maxv = v; piv = i; }
+        }
+        if(maxv < 1e-15) return false;
+        if(piv != k){
+            for(int j=k;j<N;++j) std::swap(A(k,j), A(piv,j));
+            std::swap(b[k], b[piv]);
+        }
+        double akk = A(k,k);
+        // normalize row k
+        for(int j=k+1;j<N;++j) A(k,j) /= akk;
+        b[k] /= akk;
+        for(int i=k+1;i<N;++i){
+            double factor = A(i,k);
+            for(int j=k+1;j<N;++j) A(i,j) -= factor * A(k,j);
+            b[i] -= factor * b[k];
+        }
+    }
+    // back substitution
+    for(int i=N-1;i>=0;--i){
+        double s = b[i];
+        for(int j=i+1;j<N;++j) s -= A(i,j) * x_out[j];
+        x_out[i] = s; // diagonal normalized
+    }
+    return true;
+}
diff --git a/ex20_solution/mass_spring.cpp b/ex20_solution/mass_spring.cpp
new file mode 100644
index 000000000..e69de29bb
diff --git a/ex20_solution/mass_spring.hpp b/ex20_solution/mass_spring.hpp
new file mode 100644
index 000000000..2b9a18772
--- /dev/null
+++ b/ex20_solution/mass_spring.hpp
@@ -0,0 +1,230 @@
+#pragma once
+// mass_spring.hpp
+
+
+#include <vector>
+#include <cmath>
+#include <stdexcept>
+#include <cassert>
+
+#ifndef VECTOR_D_DEFINED_BY_REPO
+// If your repo already has VectorD, include its header above and undef this block.
+using VectorD = std::vector<double>;
+#endif
+
+struct DistanceConstraint {
+    int i, j;      // mass indices
+    double rest;   // rest length
+    DistanceConstraint(int ii = 0, int jj = 0, double r = 0.0) : i(ii), j(jj), rest(r) {}
+};
+
+class MassSpringSystem {
+public:
+    // n_masses : number of point masses
+    // dim : spatial dimension (2 for the exercise)
+    MassSpringSystem(int n_masses = 0, int dim = 2)
+      : n(n_masses), dim(dim), mass(n_masses, 1.0)
+    {
+        if (n < 0) throw std::runtime_error("n_masses must be >= 0");
+    }
+
+    // public data (simple)
+    std::vector<double> mass;                 // length n
+    std::vector<DistanceConstraint> cons;     // distance constraints
+
+    int dimX() const { return n * dim; }
+    int numMasses() const { return n; }
+    int spaceDim() const { return dim; }
+
+    // add constraint between mass i and j with rest length L
+    void addDistanceConstraint(int i, int j, double L) {
+        if (i < 0 || j < 0 || i >= n || j >= n) throw std::runtime_error("constraint indices out of range");
+        cons.emplace_back(i, j, L);
+    }
+
+    // Compute accelerations qdd and Lagrange multipliers lambda for distance constraints.
+    // q, v are vectors of length dimX(). qdd and lambda are output (resized inside).
+    // stabilization: if true use Baumgarte-like stabilization, stab_k is strength.
+    void computeAccelerationsConstraint(const VectorD& q, const VectorD& v,
+                                         VectorD& qdd, VectorD& lambda,
+                                         bool stabilization = true, double stab_k = 50.0) const
+    {
+        if ((int)q.size() != dimX() || (int)v.size() != dimX()) {
+            throw std::runtime_error("q or v size mismatch");
+        }
+
+        // zero right-hand acceleration
+        qdd.assign(dimX(), 0.0);
+
+        int m = (int)cons.size();
+        if (m == 0) {
+            // no constraints -> zero acceleration (no internal forces implemented)
+            return;
+        }
+
+        // Build J (m x dimX), g (m), Jv (m)
+        // We'll compute A = J * M^{-1} * J^T (m x m) and rhs = -J * M^{-1} * f - Jdot*v - alpha*g - beta*Jv
+        // Here f = 0 (no springs/forces implemented). We use g = |ri - rj|^2 - rest^2.
+        // J rows: for constraint k between i and j: derivative of g w.r.t q is:
+        //   dg/dqi = 2*(qi - qj), dg/dqj = -2*(qi - qj)
+        // So J_{k, idx} = 2 * (qi - qj) component.
+
+        // Precompute inverse mass diagonal
+        VectorD invM(n);
+        for (int i = 0; i < n; ++i) {
+            double mi = mass[i];
+            if (mi <= 0.0) throw std::runtime_error("mass must be > 0");
+            invM[i] = 1.0 / mi;
+        }
+
+        // Compute g and Jv and store small data for each constraint
+        std::vector<double> g(m, 0.0);
+        std::vector<double> Jv(m, 0.0);
+        // For building A we need J*M^{-1}*J^T. We'll compute A_{kl} by summing contributions explicitly.
+        std::vector< std::vector<double> > A(m, std::vector<double>(m, 0.0));
+
+        // store per-constraint vector d = qi - qj (length dim)
+        std::vector< std::vector<double> > dvec(m, std::vector<double>(dim, 0.0));
+
+        for (int k = 0; k < m; ++k) {
+            int i = cons[k].i;
+            int j = cons[k].j;
+            double rest = cons[k].rest;
+
+            // d = qi - qj
+            for (int dd = 0; dd < dim; ++dd) {
+                double qi = q[i*dim + dd];
+                double qj = q[j*dim + dd];
+                dvec[k][dd] = qi - qj;
+            }
+            // g = |d|^2 - rest^2
+            double dotd = 0.0;
+            for (int dd=0; dd<dim; ++dd) dotd += dvec[k][dd] * dvec[k][dd];
+            g[k] = dotd - rest * rest;
+
+            // Jv = 2 * d · (vi - vj)
+            double dotdv = 0.0;
+            for (int dd=0; dd<dim; ++dd) {
+                double vi = v[i*dim + dd];
+                double vj = v[j*dim + dd];
+                dotdv += dvec[k][dd] * (vi - vj);
+            }
+            Jv[k] = 2.0 * dotdv;
+        }
+
+        // Build A matrix (m x m): A_{kl} = (J_k) M^{-1} (J_l)^T
+        // Note J_k has components 2*d_k at indices of mass i, and -2*d_k at indices of mass j.
+        // So contribution from mass p to A_{kl} = (component at p in J_k)*(component at p in J_l) * invM[p]
+        for (int k = 0; k < m; ++k) {
+            for (int l = 0; l < m; ++l) {
+                double sum = 0.0;
+                int ik = cons[k].i, jk = cons[k].j;
+                int il = cons[l].i, jl = cons[l].j;
+
+                // contributions from mass ik
+                for (int dd=0; dd<dim; ++dd) {
+                    double Jk_ik = 2.0 * dvec[k][dd];
+                    double Jl_ik = 0.0;
+                    if (il == ik) Jl_ik += 2.0 * dvec[l][dd];
+                    if (jl == ik) Jl_ik += -2.0 * dvec[l][dd];
+                    sum += Jk_ik * Jl_ik * invM[ik];
+                }
+                // contributions from mass jk
+                for (int dd=0; dd<dim; ++dd) {
+                    double Jk_jk = -2.0 * dvec[k][dd];
+                    double Jl_jk = 0.0;
+                    if (il == jk) Jl_jk += 2.0 * dvec[l][dd];
+                    if (jl == jk) Jl_jk += -2.0 * dvec[l][dd];
+                    sum += Jk_jk * Jl_jk * invM[jk];
+                }
+
+                A[k][l] = sum;
+            }
+        }
+
+        // Build rhs: rhs_k = - Jdot*v - alpha*g - beta*Jv
+        // choose simple stabilization coefficients
+        double alpha = stabilization ? stab_k : 0.0;
+        double beta  = stabilization ? (stab_k * 0.2) : 0.0;
+
+        std::vector<double> rhs(m, 0.0);
+        for (int k = 0; k < m; ++k) {
+            // Jdot*v is approximated by derivative of Jv; for our g formulation Jv is 2*d·(vi-vj)
+            // and Jdot*v approx = 2*(vi-vj)·(vi-vj) + 2*d·(ai - aj) -> we don't have a yet, so we drop second part.
+            // We use: rhs = - Jv_dot - alpha*g - beta*Jv. We approximate Jv_dot ~= 2*(vi-vj)·(vi-vj)
+            int i = cons[k].i, j = cons[k].j;
+            double approx_Jv_dot = 0.0;
+            for (int dd=0; dd<dim; ++dd) {
+                double dv = v[i*dim+dd] - v[j*dim+dd];
+                approx_Jv_dot += dv * dv * 2.0; // scaled
+            }
+            rhs[k] = - approx_Jv_dot - alpha * g[k] - beta * Jv[k];
+        }
+
+        // Solve A * lambda = rhs (m x m). Use naive Gaussian elimination (m is small typically).
+        lambda.assign(m, 0.0);
+        // If A nearly singular, add small regularization
+        double reg = 1e-10;
+        for (int i=0;i<m;i++) A[i][i] += reg;
+
+        // Gaussian elimination (in-place)
+        std::vector<std::vector<double>> B = A; // copy
+        std::vector<double> bb = rhs;
+        // forward elimination
+        for (int i = 0; i < m; ++i) {
+            // pivot
+            int piv = i;
+            double pivabs = std::fabs(B[i][i]);
+            for (int r = i+1; r < m; ++r) {
+                if (std::fabs(B[r][i]) > pivabs) { piv = r; pivabs = std::fabs(B[r][i]); }
+            }
+            if (pivabs < 1e-14) {
+                // singular-ish -> set lambda zero (fallback)
+                lambda.assign(m, 0.0);
+                // compute qdd = - M^{-1} J^T lambda = 0 -> already zero
+                return;
+            }
+            if (piv != i) {
+                std::swap(B[i], B[piv]);
+                std::swap(bb[i], bb[piv]);
+            }
+            double diag = B[i][i];
+            for (int c = i; c < m; ++c) B[i][c] /= diag;
+            bb[i] /= diag;
+            for (int r = i+1; r < m; ++r) {
+                double fac = B[r][i];
+                if (fac == 0.0) continue;
+                for (int c = i; c < m; ++c) B[r][c] -= fac * B[i][c];
+                bb[r] -= fac * bb[i];
+            }
+        }
+        // back substitution
+        for (int i = m-1; i >= 0; --i) {
+            double sum = bb[i];
+            for (int c = i+1; c < m; ++c) sum -= B[i][c] * lambda[c];
+            lambda[i] = sum; // since B[i][i] normalized to 1
+        }
+
+        // compute accelerations qdd = M^{-1} * ( - J^T * lambda )
+        // initialize qdd zero
+        qdd.assign(dimX(), 0.0);
+        for (int k = 0; k < m; ++k) {
+            int i = cons[k].i;
+            int j = cons[k].j;
+            double lam = lambda[k];
+            // J^T contributes +2*d * lam to mass i, and -2*d * lam to mass j (because J row had +2d for i and -2d for j)
+            for (int dd=0; dd<dim; ++dd) {
+                double contrib_i = 2.0 * dvec[k][dd] * lam;
+                double contrib_j = -2.0 * dvec[k][dd] * lam;
+                qdd[i*dim + dd] += contrib_i * invM[i]; // since we multiply by M^{-1} here
+                qdd[j*dim + dd] += contrib_j * invM[j];
+            }
+        }
+
+        // Note: this qdd contains only constraint-induced accelerations (no external forces or springs).
+    }
+
+private:
+    int n;   // number of masses
+    int dim; // spatial dimension
+};
diff --git a/ex20_solution/matrix.hpp b/ex20_solution/matrix.hpp
new file mode 100644
index 000000000..cbc19f7f8
--- /dev/null
+++ b/ex20_solution/matrix.hpp
@@ -0,0 +1,26 @@
+#pragma once
+#include <vector>
+#include <cassert>
+#include <cmath>
+#include <iomanip>
+#include <iostream>
+
+struct Matrix {
+    int r=0, c=0;
+    std::vector<double> d;
+    Matrix() = default;
+    Matrix(int rr, int cc) { resize(rr,cc); }
+    void resize(int rr, int cc) { r=rr; c=cc; d.assign(r*c, 0.0); }
+    void zero() { std::fill(d.begin(), d.end(), 0.0); }
+    double& operator()(int i,int j){ assert(i>=0 && i<r && j>=0 && j<c); return d[i*c + j]; }
+    double operator()(int i,int j) const { assert(i>=0 && i<r && j>=0 && j<c); return d[i*c + j]; }
+    int rows() const { return r; }
+    int cols() const { return c; }
+    void print(const char* name=nullptr) const {
+        if(name) std::cout<<name<<":\n";
+        for(int i=0;i<r;++i){
+            for(int j=0;j<c;++j) std::cout<<std::setw(12)<<operator()(i,j)<<" ";
+            std::cout<<"\n";
+        }
+    }
+};
diff --git a/ex20_solution/mss_function.cpp b/ex20_solution/mss_function.cpp
new file mode 100644
index 000000000..c9a754308
--- /dev/null
+++ b/ex20_solution/mss_function.cpp
@@ -0,0 +1,212 @@
+// mss_function.cpp  
+#include "mss_function.hpp"
+#include "linear_solve.hpp"
+#include <stdexcept>
+#include <cmath>
+
+// helper to split x = [q; v]
+static void splitState(const VectorD& x, int n_q, VectorD& q, VectorD& v) {
+    q.assign(n_q, 0.0);
+    v.assign(n_q, 0.0);
+    for(int i=0;i<n_q;++i){ q[i]=x[i]; v[i]=x[n_q+i]; }
+}
+
+void MSS_Function::computeRHS(const VectorD& x, VectorD& fx) const {
+    int n_q = sys.dimX();
+    VectorD q, v;
+    splitState(x, n_q, q, v);
+
+    VectorD qdd, lambda;
+    sys.computeAccelerationsConstraint(q, v, qdd, lambda);
+
+    fx.resize(2*n_q);
+    // dx/dt = [ v ; qdd ]
+    for(int i=0;i<n_q;++i){ fx[i] = v[i]; fx[n_q + i] = qdd[i]; }
+}
+
+
+// -----------------------------------------------------------------------------
+// Exact Jacobian via loop-and-solve:
+// df/dx = [ 0    I
+//           d(qdd)/dq  d(qdd)/dv ]
+//
+// We compute qdd by solving augmented system A_aug * x_aug = b_aug where
+// x_aug = [ qdd (n_q) ; lambda (nc) ]
+// A_aug = [ M     G^T
+//           G     0   ]
+// b_aug = [ F
+//          -Gdotv ]
+// -----------------------------------------------------------------------------
+void MSS_Function::computeJacobian(const VectorD& x, Matrix& J) const {
+    int n_q = sys.dimX();
+    int stateN = 2 * n_q;
+    J.resize(stateN, stateN); J.zero();
+
+    // top-right block = I
+    for(int i=0;i<n_q;++i) J(i, n_q + i) = 1.0;
+
+    // split state
+    VectorD q, v;
+    splitState(x, n_q, q, v);
+
+    // number of constraints
+    int nc = (int)sys.cons.size();
+
+    // Build mass matrix M (n_q x n_q) as diagonal
+    Matrix M(n_q, n_q); M.zero();
+    for(int mi = 0; mi < sys.numMasses(); ++mi){
+        double mval = sys.mass[mi];
+        if (mval <= 0.0) throw std::runtime_error("mass must be > 0");
+        for(int dd=0; dd<sys.spaceDim(); ++dd){
+            int idx = mi*sys.spaceDim() + dd;
+            M(idx, idx) = mval;
+        }
+    }
+
+    // Build G (nc x n_q) and Gdotv (nc) and phi (constraint gap)
+    Matrix G(nc, n_q); G.zero();
+    VectorD Gdotv(nc, 0.0);
+    VectorD phi(nc, 0.0);
+
+    // Precompute dvec per constraint (d = qi - qj)
+    std::vector<std::vector<double>> dvec(nc, std::vector<double>(sys.spaceDim(), 0.0));
+    for(int r=0;r<nc;++r){
+        int i = sys.cons[r].i;
+        int j = sys.cons[r].j;
+        double rest = sys.cons[r].rest;
+        double dotd = 0.0;
+        for(int dd=0; dd<sys.spaceDim(); ++dd){
+            double di = q[i*sys.spaceDim()+dd];
+            double dj = q[j*sys.spaceDim()+dd];
+            double dcomp = di - dj;
+            dvec[r][dd] = dcomp;
+            dotd += dcomp * dcomp;
+            // set G at the coordinate positions
+            int idx_i = i*sys.spaceDim() + dd;
+            int idx_j = j*sys.spaceDim() + dd;
+            // Following the constraint formulation used in computeAccelerationsConstraint:
+            // G row stores 2*d at i-coordinates and -2*d at j-coordinates
+            G(r, idx_i) = 2.0 * dcomp;
+            G(r, idx_j) = -2.0 * dcomp;
+        }
+        phi[r] = dotd - rest*rest;
+        // Gdotv = 2 * d · (v_i - v_j)
+        double dotdv = 0.0;
+        for(int dd=0; dd<sys.spaceDim(); ++dd){
+            double vi = v[i*sys.spaceDim()+dd];
+            double vj = v[j*sys.spaceDim()+dd];
+            dotdv += dvec[r][dd] * (vi - vj);
+        }
+        Gdotv[r] = 2.0 * dotdv;
+    }
+
+    // Build b_aug: top F (no internal forces in simple model -> zero), bottom = -Gdotv
+    int Naug = n_q + nc;
+    VectorD b(Naug, 0.0);
+    // top is F (zero)
+    for(int idx=0; idx<n_q; ++idx) b[idx] = 0.0;
+    for(int r=0;r<nc;++r) b[n_q + r] = - Gdotv[r];
+
+    // Build augmented matrix A_aug (Naug x Naug)
+    Matrix A(Naug, Naug); A.zero();
+    // top-left = M
+    for(int i=0;i<n_q;++i) for(int j=0;j<n_q;++j) A(i,j) = M(i,j);
+    // top-right (i, n_q + r) = G(r,i)
+    for(int r=0;r<nc;++r) for(int i=0;i<n_q;++i) A(i, n_q + r) = G(r, i);
+    // bottom-left (n_q + r, i) = G(r,i)
+    for(int r=0;r<nc;++r) for(int i=0;i<n_q;++i) A(n_q + r, i) = G(r, i);
+    // bottom-right zero (already zero)
+
+    // Solve base augmented system A * xaug = b
+    VectorD xaug;
+    if (!solveLinearSystem(A, b, xaug)) throw std::runtime_error("Base augmented solve failed in Jacobian");
+
+    // Now compute derivative columns
+    VectorD rhs(Naug), y(Naug);
+
+    // Precompute xaug components: first n_q are qdd_base, rest are lambda_base (not used directly here)
+    // Loop over q-derivatives (d/dq_k)
+    for(int k=0;k<n_q;++k){
+        // db/dq_k : top part dF/dq_k = 0 (no internal springs here)
+        // bottom part d(-Gdotv)/dq_k = - d(Gdotv)/dq_k
+        // recall Gdotv[r] = 2 * dvec[r] · (v_i - v_j)
+        // derivative wrt a coordinate q_k affects dvec entries:
+        // if k corresponds to coordinate dd of mass i -> d(dvec[r][dd])/dq_k = 1 (if that constraint uses i)
+        // if k is coordinate dd of mass j -> derivative is -1
+        for(int i=0;i<Naug;++i) rhs[i] = 0.0;
+
+        for(int r=0;r<nc;++r){
+            const auto &C = sys.cons[r];
+            int ii = C.i, jj = C.j;
+            for(int dd=0; dd<sys.spaceDim(); ++dd){
+                int idx_i = ii*sys.spaceDim() + dd;
+                int idx_j = jj*sys.spaceDim() + dd;
+                if(k == idx_i){
+                    // d(Gdotv)/dq_k contribution: 2 * (v_i - v_j)[dd]
+                    rhs[n_q + r] -= 2.0 * ( v[ii*sys.spaceDim()+dd] - v[jj*sys.spaceDim()+dd] );
+                } else if(k == idx_j){
+                    // derivative of dvec is -1 -> contribution -2*(v_i - v_j) * (-1) => +2*(v_i - v_j)
+                    rhs[n_q + r] -= 2.0 * ( - (v[ii*sys.spaceDim()+dd] - v[jj*sys.spaceDim()+dd]) );
+                    // simplify: that's +2*(v[ii]-v[jj])? but above sign covers
+                }
+            }
+            // Note: we DID NOT include stabilization derivatives here; if you use Baumgarte terms, add them.
+        }
+
+        // Compute (dA/dq_k) * xaug and subtract: rhs_total = db_dqk - dA_dqk * xaug
+        // dA/dq_k nonzero only in entries where G depends on q (top-right and bottom-left blocks)
+        // For a given constraint r and coordinate c:
+        // dG(r,c)/dq_k = derivative of 2*d_component: equals 2 if c==coord of mass i (same dd) and k==that coord,
+        // equals -2 if c==coord of mass j and k==that coord, else 0.
+        // Implement multiply dA * xaug without building dA.
+
+        VectorD temp(Naug, 0.0); // temp = (dA/dq_k) * xaug
+        for(int r=0;r<nc;++r){
+            const auto &C = sys.cons[r];
+            int ii = C.i, jj = C.j;
+            for(int dd=0; dd<sys.spaceDim(); ++dd){
+                int idx_i = ii*sys.spaceDim() + dd;
+                int idx_j = jj*sys.spaceDim() + dd;
+
+                if(k == idx_i){
+                    // dG(r, idx_i) / dq_k = 2
+                    // contributes to top-row idx_i: (dA)_{idx_i, n_q + r} = 2 -> multiply by xaug[n_q + r]
+                    temp[idx_i] += 2.0 * xaug[n_q + r];
+                    // contributes to bottom-row n_q + r: (dA)_{n_q + r, idx_i} = 2 -> multiply by xaug[idx_i]
+                    temp[n_q + r] += 2.0 * xaug[idx_i];
+                }
+                if(k == idx_j){
+                    // dG(r, idx_j) / dq_k = -2
+                    temp[idx_j] += -2.0 * xaug[n_q + r];
+                    temp[n_q + r] += -2.0 * xaug[idx_j];
+                }
+            }
+        }
+
+        // subtract temp
+        for(int i=0;i<Naug;++i) rhs[i] -= temp[i];
+
+        // solve A * y = rhs
+        if(!solveLinearSystem(A, rhs, y)) throw std::runtime_error("Jacobian column solve failed (dq)");
+        // store accelerations derivative dqdd/dq_k in Jacobian bottom-left block (rows n_q.., col k)
+        for(int i=0;i<n_q;++i) J(n_q + i, k) = y[i];
+    }
+
+    // now derivatives w.r.t. velocities (d/dv_k)
+    for(int k=0;k<n_q;++k){
+        for(int i=0;i<Naug;++i) rhs[i] = 0.0;
+
+        // db/dv_k : top part zero, bottom part = - d(Gdotv)/dv_k
+        // Gdotv[r] = 2 * sum_c (dvec[r,c] * v_c_contribution)
+        // derivative wrt v_k is simply 2 * d_component located at column k (i.e. G(r,k))
+        for(int r=0;r<nc;++r){
+            rhs[n_q + r] -= G(r, k);
+        }
+
+        // dA/dv_k = 0 (G does not depend on v), so no dA term
+        if(!solveLinearSystem(A, rhs, y)) throw std::runtime_error("Jacobian column solve failed (dv)");
+        for(int i=0;i<n_q;++i) J(n_q + i, n_q + k) = y[i];
+    }
+
+    // Top-left is zero already; top-right was set above; full Jacobian ready.
+}
diff --git a/ex20_solution/mss_function.hpp b/ex20_solution/mss_function.hpp
new file mode 100644
index 000000000..28c521d95
--- /dev/null
+++ b/ex20_solution/mss_function.hpp
@@ -0,0 +1,18 @@
+#pragma once
+#include "mass_spring.hpp"
+#include "vector.hpp"
+#include "matrix.hpp"
+
+// MSS_Function provides the RHS f(x) = [v; qdd] and an exact Jacobian
+struct MSS_Function {
+    MassSpringSystem sys;
+
+    MSS_Function() = default;
+    MSS_Function(const MassSpringSystem& s): sys(s) {}
+
+    // compute RHS: x = [q; v] (size 2*nq)
+    void computeRHS(const VectorD& x, VectorD& fx) const;
+
+    // compute exact Jacobian J (size 2*nq x 2*nq)
+    void computeJacobian(const VectorD& x, Matrix& J) const;
+};
diff --git a/ex20_solution/vector.hpp b/ex20_solution/vector.hpp
new file mode 100644
index 000000000..f63035702
--- /dev/null
+++ b/ex20_solution/vector.hpp
@@ -0,0 +1,28 @@
+#pragma once
+#include <vector>
+#include <cassert>
+#include <cmath>
+
+/*
+  Minimal vector class wrapper for matrix operations.
+  BUT we do NOT define VectorD here — the project uses
+  `using VectorD = std::vector<double>` from mass_spring.hpp.
+
+  That is the ONLY VectorD alias in the entire exercise.
+*/
+
+template<typename T>
+struct Vec {
+    std::vector<T> d;
+
+    Vec() {}
+    explicit Vec(size_t n): d(n) {}
+    void resize(size_t n) { d.resize(n); }
+    size_t size() const { return d.size(); }
+
+    T& operator[](size_t i) { return d[i]; }
+    const T& operator[](size_t i) const { return d[i]; }
+
+    void zero() { for(auto& x : d) x = T(0); }
+    void fill(T v) { std::fill(d.begin(), d.end(), v); }
+};
diff --git a/include/.ipynb_checkpoints/ExplicitEuler-checkpoint.hpp b/include/.ipynb_checkpoints/ExplicitEuler-checkpoint.hpp
new file mode 100644
index 000000000..326c3a2da
--- /dev/null
+++ b/include/.ipynb_checkpoints/ExplicitEuler-checkpoint.hpp
@@ -0,0 +1,16 @@
+#pragma once
+#include "timestepper.hpp"
+#include <memory>
+
+// This class implements the standard y_new = y + tau * f(y)
+class ExplicitEuler : public TimeStepper {
+public:
+    ExplicitEuler(std::shared_ptr<NonlinearFunction> rhs) 
+        : TimeStepper(rhs) {}
+
+    void doStep(double tau, VectorView<double> y) override {
+        Vector<> k1; 
+        m_rhs->evaluate(y, k1); // Evaluate f(y)
+        y += tau * k1;          // Update y
+    }
+};
\ No newline at end of file
diff --git a/include/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp b/include/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp
new file mode 100644
index 000000000..50e3c2633
--- /dev/null
+++ b/include/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp
@@ -0,0 +1,14 @@
+#pragma once
+#include "timestepper.hpp"
+class ImprovedEuler : public TimeStepper {
+    Vector<> k1, k2, tmp;
+public:
+    ImprovedEuler(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs), k1(rhs->dimF()), k2(rhs->dimF()), tmp(rhs->dimF()) {}
+    void doStep(double tau, VectorView<double> y) override {
+        m_rhs->evaluate(y, k1);
+        tmp = y + tau * k1;
+        m_rhs->evaluate(tmp, k2);
+        y += tau * (0.5 * k1 + 0.5 * k2);
+    }
+};
diff --git a/include/.ipynb_checkpoints/mass_spring-checkpoint.hpp b/include/.ipynb_checkpoints/mass_spring-checkpoint.hpp
new file mode 100644
index 000000000..86607b05d
--- /dev/null
+++ b/include/.ipynb_checkpoints/mass_spring-checkpoint.hpp
@@ -0,0 +1,29 @@
+// include/mass_spring.hpp
+#pragma once
+#include "nonlinear_function.hpp"  // repo's interface
+
+class MassSpring : public NonlinearFunction
+{
+  double m_mass;
+  double m_stiffness;
+
+public:
+  MassSpring (double m, double k)
+    : m_mass(m), m_stiffness(k) {}
+
+  size_t dimX() const override { return 2; }
+  size_t dimF() const override { return 2; }
+
+  void evaluate (VectorView<double> x, VectorView<double> f) const override
+  {
+    f(0) = x(1);
+    f(1) = -m_stiffness/m_mass * x(0);
+  }
+
+  void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
+  {
+    df = 0.0;
+    df(0,1) = 1;
+    df(1,0) = -m_stiffness/m_mass;
+  }
+};
diff --git a/include/.ipynb_checkpoints/plot_mass_spring-checkpoint.py b/include/.ipynb_checkpoints/plot_mass_spring-checkpoint.py
new file mode 100644
index 000000000..36b3a1518
--- /dev/null
+++ b/include/.ipynb_checkpoints/plot_mass_spring-checkpoint.py
@@ -0,0 +1,47 @@
+# python/plot_mass_spring.py
+import csv
+import matplotlib.pyplot as plt
+import numpy as np
+
+def read_csv(filename):
+    t, x, v = [], [], []
+    with open(filename) as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            t.append(float(row['t']))
+            x.append(float(row['x']))
+            v.append(float(row['v']))
+    return np.array(t), np.array(x), np.array(v)
+
+files = [
+    ("mass_explicit.csv", "Explicit Euler"),
+    ("mass_improved.csv", "Improved Euler"),
+    ("mass_crank.csv", "Crank-Nicolson (Picard)"),
+]
+
+plt.figure(figsize=(9,5))
+for fname, label in files:
+    t, x, v = read_csv(fname)
+    plt.plot(t, x, label=label)
+plt.xlabel("t")
+plt.ylabel("position x(t)")
+plt.legend()
+plt.title("Mass-Spring: position vs time")
+plt.grid(True)
+plt.tight_layout()
+plt.savefig("mass_position_compare.png")
+print("Wrote mass_position_compare.png")
+
+# phase plot
+plt.figure(figsize=(6,6))
+for fname, label in files:
+    t, x, v = read_csv(fname)
+    plt.plot(x, v, label=label)
+plt.xlabel("position x")
+plt.ylabel("velocity v")
+plt.legend()
+plt.title("Mass-Spring: phase plot")
+plt.grid(True)
+plt.tight_layout()
+plt.savefig("mass_phase_compare.png")
+print("Wrote mass_phase_compare.png")
diff --git a/include/.ipynb_checkpoints/timestepper-checkpoint.hpp b/include/.ipynb_checkpoints/timestepper-checkpoint.hpp
new file mode 100644
index 000000000..d67a282e3
--- /dev/null
+++ b/include/.ipynb_checkpoints/timestepper-checkpoint.hpp
@@ -0,0 +1,132 @@
+// include/timestepper.hpp
+#pragma once
+#include <memory>
+#include <vector>
+#include <iostream>
+#include <cmath>
+
+// forward declarations from repo's linear algebra
+// Replace these with the repo's real Vector / Matrix types.
+// Here I show pseudo-types to be adapted to the project's actual types.
+#include "nonlinear_function.hpp" // assume this exists in repo (NonlinearFunction)
+
+// The repo uses Vector<> and VectorView<> types; adapt includes if necessary.
+
+class TimeStepper
+{
+protected:
+  std::shared_ptr<NonlinearFunction> m_rhs;
+public:
+  TimeStepper(std::shared_ptr<NonlinearFunction> rhs) : m_rhs(rhs) {}
+  virtual ~TimeStepper() = default;
+  virtual void doStep(double tau, VectorView<double> y) = 0;
+};
+
+/// ExplicitEuler is likely already implemented in the repo; shown for reference
+class ExplicitEuler : public TimeStepper
+{
+  Vector<> m_vecf;
+public:
+  ExplicitEuler(std::shared_ptr<NonlinearFunction> rhs)
+    : TimeStepper(rhs), m_vecf(rhs->dimF()) {}
+
+  void doStep(double tau, VectorView<double> y) override
+  {
+    this->m_rhs->evaluate(y, m_vecf);
+    y += tau * m_vecf;
+  }
+};
+
+/// Improved Euler (Heun / explicit midpoint-like two-stage as defined in exercise)
+/// \tilde y = y_n + tau/2 * f(y_n)
+/// y_{n+1} = y_n + tau * f( \tilde y )
+class ImprovedEuler : public TimeStepper
+{
+  Vector<> m_vecf;     // f(y)
+  Vector<> m_vecft;    // f(tilde y)
+  Vector<> m_ytemp;    // temporary vector for tilde y
+public:
+  ImprovedEuler(std::shared_ptr<NonlinearFunction> rhs)
+    : TimeStepper(rhs),
+      m_vecf(rhs->dimF()),
+      m_vecft(rhs->dimF()),
+      m_ytemp(rhs->dimX()) {}
+
+  void doStep(double tau, VectorView<double> y) override
+  {
+    // evaluate f(y)
+    this->m_rhs->evaluate(y, m_vecf);
+
+    // tilde y = y + tau/2 * f(y)
+    m_ytemp = y;               // copy current y to temp
+    m_ytemp += (tau/2.0) * m_vecf;
+
+    // evaluate f(tilde y)
+    this->m_rhs->evaluate(m_ytemp, m_vecft);
+
+    // y_{n+1} = y_n + tau * f(tilde y)
+    y += tau * m_vecft;
+  }
+};
+
+/// CrankNicolson (semi-implicit): we implement a Picard (fixed-point) iteration:
+/// y^{k+1} = y_old + 0.5*tau*( f(y_old) + f(y^k) )
+/// start from predictor (Improved Euler or Explicit Euler)
+class CrankNicolson : public TimeStepper
+{
+  Vector<> m_fold;     // f(y_old)
+  Vector<> m_fk;       // f(y_k)
+  Vector<> m_yk;       // current iterate y^k
+  int m_max_iter;
+  double m_tol;
+public:
+  CrankNicolson(std::shared_ptr<NonlinearFunction> rhs,
+                int max_iter = 20, double tol = 1e-10)
+    : TimeStepper(rhs),
+      m_fold(rhs->dimF()),
+      m_fk(rhs->dimF()),
+      m_yk(rhs->dimX()),
+      m_max_iter(max_iter),
+      m_tol(tol) {}
+
+  void doStep(double tau, VectorView<double> y) override
+  {
+    // store old
+    Vector<> yold = y; // copy (Vector supports copy)
+
+    // evaluate f(yold)
+    this->m_rhs->evaluate(yold, m_fold);
+
+    // predictor: one ImprovedEuler step -> starting guess
+    // yk = yold + tau * f(yold)  (explicit Euler predictor)
+    m_yk = yold;
+    m_yk += tau * m_fold;
+
+    // Picard iteration (fixed-point)
+    for (int iter = 0; iter < m_max_iter; ++iter)
+    {
+      // evaluate f(y_k)
+      this->m_rhs->evaluate(m_yk, m_fk);
+
+      // compute new iterate
+      Vector<> ynew = yold;
+      ynew += 0.5 * tau * (m_fold + m_fk);
+
+      // check convergence (norm of difference)
+      double diffnorm = 0.0;
+      for (size_t i = 0; i < ynew.size(); ++i)
+      {
+        double d = ynew[i] - m_yk[i];
+        diffnorm += d*d;
+      }
+      diffnorm = std::sqrt(diffnorm);
+
+      m_yk = ynew;
+
+      if (diffnorm < m_tol) break;
+    }
+
+    // copy result back to y (view)
+    y = m_yk;
+  }
+};
diff --git a/include/CrankNicolson.hpp b/include/CrankNicolson.hpp
new file mode 100644
index 000000000..d9ac5c568
--- /dev/null
+++ b/include/CrankNicolson.hpp
@@ -0,0 +1,23 @@
+#pragma once
+#include "timestepper.hpp"
+#include "function_algebra.hpp"
+#include "newton.hpp"
+class CrankNicolson : public TimeStepper {
+    std::shared_ptr<NonlinearFunction> eq;
+    std::shared_ptr<Parameter> tau;
+    std::shared_ptr<ConstantFunction> yold, fold;
+    Vector<> ftmp;
+public:
+    CrankNicolson(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs), tau(std::make_shared<Parameter>(0.0)), ftmp(rhs->dimF()) {
+        yold = std::make_shared<ConstantFunction>(rhs->dimX());
+        fold = std::make_shared<ConstantFunction>(rhs->dimF());
+        auto id = std::make_shared<IdentityFunction>(rhs->dimX());
+        eq = id - yold - 0.5*tau*(fold + rhs);
+    }
+    void doStep(double tau, VectorView<double> y) override {
+        m_rhs->evaluate(y, ftmp); fold->set(ftmp);
+        yold->set(y); tau->set(tau);
+        NewtonSolver(eq, y);
+    }
+};
diff --git a/include/ExplicitEuler.hpp b/include/ExplicitEuler.hpp
new file mode 100644
index 000000000..326c3a2da
--- /dev/null
+++ b/include/ExplicitEuler.hpp
@@ -0,0 +1,16 @@
+#pragma once
+#include "timestepper.hpp"
+#include <memory>
+
+// This class implements the standard y_new = y + tau * f(y)
+class ExplicitEuler : public TimeStepper {
+public:
+    ExplicitEuler(std::shared_ptr<NonlinearFunction> rhs) 
+        : TimeStepper(rhs) {}
+
+    void doStep(double tau, VectorView<double> y) override {
+        Vector<> k1; 
+        m_rhs->evaluate(y, k1); // Evaluate f(y)
+        y += tau * k1;          // Update y
+    }
+};
\ No newline at end of file
diff --git a/include/ImplicitEuler.hpp b/include/ImplicitEuler.hpp
new file mode 100644
index 000000000..2619ba532
--- /dev/null
+++ b/include/ImplicitEuler.hpp
@@ -0,0 +1,19 @@
+#pragma once
+#include "timestepper.hpp"
+#include "function_algebra.hpp"
+#include "newton.hpp"
+class ImplicitEuler : public TimeStepper {
+    std::shared_ptr<NonlinearFunction> eq;
+    std::shared_ptr<Parameter> tau;
+    std::shared_ptr<ConstantFunction> yold;
+public:
+    ImplicitEuler(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs), tau(std::make_shared<Parameter>(0.0)) {
+        yold = std::make_shared<ConstantFunction>(rhs->dimX());
+        auto id = std::make_shared<IdentityFunction>(rhs->dimX());
+        eq = id - yold - tau * rhs;
+    }
+    void doStep(double tau, VectorView<double> y) override {
+        yold->set(y); tau->set(tau); NewtonSolver(eq, y);
+    }
+};
diff --git a/include/ImprovedEuler.hpp b/include/ImprovedEuler.hpp
new file mode 100644
index 000000000..50e3c2633
--- /dev/null
+++ b/include/ImprovedEuler.hpp
@@ -0,0 +1,14 @@
+#pragma once
+#include "timestepper.hpp"
+class ImprovedEuler : public TimeStepper {
+    Vector<> k1, k2, tmp;
+public:
+    ImprovedEuler(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs), k1(rhs->dimF()), k2(rhs->dimF()), tmp(rhs->dimF()) {}
+    void doStep(double tau, VectorView<double> y) override {
+        m_rhs->evaluate(y, k1);
+        tmp = y + tau * k1;
+        m_rhs->evaluate(tmp, k2);
+        y += tau * (0.5 * k1 + 0.5 * k2);
+    }
+};
diff --git a/include/mass_spring.hpp b/include/mass_spring.hpp
new file mode 100644
index 000000000..86607b05d
--- /dev/null
+++ b/include/mass_spring.hpp
@@ -0,0 +1,29 @@
+// include/mass_spring.hpp
+#pragma once
+#include "nonlinear_function.hpp"  // repo's interface
+
+class MassSpring : public NonlinearFunction
+{
+  double m_mass;
+  double m_stiffness;
+
+public:
+  MassSpring (double m, double k)
+    : m_mass(m), m_stiffness(k) {}
+
+  size_t dimX() const override { return 2; }
+  size_t dimF() const override { return 2; }
+
+  void evaluate (VectorView<double> x, VectorView<double> f) const override
+  {
+    f(0) = x(1);
+    f(1) = -m_stiffness/m_mass * x(0);
+  }
+
+  void evaluateDeriv (VectorView<double> x, MatrixView<double> df) const override
+  {
+    df = 0.0;
+    df(0,1) = 1;
+    df(1,0) = -m_stiffness/m_mass;
+  }
+};
diff --git a/include/plot_mass_spring.py b/include/plot_mass_spring.py
new file mode 100644
index 000000000..36b3a1518
--- /dev/null
+++ b/include/plot_mass_spring.py
@@ -0,0 +1,47 @@
+# python/plot_mass_spring.py
+import csv
+import matplotlib.pyplot as plt
+import numpy as np
+
+def read_csv(filename):
+    t, x, v = [], [], []
+    with open(filename) as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            t.append(float(row['t']))
+            x.append(float(row['x']))
+            v.append(float(row['v']))
+    return np.array(t), np.array(x), np.array(v)
+
+files = [
+    ("mass_explicit.csv", "Explicit Euler"),
+    ("mass_improved.csv", "Improved Euler"),
+    ("mass_crank.csv", "Crank-Nicolson (Picard)"),
+]
+
+plt.figure(figsize=(9,5))
+for fname, label in files:
+    t, x, v = read_csv(fname)
+    plt.plot(t, x, label=label)
+plt.xlabel("t")
+plt.ylabel("position x(t)")
+plt.legend()
+plt.title("Mass-Spring: position vs time")
+plt.grid(True)
+plt.tight_layout()
+plt.savefig("mass_position_compare.png")
+print("Wrote mass_position_compare.png")
+
+# phase plot
+plt.figure(figsize=(6,6))
+for fname, label in files:
+    t, x, v = read_csv(fname)
+    plt.plot(x, v, label=label)
+plt.xlabel("position x")
+plt.ylabel("velocity v")
+plt.legend()
+plt.title("Mass-Spring: phase plot")
+plt.grid(True)
+plt.tight_layout()
+plt.savefig("mass_phase_compare.png")
+print("Wrote mass_phase_compare.png")
diff --git a/include/timestepper.hpp b/include/timestepper.hpp
new file mode 100644
index 000000000..d67a282e3
--- /dev/null
+++ b/include/timestepper.hpp
@@ -0,0 +1,132 @@
+// include/timestepper.hpp
+#pragma once
+#include <memory>
+#include <vector>
+#include <iostream>
+#include <cmath>
+
+// forward declarations from repo's linear algebra
+// Replace these with the repo's real Vector / Matrix types.
+// Here I show pseudo-types to be adapted to the project's actual types.
+#include "nonlinear_function.hpp" // assume this exists in repo (NonlinearFunction)
+
+// The repo uses Vector<> and VectorView<> types; adapt includes if necessary.
+
+class TimeStepper
+{
+protected:
+  std::shared_ptr<NonlinearFunction> m_rhs;
+public:
+  TimeStepper(std::shared_ptr<NonlinearFunction> rhs) : m_rhs(rhs) {}
+  virtual ~TimeStepper() = default;
+  virtual void doStep(double tau, VectorView<double> y) = 0;
+};
+
+/// ExplicitEuler is likely already implemented in the repo; shown for reference
+class ExplicitEuler : public TimeStepper
+{
+  Vector<> m_vecf;
+public:
+  ExplicitEuler(std::shared_ptr<NonlinearFunction> rhs)
+    : TimeStepper(rhs), m_vecf(rhs->dimF()) {}
+
+  void doStep(double tau, VectorView<double> y) override
+  {
+    this->m_rhs->evaluate(y, m_vecf);
+    y += tau * m_vecf;
+  }
+};
+
+/// Improved Euler (Heun / explicit midpoint-like two-stage as defined in exercise)
+/// \tilde y = y_n + tau/2 * f(y_n)
+/// y_{n+1} = y_n + tau * f( \tilde y )
+class ImprovedEuler : public TimeStepper
+{
+  Vector<> m_vecf;     // f(y)
+  Vector<> m_vecft;    // f(tilde y)
+  Vector<> m_ytemp;    // temporary vector for tilde y
+public:
+  ImprovedEuler(std::shared_ptr<NonlinearFunction> rhs)
+    : TimeStepper(rhs),
+      m_vecf(rhs->dimF()),
+      m_vecft(rhs->dimF()),
+      m_ytemp(rhs->dimX()) {}
+
+  void doStep(double tau, VectorView<double> y) override
+  {
+    // evaluate f(y)
+    this->m_rhs->evaluate(y, m_vecf);
+
+    // tilde y = y + tau/2 * f(y)
+    m_ytemp = y;               // copy current y to temp
+    m_ytemp += (tau/2.0) * m_vecf;
+
+    // evaluate f(tilde y)
+    this->m_rhs->evaluate(m_ytemp, m_vecft);
+
+    // y_{n+1} = y_n + tau * f(tilde y)
+    y += tau * m_vecft;
+  }
+};
+
+/// CrankNicolson (semi-implicit): we implement a Picard (fixed-point) iteration:
+/// y^{k+1} = y_old + 0.5*tau*( f(y_old) + f(y^k) )
+/// start from predictor (Improved Euler or Explicit Euler)
+class CrankNicolson : public TimeStepper
+{
+  Vector<> m_fold;     // f(y_old)
+  Vector<> m_fk;       // f(y_k)
+  Vector<> m_yk;       // current iterate y^k
+  int m_max_iter;
+  double m_tol;
+public:
+  CrankNicolson(std::shared_ptr<NonlinearFunction> rhs,
+                int max_iter = 20, double tol = 1e-10)
+    : TimeStepper(rhs),
+      m_fold(rhs->dimF()),
+      m_fk(rhs->dimF()),
+      m_yk(rhs->dimX()),
+      m_max_iter(max_iter),
+      m_tol(tol) {}
+
+  void doStep(double tau, VectorView<double> y) override
+  {
+    // store old
+    Vector<> yold = y; // copy (Vector supports copy)
+
+    // evaluate f(yold)
+    this->m_rhs->evaluate(yold, m_fold);
+
+    // predictor: one ImprovedEuler step -> starting guess
+    // yk = yold + tau * f(yold)  (explicit Euler predictor)
+    m_yk = yold;
+    m_yk += tau * m_fold;
+
+    // Picard iteration (fixed-point)
+    for (int iter = 0; iter < m_max_iter; ++iter)
+    {
+      // evaluate f(y_k)
+      this->m_rhs->evaluate(m_yk, m_fk);
+
+      // compute new iterate
+      Vector<> ynew = yold;
+      ynew += 0.5 * tau * (m_fold + m_fk);
+
+      // check convergence (norm of difference)
+      double diffnorm = 0.0;
+      for (size_t i = 0; i < ynew.size(); ++i)
+      {
+        double d = ynew[i] - m_yk[i];
+        diffnorm += d*d;
+      }
+      diffnorm = std::sqrt(diffnorm);
+
+      m_yk = ynew;
+
+      if (diffnorm < m_tol) break;
+    }
+
+    // copy result back to y (view)
+    y = m_yk;
+  }
+};
diff --git a/nanoblas/.gitignore b/nanoblas/.gitignore
new file mode 100644
index 000000000..eded87256
--- /dev/null
+++ b/nanoblas/.gitignore
@@ -0,0 +1,9 @@
+build
+_build
+.vscode
+
+# from python package
+_skbuild
+ASCsoft.egg-info
+nanoblas/__pycache__
+nanoblas.egg-info
diff --git a/nanoblas/CMakeLists.txt b/nanoblas/CMakeLists.txt
new file mode 100644
index 000000000..b7471f4f8
--- /dev/null
+++ b/nanoblas/CMakeLists.txt
@@ -0,0 +1,67 @@
+cmake_minimum_required(VERSION 3.20)
+
+# Set default CMAKE_BUILD_TYPE to RelWithDebInfo if not specified
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING "Choose the type of build." FORCE)
+endif()
+
+project(nanoblas LANGUAGES CXX)
+
+option(NANOBLAS_BUILD_DEMOS "Build demonstration targets" ON)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# Dependency: pybind11 via Python
+find_package(Python 3.8 COMPONENTS Interpreter Development REQUIRED)
+execute_process(
+    COMMAND "${Python_EXECUTABLE}" -m pybind11 --cmakedir
+    OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE PYBIND11_DIR
+)
+list(APPEND CMAKE_PREFIX_PATH "${PYBIND11_DIR}")
+find_package(pybind11 CONFIG REQUIRED)
+
+# BLAS/LAPACK handling (Windows-specific OpenBLAS handling)
+if(WIN32)
+    set(OPENBLAS_URL "https://sourceforge.net/projects/openblas/files/v0.3.24/OpenBLAS-0.3.24-x64.zip/download")
+    set(OPENBLAS_ZIP "${CMAKE_BINARY_DIR}/openblas.zip")
+    set(OPENBLAS_MD5 "fc08fe8c0dc7364da115d0e09b5a134f")
+
+    file(DOWNLOAD ${OPENBLAS_URL} ${OPENBLAS_ZIP} EXPECTED_MD5 ${OPENBLAS_MD5})
+    file(ARCHIVE_EXTRACT INPUT ${OPENBLAS_ZIP} DESTINATION ${CMAKE_BINARY_DIR}/openblas)
+
+    set(BLAS_LIBRARIES "${CMAKE_BINARY_DIR}/openblas/lib/libopenblas.dll.a" CACHE PATH "BLAS" FORCE)
+    set(LAPACK_LIBRARIES "${CMAKE_BINARY_DIR}/openblas/lib/libopenblas.dll.a" CACHE PATH "LAPACK" FORCE)
+endif()
+
+find_package(LAPACK REQUIRED)
+
+# Create an interface library that carries the LAPACK dependency
+add_library(nanoblas INTERFACE)
+target_link_libraries(nanoblas INTERFACE ${LAPACK_LIBRARIES})
+target_include_directories(nanoblas INTERFACE ${LAPACK_INCLUDE_DIRS})
+
+
+
+pybind11_add_module(nanoblas_impl src/bind_bla.cpp)
+target_include_directories(nanoblas_impl PRIVATE src)
+target_link_libraries(nanoblas_impl PRIVATE LAPACK::LAPACK)
+target_compile_features(nanoblas_impl PRIVATE cxx_std_20)
+
+install(TARGETS nanoblas_impl DESTINATION nanoblas)
+install(FILES src/vector.hpp DESTINATION nanoblas/include)
+
+# Demos (conditional)
+if(NANOBLAS_BUILD_DEMOS)
+    add_subdirectory(demos)
+endif()
+
+# Windows: copy openblas DLL for demo_lapack after build
+if(WIN32 AND TARGET demo_lapack)
+    add_custom_command(TARGET demo_lapack POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+            "${CMAKE_BINARY_DIR}/openblas/bin/libopenblas.dll"
+            $<TARGET_FILE_DIR:demo_lapack>
+    )
+endif()
diff --git a/nanoblas/LICENSE b/nanoblas/LICENSE
new file mode 100644
index 000000000..09df6fca5
--- /dev/null
+++ b/nanoblas/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 TU Wien - Institute of Analysis and Scientific Computing
+
+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.
diff --git a/nanoblas/README.md b/nanoblas/README.md
new file mode 100644
index 000000000..1570d51ae
--- /dev/null
+++ b/nanoblas/README.md
@@ -0,0 +1,12 @@
+# nanoblas
+A simple basic linear algebra implementation using modern C++.
+
+
+Read the [Documentation](https://tuwien-asc.github.io/nanoblas/intro.html)
+
+
+telling the truth: ASC-bla is not really a complete library,
+but a starting point for writing your own library, for example as a student's project.
+Here are notes on the
+[development process](https://jschoeberl.github.io/IntroSC/intro.html)
+
diff --git a/nanoblas/demos/CMakeLists.txt b/nanoblas/demos/CMakeLists.txt
new file mode 100644
index 000000000..b7cf9a4da
--- /dev/null
+++ b/nanoblas/demos/CMakeLists.txt
@@ -0,0 +1,25 @@
+# Demos for nanoblas
+
+set(NANOBLAS_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../src")
+
+# Demo: demo_vector
+add_executable(demo_vector demo_vector.cpp)
+target_include_directories(demo_vector PRIVATE "${NANOBLAS_SRC_DIR}")
+target_compile_features(demo_vector PRIVATE cxx_std_20)
+
+# Demo: demo_matrix
+add_executable(demo_matrix demo_matrix.cpp)
+target_include_directories(demo_matrix PRIVATE "${NANOBLAS_SRC_DIR}")
+target_link_libraries(demo_matrix PRIVATE LAPACK::LAPACK)
+target_compile_features(demo_matrix PRIVATE cxx_std_20)
+
+# Demo: demo_lapack
+add_executable(demo_lapack demo_lapack.cpp)
+target_include_directories(demo_lapack PRIVATE "${NANOBLAS_SRC_DIR}")
+target_link_libraries(demo_lapack PRIVATE LAPACK::LAPACK)
+target_compile_features(demo_lapack PRIVATE cxx_std_20)
+
+# Install demo executables (optional)
+install(TARGETS demo_vector demo_matrix demo_lapack
+    RUNTIME DESTINATION nanoblas/demo
+)
\ No newline at end of file
diff --git a/nanoblas/demos/demo_lapack.cpp b/nanoblas/demos/demo_lapack.cpp
new file mode 100644
index 000000000..ba0917815
--- /dev/null
+++ b/nanoblas/demos/demo_lapack.cpp
@@ -0,0 +1,41 @@
+#include <iostream>
+
+#include <vector.hpp>
+#include <lapack_interface.hpp>
+
+
+using namespace nanoblas;
+using namespace std;
+
+
+int main()
+{
+  Vector<double> x(5);
+  Vector<double> y(5);
+
+  for (int i = 0; i < x.size(); i++)
+    {
+      x(i) = i;
+      y(i) = 2;
+    }
+
+  cout << "x = " << x << endl;
+  cout << "y = " << y << endl;
+  
+  AddVectorLapack (2, x, y);  
+  cout << "y+2*x = " << y << endl;
+
+  Matrix<double> A(5,5);
+  for (int i = 0; i < A.rows(); i++)
+    for (int j = 0; j < A.cols(); j++)
+      A(i,j) = i + j + 1; 
+
+  MultMatVecLapack<double> (1.0, A, x, 0.0, y);
+  cout << "A*x = " << y << endl;
+  cout << " =?=" << A * x << endl;
+
+
+    
+
+
+}
diff --git a/nanoblas/demos/demo_matrix.cpp b/nanoblas/demos/demo_matrix.cpp
new file mode 100644
index 000000000..ba4851883
--- /dev/null
+++ b/nanoblas/demos/demo_matrix.cpp
@@ -0,0 +1,45 @@
+#include <iostream>
+
+#include <matrix.hpp>
+#include <inverse.hpp>
+#include <lapack_interface.hpp>
+
+using namespace nanoblas;
+
+int main()
+{
+  Matrix<double> A(3, 3);
+  Matrix<double> B(3, 3);
+  Matrix<double> C(3, 3);
+
+  for (int i = 0; i < A.rows(); i++)
+    for (int j = 0; j < A.cols(); j++)
+      {
+        A(i, j) = i + j;
+        B(i, j) = i * j;
+      }
+
+  // C = A * B;
+  MultMatMatLapack(A, B, C);
+  
+  std::cout << "A = \n" << A << std::endl;
+  std::cout << "B = \n" << B << std::endl;
+  std::cout << "C = A * B = \n" << C << std::endl;
+
+
+  int n = 3;
+  Matrix<double> a(n,n);
+  for (int i = 0; i < n; i++)
+    a(i,i) = 2;
+  for (int i = 1; i < n; i++)
+    a(i-1,i) = a(i,i-1) = -1;
+
+  std::cout << "a = " << a << std::endl;
+
+  std::cout << "Inv(a) = " << LapackLU(a).inverse() << std::endl;
+
+  Matrix<double> inv = a;
+  calcInverse (inv);
+  std::cout << "calcInverse(a) = " << inv << std::endl; 
+  
+}
diff --git a/nanoblas/demos/demo_vector.cpp b/nanoblas/demos/demo_vector.cpp
new file mode 100644
index 000000000..2abee4422
--- /dev/null
+++ b/nanoblas/demos/demo_vector.cpp
@@ -0,0 +1,33 @@
+#include <iostream>
+
+#include <vector.hpp>
+
+namespace bla = nanoblas;
+
+
+int main()
+{
+  size_t n = 10;
+  bla::Vector<double> x(n), y(n+1);
+
+  for (size_t i = 0; i < x.size(); i++) 
+    {
+      x(i) = i;
+      y(i) = 10;
+    }
+
+  bla::Vector<double> z = x+y;
+  
+  std::cout << "x+y = " << z << std::endl;
+  
+  std::cout << "type of (x+3*y) is  " << typeid(x+3*y).name() << std::endl;
+
+  std::cout << "x+3*y = " << x+3*y << std::endl;
+
+  std::cout << "sizeof(x+3*y) = " << sizeof(x+3*y) << std::endl;
+  
+  x.range(2,9) = 3;
+  x.slice(1,5) = 10;
+  
+  std::cout << "x = " << x << std::endl;  
+}
diff --git a/nanoblas/docs/ASC_Logo_transparent_300ppi_RGB.png b/nanoblas/docs/ASC_Logo_transparent_300ppi_RGB.png
new file mode 100644
index 0000000000000000000000000000000000000000..bd838934c80e469cb958718c2b026138c3d39d60
GIT binary patch
literal 82368
zcmY&=2|Seh_y2=XlA4mGY)xHDilMSJqHf|=M2jff$aZB*GIpj#rih9nYo+Mg#u8<p
z5VGEKWy=ypnz2Pp*8h2C9{s-mdA;t9ndkXDpU*k(^FHr$KA&;R_=NsCfh__Ef~-6G
zm+mP95hz2DRdTEO;2nedeb?ZhHJAQ6=ZPRn+tL5He4gu&5kv+#s(a{+PXe>2<kSx5
zV%cvktq+BElNAZ|XKk#xwEZIg@Z=SLej_Zbu$=N#>2a34ip9DAHVZb)eEVu~(EMug
z1H9{v-LBoY3J4A<tks`0!|e{qhOS;-n9y>tIeK|@ufYkO&*RIBN4g6S>D*4&4yQJC
z2kA<9EB8iHQ*M~Sq&&U0;;f6)+>6u3rQAj@`o`Qx*8ne{Q%|Og11*bw`V5lA1hU{A
z+bdfc8<~c>d!GodWnY3gMO(dk{NlSRzTQmKqJi3RJe&tX=x#l=#fbkVoMFj%wMRCb
zD@jVxR(){kAXVdz*PEX^)YrlLJeMRHc&16o`Q9ClT<q&8M^E_$UVWNAYioJwz^I#S
z5jTQNB+OG^-}d5~*+~@S3}z7Wf#EG|QbzT9_tW;WFuYmAXs5nDL*eBNGJDc5@EJNS
z5u2xq@K*Ov0@qBQ<?i@T@|*z(+Q(?PlV^SgWrk%t;ymuggO@1cED4-wt`a@yoe-=7
zec2KiADmCN)#fS{2h}&jROl{?`|wI#Z9im*t2vhlcJ4Y(J7SVtQ_S?cpNKwxe>={j
zH~XRCWg*TLV$aS!unJ4J(yjK@mG~kH>!dgaMtJ@Dsrq}2ce{?!>a*eU@Vh_I`NGR3
z_R2^Bx&$TsfV?K^lF~L;-GqV+`=|tLcBc&Urq7@G>5<uxE!TMtt{@%H-hSbI_CxQ^
zL+B6yuBvCpU~=R7@aTmE33PVkugdJ{S?676UxFM=mObsaJKYb*7|Hg3cM{$twU2Ed
z$h6$8oWF93wVpLxGDpBGZ6Da7z6P$D9@~!>LD3?)iZcv(^e~w+E1y26g<rx6(BRF+
z)}y+ggiQh;{=URDI?AeKB-<3{5zU^<&C35wId{vtUO_+Fr~YIDU242kYPr(N1nElQ
z4yYIAaUSA0>8KR=oc{0P7REoc-)o>3hCgMSLf7I*^&zqdTq1U>1?SO~{ZM_y7No7(
zcKob+V`eoKp_QnSOKT44?(G?GgCF5V@VlOb4q>kwP~VJVar<mLxxm6Ml>I3}nH94`
z{jo^>d&M6HZ@qLA3NyaOFl9K`Oo&M5@o1d|kLZ57!G44bm;fHp!}*-B|9aeXm!*$0
z{(>^wqXun(y3t_7s1*xY*%G2SQ0Y7Tc{AKac2fSh$y#(}4gLH0R7MI){+&5aM!^;P
zNatn7S9>xBMW0*KM`>)+-yIU&WX%aEv9SL>WUwdm>~sJpJV?SHj&ZIdh}}j#1usFX
zV<RT)NAl@UqE7~t9%7VDr?dTW{W*(63Ut!X^L{2iFb?I-@8Ry=E_9vu)i(*0zy*(g
zO+=qN?jen{hp@Ke=gfk_UuNJpDnK)o9!HtO=T#Z?@8Z5;&WEH8WNnUZU*Do$Pb}XK
zSCG2hY!6KSJWk#KzrgF8?FZ*g?6nc}^l=^!Bq12l7oKc^B2)FFXdV1U@z_5SRKd^w
zgmQ+cSSA7-K{YBV4u-cLt0x!tO>rJ6WB9&sbY}czdgS(jaq|jW_*kal|91w(x6AMU
zW|h^e0@vIf_0*Mk^*=6eYzdY8G;A+ligJUnWcA!^5c}cCx1O_XS~yZ&>)I;^?-Ass
zfdf|HL<$0%z4Bz+%utu<`c(+#MR`&jNgX5?lr{))R!0wT@%+HRMwei|o%7%fj(lr6
zi^g@be)W5`G1Q=9AyH4$Tk;NbJ|{>6-H(@CN9jJ;<qwo;39_>|k5B(Y4YB2}27YCq
zDg)752J=OwL^=09mK)z$My?f0a#27BCTPnYF;V_Ka3Boq?q8J-*`vhF$O|>*5JMX;
z)ZO;ux2sYa2coQ$|73&7Oh@}t66Pz4lYi^8_NQ!<cSrKTt>GQZAJHjo<2*Vx_0<W#
zvW|-=)JOtK`RFC^B3ROtz>$`E)$e9f&^NYwe>mWV{s1rY*@s7IG2N*75Q7?DNT}>r
z>WIm6c$6s4BPSlEeEO<{E0NNi&**2%$R8NLl>S72jk=s9$$6VH;_ETe7L5{8e~6HQ
zKNc(9R(nQ%2AHB#q`cE?z&M@$vh)SY7EZB0*wp;#<jJ<*ahN*zJj%+DozScpT13w9
zNbAX$uJengXa;2Y>!6;b-1;>P-hRiPJj{_*X7?dO0S!pHxvvGfBDf}tHHI2(cKd+N
zTo`H*gMWiBnl>n}7)|Vzw4tBnG!8{f?8_r72B;a=e{QP30eyG;>m+9_NbhJTN~HF>
z64RpSTd^;$gFEsM!;kPHxb?+P7k^Vk37z1ZTE@ZPgi@bkS<=iy_W1iF_pmQTCX|dG
za)`>R0!<l|HQkEo=U0eB-QVp)Mwl_YPcQT>#TKGIZ^;QKR_tB&!_}T+<loEu=P1p-
zk8R>}9sfIyZ~FB2flV+@j-r$|=gIws(N-`bMf*V~XJAAu%^eK}Y5i)eQz-M3=7frC
zF<<waNE!L<`-&1;M}g{!D+Z@tPoH<Vfez^KHq{*c7eTB>Jw|@+_ye69K~4%K40!do
z1)(HjDLaJz=1@I|(NXEgp=a%?98(ePe;eICf7&mBW2&u@m{})w%Cb!<&Ym}n;`3lV
z4hQqqtG04Or3*<<=yrN<%L)p7v<&?AS)$YU7GJv^{(+Z|3fopP#~-bLb<)@my(G^^
zi{mDWsK0!fl*3K*Y6mBs-z$ad4jeN?E!Ft`=<j(B9zNL?%0>{ycV~LnOUw~gUk>X^
zIIuIG14HBY7>}n>jN9#RTmip^JbOitgnoypkTm{+4iS?A=o|uCLa7?f>@_u>{XJ_B
z)?I7?=ru?XJdf#!WmxnL%J{DhIDO8<I`_Z({k(uW>__w>MCU1cLhPRrdcOjORP=X(
zkB&Wu{^6IPOf=X!f`{JPug8rQcaOi!uy3uJ=STFu6B)5pV}-}9@dHDTVtNWPzV<})
z>6kzJJ?;VDGpvpPzl!<!>s3^ZZ_1tX!X}HXbIF6<*O-QxYvpi#B1Xc72x$j+&Vr_8
zRT90`2vpWdqukz6UPf$*ez3b*Qn?ev=^^*qX4zd#6gTt$P;d9x`LQ?S#rG;RQ4{sG
zGWN5>HsLSmao^NFhIBNYa%o-s$Cw)-zRXn_CInTaYDQ4YqDg~4{yRUET@nZ*4yQK#
z5IBai#KE1<O({K!>BWuB1P`V22wl*{K#dqMkos>|a;WONrlI7~i=8_hxG8VCJ04FN
zy9KhQb||;GSb7JaZz+9a)XA0F|0Q|JbMNxva$N)$eRaZe!*aOJV&C!}V$Ipb(Te4E
z`Q?!cyIRuPB#k^ShpM=s^YzP<${vff<%g0y2wzIc<H=V{iA}R<to>!Sgxl#$8wVd%
z{)izLXf=T6aTSJ|#Bleu+4VA2lb6o?P?wGxQyH5#qcung>@d{*1Xi~Uo<w9?HpO3o
z^1(bZDR8@Lg4Wy~e0h;Wu%vZEj(1PffAbL^P_c&4UnV;6$6l2s(rqozIqnK+r~VxN
z2R<t6iY1?|X}?VUv+nii+hVOB#xlQbtKE6;Gg#*(iq^cvA$r-wPDjuD<_@W~{l4p+
zA4SHud@^hO<n>C{;q@E+5w_SNb%}Ix$&Lj*)^7n`u^K@O6>@>Zr)mo%^-1@JAFNbi
zRpog54k{HCu4h1^VD}CDE`;Z$N?AcTjS+jj(csx!FJE#AtGMtHvse!s^l5PzKJ~%q
z*(k|=aodCm|1FF#RiMtEEib~|8@35#YkhrO5*SW<elHa7vWb!RS5)*miukEZUnQmL
zbCRW!RNB@-nSw4JY28;dFxX*X&+n62a*+I^%2Xn$m8t=pL1(!bc<e5Tzp#2d_uP%1
zgoGJm5vNpR5iXKgv6q3kb-U_E6_?goHP)wUKg(9T5PwAu>rzHe`Sp~6H8<5W5%()+
z&iu3ixn|GLMe0zi-?m=;v_)q@=sPDJeO*xSTP?ZNqDfpnAy3mASj9J0?j#BJ3EPyc
z(_Zf!ABtyMo_!s|p(7+VI})`c`LQThjRjfz4mAvrFL)f-X43Ut+p4{Jl3wb6m?7ni
zlkdF3)A9)GVFW76b&Ja;>vlD7g@2Nsa6*u9=!i*V5lchFkW6um?&Rt{G_sjOWo5}+
z-oi+B*6$0nubX|n%3l&^nyYl{lN}$=W9uH>xzK&#_Z4luHsF$ryZevjtk~|^bg{o_
zCzljMDf^D^T+dM`B~nwk8jaxJ$pRQLV$S~4iQ;aDqhHc3ck{mrTGbz@Ci_7r(>Bv4
z_G#L&ob_7+{H*&poQD{kek4g680&7!dnYt`LzPGuNzkiCQ$LxecuPxIS3C9Q)t+Bj
zJ5HVP(ygY!>?}IJ@eoePemE>q?N_<jvXv1p`;ie}Vp-vddE(Y1`pXuTzoB$UX%x!g
zg;{SZJbA_P#{Jb()43&!Fc6IwhxDe#|7Bg{x6T%SV4=5aZm8vmNned$pl2tPI3+%g
zD{IZK6C&^&J`hJ1IQ;`Wi@2DY3Txh><{MuLF^uQE$1rnWP~j3GA!;9$(^T&C6+BVa
z?-?C_nyynjr}8pOg!BMSt_YHv)(GQ(@oS-H(A1pshd-!IsCA6P-Xf*OC)>h|g|Ei!
zA8}j1iA4L8OXRVs?1!q4lDgF`xnH?6v4FjCMf7ir*v_o(t5Q1V4*VTYTgArqS|a5s
z5L;$OSG=Z`OM9wTb%Z@lm#*Jtco9#z^<B1D>Cg9@$)g@zGpZk*6H3~9@2y0?fqmET
z-F=;0Nh;4H7o(SUBT=tB7RJxXhtbtWk5s2oS<}6jS0mQ0nU)66LM8ZdleJWq?a8+G
zT&uxSpUTBhNj_9OA&-OWua&63Uh}NyM&EU&g!#*MLxEK!I;>I&stEiTejvu!C&bcE
zK6C-*nfl`Uk;_t)_X_EAFU?C9^fTL)1Za21cYL&t^gd!@O^);kj5*4Q&`s|RcWS<C
zR`HnSIdGnQ+kW^+rW_wPfneF`hWjXa_v;S)iQDPrRB9MuadZE<o}2YYyt|LD;|XXP
zx-rk7zW&>^K~6nMk(0^{YK6lh54YO!`{)7K_@yG=@sW_?rhSgNO5p}h#TwzARsjdL
zu-eUH4#)kci}3uLWiHaww8Kv<Idq+N^7a8Od^WTw8miXn*ga><0}=zUuxH}Sjayvu
z`8-VeA@zIw6kX6D<XWWfZLvk#gh17_3V!MAnF7PZbeGL0mSo1mWhzw%D&_E=L%Ita
zaj@QG?+|hn2OqN4&)R#O+10L>c<X_ux#84!h;&bsM>5lP2G$#Lm!67}L>?P$J#E=i
zIV2IA9y&7Pc*G<I1L`JY5YGm$SQ^5w*j<EyHK&z`%J>01aTPt`O1wg|ZQwI`g6il+
zr>YHvwLR}-9CMcvI|jEA*8Afok6`?|1zpv@n3+N&z=;xncZ!itMO)fz%m!`3JP$}U
zbHDr2;p(qnXz{ZWC4{d|$%mnc?9UzhHj=`WAd<I$-enrh=6_KY)+Y(XLFAOc41+S$
zilP4^qrUF$i(6ET<HU-_{?ZW*Bs0pPp~T!^1QwlsEC{JMi&39FjGI(YUz2mhkc?1V
zyUb__HFIX3q~5sISg<P)zIx5V@GY@bwM&4{`O%BN{vfWV3tx%)(7b(M_=`OK;kqkP
zBJ>P!LXBT~Mw2EzHRJc)v4<yBx=lEo=m%Vw@`}qR6e>U4z`Z#~od^foK@|69D3&DY
zS08oTNTRq&tLb8(3ODoqukR!|LL6lpv`NvJ_VUcl4~q17FW&nNRE;`AZl*D~tUoK-
z@~Y_HQb{YzeFY>Z_z8mFl1!CrbgCRrSjs}oTU{fH1bH{cUY8{zbmz@zFRrt#MxtLo
zE>uo?2U~|C{fp6D-n4f@6XBYH%-P%NNv##4{XO8ONNO-NNE+XwR*Kn~?gyPXO8}Vw
zjlLEd8f{gr9LbD?p8*TuCRK>Ff)<M`lexA)W@Mh{G;=Q>D;E)q8}sRJFqXNhS>(zo
zh=Qv3^ZKMPnkq1^4mXAH;alNq%@YT911JQ~z1lW_$7|a=a{0B}@guCHY^I--?7uwj
zQ%$np)}K>AX#zSFnj+HkA34~Pd2<MwfFMh6zIgGymHK*Zh-qvFy6)4r)0M)~-S7kM
z(6=hJ%>N~d#YfHY5wF?opoN_Z0MVl&IFE;t+$8zpk?a^)ji$ie4A8bY|DYPsh+MFZ
z--k92g<xj@xC4DSeYKZ9&zSu%NAC2zYz3w|dgAcNW*K~t`C5ybfM8j~8R7<zv+7{A
z`_{`Ca<1%+OrG4fjU&Uy9qSomJ($}dg>IC*vgtbFkoDqwn3?pZ%n5<LfE7HR?Tr#+
zAKpTScN*almVQqhqm_Vhd}==F%%tHw?n!dX99AElSH(x%PeH0YrUp&9Iue1ngY@&o
z`8z^}Cih^~jb3W}m5~b{#unY~>lTi^sEcAsyc2<>-iRg*v*6|K;}P6~#{p)sX=Ay!
z8YYN4bBM{w`$LXmAssNJJ(4d9y4B9n=TGn+f<|?~_ow`HVXv)H5R0eDBBV=6yRIS3
zQ?JxC!>BqAj$E=d-|vs4{WujAeSUWyPa~ZMsp82*=~)MU<lABOLs@G=O#7VxZzL-i
z@D3GS@!aGW1%nl&{iS~Lt32QgtdexnfnSW;Y9^hshH%dEpD(KT8FbZc0G6RA-BeF;
zoLtdS$|I*Fzf_F;2QPeZ)JaO%aqpj!I-k3Vwldme-b<9DJJaWO;g@LesB(w`#K8Jw
z8}LIU`e?82?1$D#epgopcnTUN8M-J+#Oh4}%nJK1MS`Z~lVuK0`P^SPpCy5-lx!D?
zF-<WCZw?iSu3)^O7D$lrT7i}baY~N{TO0gk>f_4pQWAvJJGm%M-#_kv=XzciCiNx-
z2Asf54YiBfNWL_xu;jIZ8`^mY;*b$)=bmOCy+}U}sg^RL(z99YHo3qh$-gsn=>iH(
zWa7lJpaYPt-WWn3Fz7?lvM5QQxYBu3{U3A&*p4zHpYB)j;(G>_Wo{OQ{K~GF{S%|U
zNgzs&Ur_tLfNGrX&+g%SxGJl!A*jx>JE7dMH{FUEmKv6;#3IJs{#yQrhStc?t+iC=
zZGQQHoph>nThkKts?U*EQ(k=&pjFrnBYOXUfy2ST&?T0_>B#AG`DFg;U2Dj$k`b}c
zBV@`W*4U0)g0RG!l~bNV#eZthUqIh({6BDOO;-GvAG8<g6APD~mSI7t0YT%??}^Id
zP&O9(p+-QgpfTHV4T7Iw#csg$RSq2^#l}gORT>>&cNCC*$>O8Q`kk5%q)Vr*h-sZ%
zeA!SrPn-h5aO2iRI&tyuIdS^w;#!gH%E7htoW+SrO_Vh#oh3`{!3_~$;_b&G7co6Z
zxTN3n)|_%k5!8vW)z#UOW>}_?y3>*@{Px*7Xj%XRuwe2B=k;A}moK3WWTovFl!>*g
zL75%_8x4bm7r`axc_LAeERh-zHj8G<*>;lL;cw6e)ckwJmAEJM@TNn^?wN3AqoSe_
z4_@*tes?jrxtYsA58_q~(oLl8;sG#&SlG}XG^}POxctwYH|kp+k{}ruS2C14H7O&2
z7Fi+>A)sf=vs=`ZPdgCWkEf?&gSxypJ>}l#pfxus`x%!Rq0U(wP4n1-ivhNk0{0Lv
zCBicc-S+e!i5(LNKRtEdR29Q-hXGVDEtq<+CsXcC7H|vdc_-vlD(1MNk^Z{)PLv^x
zF?a<HHme`EvGmVl0@_2DiSp|kL*G$wv)+)cdfRFl6NnqsN+=|50z0eX-71~7(S7zQ
z2Ohyd{COvUSQjnmWMj&$ps^AADm$R>hM^+e?Gt)e+KcZ~DD;Do!I=TW5uH(0v`qs|
zxTn({*U^gdS-ab@$7>(byth;(ep+jg0F$*<*8U+H8|pUdfden)Bc-OWZ>Ah*i9M3*
z`>{xVfKz`v$OdDdpsma92UEi?JtO20(N$^ypN0RtspGt!Bw+QE^(oZyIs1wImeI3w
z?}5W_MlN?VK}|qoXDE$$wj+8UDFze>op2@I&K=scu@OW2Xqg!C8-N>M*9%RUdFwt8
zi*X-z=Kp4LvMmkdG*g291to<5=m+Bm#&NkZ61=4Nxc1UKEMDkWYK3<m80$qL)xfEZ
z>Yz7MHX@s4=`f7Qju%?)u7C#kWv{5O!S9;6a_rHFpNdmo5gJKAU<QJ2_0IZEQ-MOo
z8@JF;ctsT{S3TQDnzb@n#gz)iZ6KVJicK}u(VlHpf<0DvO(^{j^0?BTNN_WIkHj_#
zO{V}OeEFu<x!0zN%fNK1OPzoL=V0;L^V0dAjfYCk3%Px8R(~=rL#$mTAHhQeV4#dU
zj5we-PaA=8ZVeT<a~fa>VHcq65o;fjz6Y}UCJ$8Xl2?=Biq{E<0?s>G?Ed;TN{|=h
z4w_$5M-3Sgm=kSOp5(Eqmc??9Ts}@RWryf0!d7tMV{6OL1#1}VNOQec1fno&=E#5l
zIcT^(ef*U7m9Iz15o;z3R=HS00<js`@-Gee=ig-LZ-eY;)Sr5&ehT9`Dpcr~Y%<m#
zK7cQTs8W%$yeCFdEKY6>ZfxdiJOT0hP2bdK@eeH}<o~-*C`w^o1<N6;e#LPYK2>~g
z4Nh|y4tgA4K-t|5Vbu86wd8z|Z^PD|oGL{y^qQ3pDrF}o`?QzS=!FUTu=lo_L`K0i
zrclbg=jV{&$V$wCnzoT|oqh@xw)#k0ZLp&@Wab(g)Phu&CXt_T9L4f0z%qy{Qc~Qj
z@+X)f2(f>4Mlv{$x%V`Ev5$M)3yr%hut5$HNL8;oIo}hp1C|-ea?ikUEEon^ab-m}
z0EX@$d13z*_3a1<cX!y*D0#oxN(bKf>j%TX*Ng)WnRAdro*1{rKx<?VOfi=5+_c{i
z4KZpyM1Tt#0X^VbpT7NA>qsW~l$DP5dXMvGPqt|<l@yqQv<53gE5R-waTUQFUDv#@
z6&L<b41UwmQuAnBqO~0#q!fyWLi%)T7nG5lvjD|{r(a*SxZa(~TN+uZcu-gOQ-$~G
zVvaQqYCn$)Lfb&>n}r*$wiiQdw9y<0qf?wRssP)#0yG3??z58RW$vYn`h#-ufnF$d
zGV7aFc=&;3q3K%lMDaPRSJ18)GK!1Qt3uWvM1K0gz2jv(7-TJu(H393v6Xd_F<9ar
zWNZRN|9GeZ?O-`-eMxv$MQiD-5GMXEKY)xm(4(I=O8wv&j4th@Mi{k>xq;3^?KXSb
zhnJOzGWKjQ@gxVae|?aA6$FY&76lS25b9tj1zOXT&)-u^lfXHg<T0TQr6YiSqT{UE
zbF85Ga?XxF_7*x^l;l9}82*LRwMEr)qAaP?R#&&ZhE<gsy?W#IBJB=hcd^hz4g;bu
zS~Id~k=tPzex?&1{SXlR3nIg(BzvOk#+|*0k<<TOzNXmrBa|GC)y8s6R1bW!HFe?f
zX^b`{$@6*t$u*(cGrlFp#*k|wnn5mD$h$+tBC*b<-Z2=~6zL^;_(75<tBa@Hre2Xi
z05tUfEdHsxDX4|V=R|(i@9UrVv`1zc-s@16Ue;O~zglbH%X@Qx{MgyFzg7uyZNGn<
zYY)~8IoMLXh9CzSVPGeRiuRx?_huDLiiE}<W3x#h?36=L2zCSlGP;ZRU@l#Hw6`-E
zMRtJDmrlj>u4SEx{=MjvP`WEU0TP|cicaJq^~bsPKEe=(8fnjD5j$kqb)&qQ{b@g5
zsRT!UqyyCxR@vPKv#=pe!Tnw6>!{;8)y(E)A6!UD5GcZ=&x6S=wTO>=x`f>@CCS2F
zEAalqYvWkWMu{0w+hYYxBX-Ln-aC~Oz5k|UlWgl9b+S1<v4fDk0=24-(ht&_^LXg%
zwS-N^i_LYb4Ru{aw!4#0M(;}Z)4@kbADGv`&y=L8TbE1Y^t+o0hd=&7*w`~$moZUt
zfZ635P%`GroGkwK#>RVIDs5ugks+so?Hx>K09kHF+g-(BDXAIjs_??Sq(X>#!M;fG
zo6t$VSayr53{}aOx91qQUq*UrEzOT#u{MXUra~ceX?ovmAnMq+*_AJSe6r?Q#cu|m
zWX{<S`ra$!+nHYciN&x9*xl@=owaM;uc>g{n8O5*ts_jvYkwY$428OMBEHqwFGO?d
zr_oJ@ne}wVEozCv2?=-8h7#8P2Q%;fnYVoM<%zI=N00D@2Ua%1&`Vm~m*211K3P!b
zH+zZkk^lN^+=tPcGXYxzgEBj3Br%enhGQ^;gmtOPMh|!K9USr15Q0@nG`v+OF(5u;
zOXtn3``z(RA6<C!GfPe2kG{-ywbbf|Dix|sN9T=V<>(gbq$gQOjM8-Ur(yVuj^f>s
zsRPSnDlhJwV%h{)_Az18L;4qA>i;}Z|8uSm*0yEUIO(ECDCXKWpOrXTuk@*=c>2=w
zFLQodPhW^{8us2=tLA=sSEU+|!#JZ{^jFVS&EklkUp~fDU+32NKGJ{Q;eMshNNBM8
zXVV$=cYR||H)LT5k$&DD6d*NlL@X+Z-wCH=Q6&LYA3>p_ru``+hDkX6UlybMT(_&R
zO~Y7Au8|?Ms*o0jteRDb;U0s&VY6j};x$p<y&Y^_r@C)++<BK1|0<W}jwipY!FcK0
zA#V$YuvDfL^f%b)exVs9CQsr`+)(Dcuhv_Id(#Xx^gPU|_xoz~&V5lGh=2N5XHU(H
z7aV$k2DhpU$u3UnShiv2@oeu$HbXA9sxDI#rTUEcP@USd<?dvUG>nlJ*|gUdY5hmY
z(Tb`wdZw{l4sT{J^nTa==p4TGbj!`*M^FC}AC!O7t0?~F5`=;j8ryUcI0BO#V;Zz1
z*u94lU&SgeSFmM;EI5dIr(-r+|3~~18h|Qa^4=ySLT{n*9mx5VDNTH{t)-w!o0o1^
zTiz}A<M=dagR4H<B!-elYw?c-ba>(c1J5$pXnx|haVVtt=@0vWL~^iL)$TV|;};h(
zwU}eu<6$RTHErv-{zZkpX&xz78xCCPRJUv;l>p2lY&Q3Z6+&~<#k8S;DdVDVI$d;|
zl?omAUyNzlUyD3O--04dH`rxr*UnANez-B`G=E~vj7@%vm0tFV{0!n*PKxL#16>#{
z`17gVBT34*>geVnn|qR!lW<ro%<Y)`rk}cpzU(c3cz7=9?#JncB}z=u?N51Pr4OGf
z8fAGz*p}63-dR#d)JlqNF%s<A^EIChP?m&Pp=z|1jZlE{kiWKmb<w-*sp-E3m>!wO
zf28Hkb2G~>Y!rlD0yrRcKat0(U;Cp@h0=o7XN8{Ow}!e2-kUO|1#(J~t^`*!7}{aZ
zEJ?F#jchqwTGuMMyM4BrU{%{LZ(w11VX7>4ctPQ#{XON*Lv`(0axM6Q%usHZ{Oj|p
zdY{Y}FGGy6u3B#&sCSUGN-<|x)r`yaB-hNynX8+ZSGZ%fJ`<WK_8J>=mDx4>8KFKa
zkmfzn>ZCZ}Xu%I&y1R;PNuRy_<mqbW#nPm;#R}9QInoPleN(fSWSgy0hQ&H}evTV-
zpC8_9{yNeTBR}TDO55O@eja&^LiDhNnoByNlv#5-ev<Ln_JLA31(tW6AQdT)(;XMC
z_WHB{X{fo%&gbUv{*Oo6!KnuAdR#M^-Si6TY?fzS)++y%7M7br*-RSR`hyK2A5=Qz
zZ0-545PGeGHE@hA?rx30mhj=?apkmJrK<9|c>^?08S<5ym^v(j9CTqh>snliS9+}8
zGxzKkYt(<xS$!^`_vdgHrV1mVrWH%Ap8i_QE-HL7<0IZ^NWh!SYj}hE>*Tdq$4ky9
z*@u$$7ylf#*R>!!FXx*X>G>a3_~PgIhGIG*z>MkCl=;~DP1)9xT-I=hyU&1f2k0($
zspq?Xd`WyyDwfGR{=mZMvnR<yBv&Z|X+7n@FVhpKo1iHYYx%wYsAI0Sh!2k8_4b{2
z@3T%{`TplhgQNOBRcfE~tB=6pyzAZnuEpVc&d=GTv{XHtPg9#$FKNd1uycs0P`wPT
zXmL13U<IWx!o0C=^%Pke_xxz@v{Q=kWeLWgb!l=|StENkO}rfYHYRPj`-bI7vi+6f
zJKAu-B{%n@<{er*f1ITwD~G{3B|*^dnWUmEh=CyLk%w+SLRzkRXnxmrqw8J~wJ~&y
zr*#|q{BaUG8_;dV<CjkBE-2u&-Agmy9p%;f_HilZol0!lyxFpa21KrBh-uA5+bmBp
zTribdL4MwmxKe<t8$4h{D$rb7oigPfBCVhiWtt9uHo0}<O3(0TU)=;z^zhZ-e+TK;
z8*(&nE-fk;knJxNw+uIYbJ~9O14HD~g3hwk*JV}=Qw#~G_f#y?nCMBiY5kFcmH13M
zB41V+4Z`cMClmD~*fF*z^T|9#o3I-1n%`tD?87(D$6i}=I&Hd`cXoMvS+sq5&b<>o
zs)bN&e#J_X^lt7S@q*(J?w6rjD}O3%0K%El8z>ZF%HD`t{N}V}n{KricnQvH#zGgL
zed}(9Y|X!s-CQx}-73F4&fULG^o`9lFq)9QNJ|qqUdYE4grmjHecUD9(l|%ifU225
z?1%#45Xffn@6qj4DoAAaA!o7F&v2BYOc9!UvT#D8s?GJ3m+IP*nHZ|Z8K00ItoZHF
z4k=m^ES!cDi`ScK)(0{pw0LW>8ifwhmL5+C&}XkWFN85A47yx(7oa1R^hj%c$<%4i
zc@Bz#NAzXdn7*;wuYCr%Eg7nO7U_IeutD>Sm2vbUQc8!i$1ap~pA*gx(x32SEhCq9
zJP>R6le-;u{QXS^E;lEM^+E@gfeE3rhTP2Remn=XBs;PnAF<i$iO$MhXj5GeQibxR
z&A8xZp*Qj1A}ZQnaD1%3ww9k~f?MF0OZ-Uo-RftUHDUXV09a}5mn%d2(V24ps%XQ8
zqGEZakEA32W6@yf-?ME4H5wj&BF~ec@CtWwXX&3pm_J5O-et6mQd5hejPS_^GMR8V
zMr%b)4{ai`LO31;;<u1t1hoLv;Be%Vl#P`ng(#S=C;uq6F*x_@A<apQR>ee^pMFu*
z=*Zn+E&NR0VZxeO+++ou>hmRUh$XHd;9F{~hElGM?auq4PJHs=pp;?Q4UZpte7m%X
zC&Vby=$i0B&CPFiSm;;7-nrU4P0ETdMK*1l_tZ(XT~(rRrM*+rCm)Vw^?MaxTiZ&8
z(`J;DuYqZIEc|1+`}n3I8;zBj9)_9P#{HNhg+Dr{2pbhNa;zjJu^1#^1G<TB4%{ER
z&^!;MvJ9KP!<~mH?iho+=wmK%2R+{36k%}Z#(RZ)o}AO7(6AH>X<#DZ030}J>cpcc
zco$<(A}EP1IDa4syDOrJ=#gf;w&O71;POq6&K4p12}>v{NF9LsFe>angn#tPTuTGf
zQqtH@)vd+?mi`*8`o3_QJ3c8W=t0I0UQU3?7eV=0f==F)-Iz^Ey#9X9x#axA?LnWo
z9AHZyN?uq!#rrgs(ef>|)D4=R6Ap4cZ#_v80c9uJ(Sucd<GT{7E4vq7aSr1K8E~|7
zza$!twX!o#jnCUv9QBJNYre=65#peu0@4C~cf!Z#raoEd@mT19_S<7N?$yU->u~za
z16jp`IQM+d35W8JHmeNmlU|zZuj85E8HO^A<|&O^1|Y@2YGa_*K{>%k`pD}g1DoP*
z;iYw+KUDyN_}Wgcjz_Rwh-pLL#puNACyOGfmmA}qZC23N`=aE<(CV+K3M)J~;#GY+
z{p@A_I@s7nNdGqH^AL6l&<GbW<=~!%wA0>;>Xod$I18BBV?9L(00WTq6nH6ekABoE
zDwI~D{WNqkrIx6}-Portsk_AkeZ6a7h4*2#mSjGJ4?T34;;|JM3d6gt43BPS>IO76
zt872L^EMmPWzZ~w+T458k)I@o?w1k_QcHgbyvj|Q*#BT%0l|Fb*3(e^KT>#Ll{W4E
zXnU)bO-BS=jFjyMl*j`dp@*2tb|##ca~1BJ^VE5s!e0{R@`}BTd1Mh)-vlif`_EZ)
z>_@emNn<M>(VNWDIh_#Rg#s696Sboo5#&cA%xFT`%H|q&l@+@gI|Fq%6zU}YRI@LM
zo1S}%DLub}#B!as^5udJIe9E{+fVy2+P?@qg=(#Oj$2~zi$5Y5W2k@-)(>}biIwhw
zOJ)D((iXI-^-d@ksz0Qc`67N7czYV^d#nESz$T9*xjWWjSDV7o9}T<^Orq`!U^Vtf
zg{x3>9~UB1dyb6ojVgn&T``N%*cOAzK?o(R7$7V-e`kosKyF?08`5Hd<?aVhZ3cqs
zg%D5gA4bcXOTjZ^X6g|Ojk8Oq`T0Ew*H!95@LQelo_Klhkdj*7rU#$<4I>U|cAgo1
zCg8qTwV79NSYTJE$-7J0^#3-$7A|}8?o#6GHCv(dIDSD?Eh5T~r=YfQSJPirV}9w3
z<zGm1#n9cJXLIdF?dvNZB)&P2sk2ODF_-7P04{K9F42U1@X%OIws_ulvOP1-t8Jzo
zG;dF3`{lC*i=R98z3SXXKOT=0L~>k=whzb<ubnFvGNn9Otw+0?8N|xcSbkq&=Xhy-
z6)o7EU3-LdggXfer|q%hHz2L<J3Y_zfHF`YvDRo3A~`O+;_Yt<-{PBCLiJ%9-ZH+q
ze2;S|Fh^g?kzaU7l}O?~Oh#r0RJcf6vRT|4OuA{64@|9SQY8+Fl3WH=-`GdC`bWiI
z8#>nsbrj?}9}}BVItLpC#?(RBxp(-iMWmdY8|m0*+KHoI3FjPH=<PiRi_BhI{NV?D
zOdEZC(cjjG(gP_EkuhzX@$%8`9}iR`H{~-|lg{gL4t2P{$#K1Wm`uNMlZlMIwdJ9&
zQnQsq>VNJfQaX!-`b3R)q;OK)E87mWtOh1!&4cM>uUlGbh`}HveTsxhw{)nH)o1sf
zBh?p~aox-fB)^rRYja%pd)u}PcH&NpmpDk`)H@{uT=`A9lO6OC;m6RvlDXrYRQf%D
z8JEFaEfe~lvombkA=o99M-))C<KJ;<)T<&3LQB9HS}}JW9!SzNwWLdi&XHH$t;KAV
z0iO$;9zd?t3H4i9T;uB~OKGY#=P|yUK5F{e@WsMgOP2Z;`J|P>GxB)^P^Y;v<2Htt
zAHV#vX!Sa}n{O1?LEp2TT#fbYHLRA2!LE<#un;D`8<Vg5*|Cqor0!78<9QvkpNLSs
z$OzFCCPheW>KlyABgWoI_OFuPV8ba)Crm7a<3HY&yjvIMJ@5KJ5_zu3GTiisX1CyD
zM82w(i8u_(;+ylgQ+x>=?qyxpqqXkzWog>+Us9I4X@*3Z!6{F|BNH-`pSz`GNR7xH
z%a3_N{YBRjAs~7nngi#&a7)k4%Cz>JitsO7WOsNNeaytQ;x?o-A&1Yt@0QOZ3kOzi
z-9tjB1?Q&#eWzgh!u@~mxxr29TsUw-x7yODYVCx;%B55I?w3mWJP!1BQbnSxk}gk<
zInWEjJkd5&3%mV2Z+2-(awaCaatmhMM*3YzdYO2`;cNyIk^S7INYDF~7)Paw+P0%H
zGG&VyX^Tm>P6SLd;+jRIWqxx+U11Sv3SV;F|DSxG$Cs3@J{Ww&=t9C!ES{SPL`olG
zPGPila)pTJ@i^GAeg2#~7QW|_;HZz}SOU28s!x*nM}oA;O(x`31S1TLG{@I$_=-;!
zbhz`!AAgT9d-YAa+dFZHOWRH&<%;*`JG<#Im^*wz8dRf7ww5^5MZ|_R?TasA3XQ$}
zw)ux(Czrw4(~I*}Ama-Gjt7gUa-H44kH1tgKl<}Iw{C%{)fKcao<$A(MINt|w;g$1
z(Ih7;Vds7Ky8|=M5rVc<oRjFlH|<X1K1*fWh!lU#E{kx!)Zv|GkDAj9gX1K*=w-jm
zC0d5*rYqwsLcGDr7qY(1O(sQLbyaV01{0D04{+iX1WdM*$W8HA@!Q=Umg~H*TQJ}c
z%rzBXj}$stvaK8&4^!SgupjI^X~s<`b5wHWVWy>z!mx+P{QorP^H3H^n1^0{XHqI*
z(R+p}n}Ud477=`@Uq3i^3gIsh0(d))_wGGg2u_6nrw3t{>p;PYZ-)4_?fB(Tt~TGY
zc9xLa^xUQ1fhCZWyf9`_IK@Or!D86zk0eSO#}Z>KdR>48sIMEw`mG=ijbFqwkq?W$
ztn<*upJ)SHNGMB}C`2jJ=tLFF(raVvQ}@~NGq17@_fOZ729aCfWwQ`TL<o+!0i(kH
z2kY39h;lc4XClWM<H)7TwXUtjjY1tf<$Ck9W+4i9Rz6Sc1EY+>;D=!Dm>;iviY$D2
zdmnMIc2L(vd+B4X!U>dy*-<mZ8xY&OAK3BNi;MFO>7(o6%LOcRz}?M?x5rWO%aq1!
z9wXSA>UDtJw4ZokOwBrl0T}w)SSKLs4K%hZ@kn)>g9R@=ATy8WFVE3>#R)IWB&BxK
z`?IzYNs(apPv$`RAw`f=3M23XrtlQh9=yR}F$~DaImw(wQ3hO<f+X#|*@-2Rb$(Pw
z`AgLe3&FwN0Tu;|#s!P8TXXQ8T4WU%qqV7HpD5}t3{aOsJTCJcb$6dCC_diY9~5q7
z;|B*S8hcZyuhYAhoZ!Yc3rQAArdC&JO&rFRx$pp722|kxHyVCI>4me`v<;jSCFxcg
zRBEzoc6pLREh7A)SxDxsB|9n3H*oHhKi@VJie}xDv9P}N>sHnWq1>Su$zGpM_k!DM
z`d(;)|K*`cZgM5B0$O8dH_C^ia*Z-bKnK1!7cOgkq`&;w$;EsgiN9cp!hRKLBw*v8
z?~{Nv=dp>(CyI8ZdhKC5pwFe;0n*Q>hI^6CH;-D{^XI$*l(eRg($WiQ`L>8iCOTa-
zXp;Cog>iguyk9y^W4Gw>3T^9>#aH!0lv84-b9m)&li+p!K~qZN1mAzEmY{U!Td?&#
zj67|i0+7r_Aqiyom;m|0?1uj2<psZ!s2c?78(pM~&~)*shvSE(Jsdb6bC}+ro9k?$
zxEL2OD)PCSBp~~>OR;-;2R_JlK_F){<Qs(r!?i9U*xXcsH4d~0nIYCyi^CrLskYPg
zN@5k<pR5xl58ig{<f5x$a5@5R+zXnHh^D<=Y-Wax`B(-rK-kRiB*VBMFj0~x$MHK*
zwf7$K9rYbt=2#Ysz6hR{k+$~<F26ZH{)|m~@^2s!QeVFtBTY&jsa94WY&U^beRA!k
z_(k`;`2wL+Sc6%^1P$%@CKlD7(0@L>7NUBC=-b%(6e{cG#d#25itd*XpA-ls;a>V0
zmpj<P64FQE8*4jCQV3T4T}h}R_xOd3Kr9Fk%j4l#6WrLMR^iP(AqpmmDw&ZrBgJC~
z*(jc1=w2sewt;70(R+wn#-PSl_8hnwo@m%M1C-GI?f~NH5hqFiqLjx&vB#L?7z7-c
zK0Kn(u}+Aj2!@b<GnC$8NalY_45M0~b*;$mTKY#_8+qPkQK4NwM!F0|Cp~Y)zMbKM
zQfTb?lIiy$6>r5U=Mi745BkS8!#6>;>f<K!sb;3G!6ysKoI?*fp=O@FFr~hW{t+AC
zxys)7-n)`H2bG4$bRv%sBqJX+HXYK{x<$1%aSb*pSgikP`gjAn*eQRp94}5jJLn|X
zlsbGQdvq%Zl2_N$M;Xl3^40J_>wz6$r3#DStSEnk{4Rv?gEfng7%MUKA7suV5Mzmw
zxqBfSAE|~_&N|#!zo{eO*;p7;h$RqQzBC5_Z-?CMwYb^rev@t2Q8Is2@ys|ET?w1=
zTOfIlQVC&#q^TttjMm=^ys<wivO|u&Tvki^sIq!R6*rS;YSl0}t4xx^o_`;n&kN~M
z#09-60;pp^2h{GhKrazo1q@nvao#aWopJy&Cqc6!n2WfA#Oeo`x9(UD9?9;REU@H@
zJWjaUq|dN&^rjz>(5;4tX0RhUxcJwLOO(KqaQ8ou<+Ag(Q|vLGyPZ>X+bbHF2Z-x9
zXkb^dOS`YWS2P%g{er?T5M?5`<#Pp#_H8p6U!*9nKA-YB2a1?fgiZXE*h3Ur@)Tzp
zI}!%L+&5|s9)8<}*Un<kI}G)K48_znsP91C80l2dI5&AE5<=cHrc3Jz{L5<^`X|@O
z5`dB{>Kuvynn!gP^4P)9Qu+^fEDp>CQHnI!bMo)5-XY%QC}u?ECzqNd%zr`c<2+(|
z-js=#RbBz6qpyObzyUX;2AzEr-uvQZ55M}MGJN&#sc#gEHf-VjFv2=NUIB_n+Cl%|
zHZ6x!aZyy(xl#$b72x|v0?&>YkOuz)0PTv$0`b~@;^Tvdp`ZXe6jo|T%jOjApE*b7
z-vLJwp+wTjC<Kr7dafsIj<ISOFw~=;U@IEk>IwJdq(lT^)(zcnJ4e=cs>z<jw_gd!
zig`1!I@J>@p*^{x4C|G%025$);KnSjT{*|u+6F{OD<HJa4S9$Wxmhtfm6m*-V|hjA
zeG*Xv3|Hx@9S)EGA{ZNXoz;MlAqV8Ak6PNTDjd-uQjV5EtMVbn%4YjbGg8&<_=VAQ
zwPewG{pf)PA&U6^+f+2=1n;99IN`=U1H4IpmJO`%6(i(_%~Th^7=Y`Keb#)Dri8>W
zP$v--@%braM%|<vVsm*fadn3|@S4HJ|9xC00Kw<iy)1)aP<mcuT_-i^HrLXEWe5?x
zZTqL2>Vov{{kN#e5ZvYkiy;kP=*0by;7<V|=LB$~n||N-P>>&=t}j}Yp=DeO659+a
zhWY3^)n_BFf<WQzeFNWhiz@0Y&0S4O!$A7S6n<eEWZ^Y&3FWGtMC4d*k-?Hy3D3-b
z*6T@VKu^`IgRcvU-bOKIj|nyrr>TLilWaGsls3XAIh$+d2w9Lqau5itle!BR_fQVd
zKwcHCi4BF~Q`QSgjOaHUk~d37T?1L}SYeSF+clC!R9@77t6Qvd3}FBd-G$VP^AMi^
zQNSLT(}I<`NQx<GBev92X#Mu3-nks8J_|tjm;e!)V=RZ8bkbdLY?~1^=`L{)`l<=S
zZhyS`CN5?I2cJ0_@y@5@Iwes$ndl>JLsjF(b}O5WM)(1^hn7*OgHD>bI=0#aEH(Mh
zcDmh)oh~1_=%;Sm&XTXPvu%G}SRyD_bC6I3x>UaUq;7x&t^(BLho7cqrTXC98u+$#
z6qYI;)`bnX0_CzQ;o`!|K{12BJxALH<qR0REP_Mcb_H;+{b~lP|0`x(;0G{|Qh0MM
zR77Wi{EQ!`!T;pjt!*BizydBBtM<)=mG7s46k=WD`k|Uo6v5lN1udGB?Y$3vUYeU@
zoNfupX^%i}0<mu_#1WY!r*NyZ*$eE5x9SQnbju@l2t+y(%HT+Ij3gH<XJHrqBf#~H
zYjDCRp3)N3fu6&Ct0)Rs{c+rOhuVRdBg3`9QT7u)e4Dxj)td8(6lLI5V2Iy&lip1P
zkg8^vaz|l|Dw1+>zSZYfr3PB>u!sO(b0FS>w`#I|MR4t%lJq_x3do*l3foEKV;u_x
zV?yFVqM?$4mJDKcA9^xZ-D<Ku+Uy<R|07=FASS&>H(%Cj5<+^vK_biQ3WCT^zvy4J
zKUNNCCKs9p^%pR5JPP{aF`!1>?;aRetnANgxz0DKEZ@s~6JLQCTiI#XZ9yP^@U&Sy
z$TDOl;fp-EI6vs)`}3Alk^Fw^rS4tV-z$F6gztMZSNAKzSA1%1;3mk|iZpwW-v9T&
z5F4`y^m(w}j@vvbTy-jtM|3muh?G|j3j$N0hiNj9Q|;A%Kj>lQH!nYBwd*nte@|5o
zLaH^-MP=k2OE_Q+enrNsS(|^r{s2Kd*poX7Bc7Swp%A7%02`{5enk+;E+Hp%zW8n7
zlgx<>x8Bx*qWK((u@y|xWp<(PGF3IOx|ss%DS!LpGw~Ti8BC#m=Xu5?V`mZXF&jIp
z2#^rQQW$L30Bk_*p(V1l6Q~|%t>!~d+2-4!$@4n-`ie$NGPQYy0<{r(9`cb`<gM}o
zzX3IscMa|T45FbBDgxyB){-IkRt`YNpLm-Jc+)xKYVBByFpK{8xir`8y^?m`!rxTE
zXlf|g$N?=t>3&kb+7iV6X5i!)fU8eLNS1%JB;5`~{y|?XZUdp=A`D#HpCvA@tPe<f
z-fi*kOzyXwT@dr>7w4y#8z={^!~?>x=1_<CO}SS8T=B&m{+jF}0n;@xm4lLv^p1Up
zbr<$(@^oawI$yKXuNPU62?=C<{?^#$p>adXQ7k(AGXUgpsBBFBZo`xL+TeV9jXijZ
zuNd^8bORptaJlqAgh2)e#T1!uOEQ9Qa6$(Wqc&~Np9Iu1L|}}LEs_2NX~>)ViQFBx
z@>i-WdibvctN+4O4s*{SZKQ|Asx15RfpHnwf_@wlMomNVyOJ-$Bz2Grjwapf<BejG
z-UuUE`C3<Ss4V7CWmj#tX;96Ov5|4NJ&l(`9L2*IZS(}KpR7jn9J_R+ClNOC|4tWy
z_N)h0Z~tBVTG68_amICga=n9{Cs$9)AG`W$!39Ng0uv$I!0l0(+iB1Y_!ICL;HpP!
zu(9CZ1Nhm1(>dCVkjHmeSp^2hNpkOj9UX+8w_?3Cs2Qjl4P)~EhBeh{<cF%otPWh5
zQAL;52YA85?1XhPx`IIZX%JUA)a|oF$n_j{=+Fn0J+Tnz2}YU4<4ei|n<TZW_GAZd
zB+5q^2Ma2p3q^m2H1~Ugk)=5awy3ZajES)YNS5|?>}$af<THgx8~JgQpwN<CweN60
z-l4sQ@3+mjr?ijsgj){YZdgLy6bC@}$<K8@Yr_)w<Ci@CChFM3Bt9Ts#7qq{HVvR%
z+Yoll0J;MGOEuZ&^sBufxIHeI@k~LR<E`c`DkQwJLy;dOp&tE>hw@4M<p|iSDs*5+
zoK$6_>rGm+9V|$bibl-xE+}KUp=b8k07Fo@$`6#ea`y2xHUM=%#C7Z&#!W`SicU$J
zpdl6<E6JUs7;m(ZD|RI@s;3v~tdo8a`}r-}*2cNiqIm!GhhvVUT+QAbX^4c?Ri^Sy
zDO54F;41jT1AnZ*720kBUsb=MT`re9jP@Kku(x!my41m=CkDPw6f_H6RS@&#A@E{W
zNQTyh0CZq-yigB8Q_tUy8Q0+ROI8YouZ6GFL0p)SR~yjNHXu2k*h8#30&dJg`|2t*
zFN^9UNDPZ{%ZU7@!R_$0mJBal3%N9;bq)%|DQK}#0v$PA&s^Is=qaYJ1QM82d^$rN
z)!(zwHu3YwWdTA~B#6<v2&98M*oYf4BKieSN}$bj9H4>ZC>R%0HMpJm1lnG;+5c<@
zJcy7^83|fn<z=U8ES=4~h35Ga!R;~NQ<5`?wa7b``M0TT_xPPESUdu~3-oLI^O&fQ
zElVF=S9}>dm!9#GZ`{HyZT~Hm;FprKsQ`M%;g%(E-tQFXSCVwANv!%xRuCU)cx7Uw
z#s^jMmwzQWf@6UkFX^x=F%R9+zfN$adTzW)+tuI%`+^NCi|0vcmw=E14V$wM9>4{b
zlPpP%pc>_wQ{IV{b0eiZm`gr_>+hf)Rqh^FrRH3hn@tTKFMUf_iIA9aaA^M!zyQpv
zv8E!13n|@<-82T$Ddfjfe;5~ljAp69F2!ASC~741tEc|kK-w9Z&bBWSOI*1J;{pRV
zl)+jy>`4uQ+S_Xp7_w1I1^yBb+SEo9J>3Pgu7tAA_o$Jg>GML%SuullQ?J+TYGjA!
zUPv0|lth29F>FjAlp@R_Lyc{f674{M4*G;gs5t!bdd=E><R&O@TB)oZCA=L)FfD6)
zeb{)q$Dt^KV~x3{#nP@ihyDfVBWF#*9qQyJ_{&h9ujd4g&pNfuB(=jATrj?EJcah7
zCgn>~jP+<=C;I|4rCg<SuJQsiUG)6<6O~XsJj_P$d>XWg5l>8bG(O1C)5PElTPKM5
z*U3!+AO-TN8tX($Z2keB{;>5tf-F^Xm@HN?B}+mnNaXK5SIVJp;;a?)=OHk4q~&S-
z>d2}#Q?sWj6U6-pT@=GdQ98sS#MNE4ZJ`xL8DT4iTHNFm<bio9C_Q!&xe<~Oc0(t~
zRgcmId85?f+h>Z<a?No{LqHhHkM3OOB)w`K{pv8L6e&ad$AS=owRRg%gL-<wV0W+o
zvYja1rKe(?10{0}8X?f%hd;sP(gG{5g_VPefMu~Q5rTfrdChRCwT0qZ){fo)Nd2pj
z4KFj}2Ei%#vHPBsdE)8{V9O9p&p13^NuklA|4tsrk>F>y-RWA;ERn*Yi~6*YwDtrb
zw*|f#RJUT}JB%Bck!2F!GvKd)@Rmc}Jle4jawriud5*mPlCrdW@2=H|u>=N6xA2#j
z#fTf@Kj%kQSP4a@(fgndfd=eOe9#7*GR%xN4wQuU?kWFZ846_HqK9q*C=$>WBsIau
zF@trRHTn%<qYx}n#o9d6c9OldfEZxKXzV7_HB(~ye>k!|@3EP6s)m-+uASah-W-9{
zzw{kcrGLTvqKOhJ+5v_(X1)zlwo8vjH&+P?Df_t#?D-Ld-0$=)0?S9w-$(o@uK6RR
z37LcTe3qui)ipk%FuXU%I+Q!m>;GNX#)d)ZMbe{{qBGC1@aOIAR2*z?fn_Ss{ugf%
zyCzwNo8FAA)6*vU!Jr#+OS_NHgKg7!XaZj93b!`JO(qh8LW=fNsjw%3Ag8gqWvKGo
zzEF?t!H&$hZQ#>A9Z76)w4JgDtrNdJL5rc_Y%L@DrvwuadHTo^SSdvnd)A1Wa<dd>
z(LxlB^;_3cvH&DxAfa4mq3r{5fUlla0dERS5z^#}u?RKwgC7*#2mEc%X*F}3L)=3C
z0(d~lo0Pz#n{dXpq8<R!fo*93`g2#<*9BF{&~8L_wRh~R>evSjM1aT?_4V-+*Y3kk
zyYb#&>xW+nD^lU0F1k6)T!qM=h0umS)z))TK1RzoCD-{Q&I8&DA5k^5j*or<GJsUc
z5bUx7OGHg*af?I83U*}<JwkJr8|f6(at9x==Z}W^eb|=b-Q)K)1I?cg-YXIw<vJ_X
zWW(Pk2#%n(RQ@!L{ova+qeS3F!t6L{&CcAOU-*0TW~tsvv_1s;MWNioj5E=d2xZU+
z53W-$jc)GPH|QsW^?mO;cm{q0nP&{>n^Gs=ai%w1HZCZOl;J%E;WTgBZe6hnr?VdF
z%b0MhtCmyang_8BJ(;MC>%QUQzUI(J=}3nX5@axhe^P`coO{y|YT1{w76Ox&w_W}N
zoD)DA9Iz>>`Zb|V0d=+`2bBnlkgOssr!??O+wehKaP9Ao=Ij`T?yM6uP_6{rUv(Gj
z4AfnD$RU`IojB$?)2lIG>(;i?C4k9@K$W@9CpbR3w0pxCqprY|R4W7!`hhhV6`&4u
zCA5H1mO2EV-HCYk911^{s%?8_ZMN@zaucK(Pu&0!oOh8)&MQb?^rxupFv5Y(?2t!M
zl=oMEhjZ{5;_eJvOQ7g%A&UaxA|kzQ+f92Pb$|_`ez3R=nmIHL%o7J861R<btqfhU
zi5#agDTRBL){#Ct`^HHgJn8noI`DG*@x%O`k|Ah82ub|)bg>rXb9$f{y^`pA3Uv!V
z`3YLGVmqF8u&FED=yQ+8fa6l;U%S+D#Q1V1&cY;xZ2`UXyu}s>aCklb3&igmXyuqf
ze1(p$iS0TEsR}w4taGH3YVGfox8s2@B4Z9$q*U*S4NJpK?jl~pXQIu46p)WvSl)dG
z7e!E^f%qq9>(A#7pdGfkc>UndKtjBisG`X+0lL#$l>12e0u`aBvY~=Bss(t%SB+ms
zuAEyCuGPOd484h7*tMtp2{=biLp%de9c|m;E12H+0hof8=2}&#+#j#L*%s0n;J5a7
zzXiy4sHjoMr)}tME^JE6N7vdu)&O6s^K?LbuZP$oP@YR9&36`|>1b>0CmUc!=n<io
zAgO{E^r}-}4Lx@(_t@!|-W2WK)^ezACW!Cq1rC}*xOVYQep=701l9EWzGGG-6u6~_
zz_1}xuLU>o<p{s^)H&?~&4Op3<|%m#E5??GOFbV+PNZX74?F_s&VFOlP)d<9e&E8?
zQQk=PWnu&K+U`kp@f_D$i28FDoNb%bGf<L3Gu!75dME&F7bu}X-})M9;Fdh&>dvaq
zMt2vZE98C`lu;d}IevG0PNJz7B7^q%Ejcz6jYe&sCIls;!~|aJ(7vk90zgvK{tgR0
z{@5Fsx_N*SKAhFq3iN$YSF9W<&4+tBJNAL`6VdGJc0a%0)pyLX9Z(vZ;7t2J5BS*Z
zYq2NOGhnx?>Z^5Z7^hEw%(Ssdpt&|1{s@z_ZnYyw9&=vn@1&`D4Q4$WAP`fs7<!o&
zD{T3q1X=}5YCGZDP2b5qYjSvD4;cIjTo+DF)&;R4>%-Hs$h?1?hW71{dQ5K_yjhzL
zElr9#wD~9%Xgy;V$EHY-9KhG`w=}<qyy=4v&9Y%9%x`z(@&8+a0t7V&L$?1JLC2-S
zBkxz|DpCVmNO{6$KTv`OK1ojQP<6xb66AQ1Q6*>uAApCfJf0bS)wXyWv40<0I~2hG
zC}__DluPYo41=a;WA|f7m;A1vz0zlsBw<Ayx0l|H8wSbgMXq*6v!=6eDPL@zwPo-D
z_ENpbn~s27Gke*MZlA@iG)86cLVe5DookRBJ1mgZ37OY@_fM(RBCYUHXxM><J%qLp
z4xfaXh%`NKN4YPGoqws+R(GAc6A0x<S9lt_l}_e>6O@lk2@kquhCDvQF*zPfbPc<o
zBKq1936kfbn^c50YoMov#!t?1bONAO;oy^1)dSO5b)6LC9ouSCd+`z52clpzZ})}I
z=p@iR+%EuZS=3+ftvrbXECLa}wr#JPRF8(zRUjht_B|kWL5K|lq3Tx~Rk9xR5Kh^e
zLi0TK)0?4IOHK*@IwqqpC@GQtP(p{LM}{+f4R%@&hE<9EChUNQJ*A1~(C(Y<SV!0c
zDMhRzZ#y8qVK1tdcoZOcC8Bgb_H|}`aQz9S<Mv!~`6C$3=P(~V0LpLlu!26yknMzL
z*B8;_K@)y8G{DyL+~d%Wj<rD5Kr(6r+~*I9ITGH%(>Dbv;wqOKJ=t6G18fvz`7H3o
z7FBGi2!cQV@=lXk)U;K^M%2Qe4L!DY+JMue^*h3!DXsi_C*-3EzH&K|j)aNp_}hz=
z10YD@<Z*4oq+)<&(ro7gkY}>qP{-InCyU(#($%g0%s*}~cW@`LSx0u0*>@;5NU*Cw
z>k2S}(;$dDdN_#QEe_%cRMiPxEu&@|9r3a}MLpX8WADA+v3~#m@duI?rAWglWkp8H
z$gD_4w#XhK+0;em)l(v~?2!>Nvr}Z2Rc28xl6i%)XEvYvc~$Sv=O6g~@I8*V<9NNE
z9S+xdo#%bt?&G|l<{(#ib3}v_&@o)Sc|we=gR#PXks1?&<I+u%T-ERe{rkR~sFP>b
z?hjK%5ZER3NKAqR<IGVt7^LA(=7N=Vcy@C;G6Ay+sv<My0JlR4DUbe|pY*?*<^Mqa
z3Z&U2=L~YuJZ-}F3_PI{a&5Zl|JE5ad}OpODfZy3z*_39#{E@K5nBw&WBee0RvVZe
zi`>>~BEHi6B~3vi*o4q%263a)83k0R)P7utCpx3qxoFh|!zUnVAKc5aeS1X#!6+zG
zra3`RZpEXS-Q6k(>rMjzh0d#cq^NSF8B(PMI*=bxN1Et_;O4Av?f(8|Wjx)Il&2ub
zYE(mwKs&TJK(7`7S(*HLUv|7NO4n6Xtc?$|+C$TBjVaXspS-W8CKE%Jt%hOTZ=ea5
z;H~6soMPFENWf|oErB-i#7M#}KHNLWg@wHZ2jX+`!OY6z_7;Q5FVF$}#RWP;s<PqT
z@6Szmw<{Y5{$Ufl%j}l>)%?9qOTF#Ihp+(cl1fL-Jg__<`p}*P1+LkW`}$NmF@@G`
zr-rG(=01C0!T9fNAY9(hn8<iYX*VN&w-+*1Gl(>)2f_a}D&~U#R+sft7f6EzpoKXC
zgfcd`Qu;@AE(T31jto%zqbx9omTIOtI)N-42AOaJ%ieAhw_BC5n!U$jA^m_fy4yL=
zm4c_!!vBU`oh2+)KdN!em;sde8f5c9X@NrDduJyGEIA5f^9<FG4J<VOJJ+b$WG5i+
zeCROXhn{v)sh(0Nlayz<={v;D$7J!BQf)%pyjX!2f+ZW&+I(E7*pJ$-k{ysPm~c`x
z4_Y2I9zyv&Xpzc;T2CR^|LAHqd@jifOp&aBap1W3ngxzrY4qniKgW&1<2^@ho+{>J
zzbc+Q9kW=Nd*!SFTh?<VwKR~`*r7zsqx>4XBb8A(;D(}5R=8A{BGugSS7g|Vmr-K5
zl-sGD(orP0j}+6nV*Z%PE^5W$v7^b@qx^bk;m}EMjXytABzA3RX4juG`ifX6^V{DF
zM}rKb>qi{%cMa<xZAn!D`DaKJf0)KzHxR|8PeOW$$#JSg2{84#9(gy?|G|EJH-p5+
zjK-eb{JRGxfQ;qaVCA7rh5!Gu_GXBX84lZ1aI^|4cRnA%e;I!U=-sihOlF(|I)ZmE
zC$Z4DS-(1M2gmlx2^uL^J~5xOPB1%11wi6Z{bwbB`2973x&`81d1QM4<AJZ?DW}j0
zf-K7Utq=&vNQ8(sj2>I;-9HS(>^WMXkypVRI(7=LX;?uz&mF;sk{{tTZA1y_`;bJq
zhuhKV*ptBYwu$CME5NU<C^#uv=S{iP+m~--@+yn&LXwI&FCu-0PyYuLFI=ey4izZ<
zMbZ2TAQq=g=}}fpX^dYCZ~jd@@yO?BYp{PjsP(geK5yb|=%o{ixW&O*k<H&ellxw`
zIMYg_0;4e$>s}V0GE4<7;u<oUlKH`7)Hes_Lm4vCz-g*P-!fjsm#kD6sBFxwPtZeD
zb_6Aaa~-<c*ZgX0qq+zb@ztv9ThwmYI@e?kpo#~YyrdsMEa&e(*2APU41I>OU=Xj3
z*zY#xMzqd#FtCr^M{zUz>+%+t*aN20)s1RUXoV5VKz+brfTkeZmI}#OOXjjqJ5*n4
z$$U4L!`y8@(42_O8A3HFauCOLKPhvL0*b5oJfA=N>?Z=riv+vR*;irLv@EG2pzlr8
z&<$WBK4IYz6`mY~_BbtUXY!fwn*#8RFHa4#m;0ROh!<`mCv_$j&_fe)QbG-lxTHi#
zDiw=`B}9(Se4T3x+u$fU!vYh3jjqiVH8>P_c(sx3fs9!(zmDETpYu4<z5o?M{{ZaE
z#O9U$&i{B?J6XJh;cN~dKf#|hNM<TNRNOnFk8JWgG?`&p`=apcM}RC#t_${5m=Wp^
zD4-Wk+IGQ_i<zGI5GL-n(kkLL8$7uWR};^NbpTRB+((Ew<|<^|pnVrM0XNhvT`+gZ
zuAcaMX=VBJU?Pdaj^{j?=Ku8qnA^vOuy~weme{bs?X;;Mci)aks0neUA&)U6HJw7|
zSON5PkZ`jvH>Y2c3%&@7`NozWP84D#t9rkIQkuMvD3(zY$tIZFz1f`e!$HQ1ZNryU
z+x%iaOl4aMz;bf441J{P01P7P7BJ~|AOgEmFAPo~=HF9C4N+v1d`On8^?UU4zAm#g
z0ON`U2MrUqX3KkaPx_Cs;LiiD8u}BVc^`v`u28F@5t3TQA|{}tq+1XC!!Hz=ZlP@E
zYm1eonc_p;Ckci<E}&=8ibSk42U$%(cM6bFVdSgqf<OKNpTN@4yo29ejN9qvx+)-H
zZ6Vli<O>QeT$OA7z34X(?6W-3+=kB|`MAv7Fy~``%d+4UZzXx!?9;BYKSq5oXK0c;
z{y#`xg!n_-;p_GbE;wj-?wwt^R0nMYq`pCXZW%~35gFDtV>x6*n3I?-Eo%t#@D;7f
z#(w(8sE`YwvxDg7>*(4Hl5;1ys{&YkIV7AoAYA8!tcCR3#&~ZP%#{Odd(91l&1tEk
zL*368ST+@L<Q2to`>T&;48Zh*cQj>-d!D>Euhw_oIPw7`;~Fy6Pat(gI_hh4T`JnS
z^H3U-BCSKc{d)%J{0UB17d|7=(uQ|2eOYNU(Z0<+z4fz6q$UEe1aTzr;E&QCkD$r#
zM=oC}L$vz=K<W(ZG`ONoRGea#@^>Bo#yy)y5;Z4V`_+BBdN@Lvy#$fVZ!`82pTW}j
z?OHAn6h#1hJ{g4`H|Xra)WNIO^g~pCZ45r$M*8&IwLb4#90g`z=Tw4TMcb1&ib3yK
z9Eh~5*5A;GEN%WfrurJNi?My{QgDJ&bBXp~0?7{CTUhl5eBsfu*m3k=(SH5=XMMnT
zb)K_pfm9cx(E*6w@poYtSQbjPOhX%sY0I3wemdHMGHDCW_v}}Zen@T&Jj!qBt<P>#
zHYVru+5}QzFHo*=SzK(8THkd?o4y4(=QrrA%N1**NruquJF?$Y#e=X^*Wab`_o;ZV
z^oh7`S5EG8&E*(yKSF|X??Uc}Q%VPD{S|Io!za+!N7nKmnYi?G0GO7-nEMnf^kYL_
z%GDb2s_W><$e~%E<>3vvyvlP@05=%gx0cp>jw;o}^I+*v{Qr|*MPfuU3Dl|D_@c5e
zyF3iQ_qQ~F_;{1AsFRjj&HUvgzB%MVB)OznVWe)3D-XEq*p6(qE>PFhp>|{_);UKq
z%^kaHSCfP?5ovFsM*q8WRCf_d7sZayf!l&`f5D-=$|$0#mL*3GLkP3SPjbgg;si{o
ztyF-3U_20-|2Q~j_dK}LGvP25DFp=xr1&i)`*tXACNdT7eYnn7f^&o*pqs61ZEDPM
zxlzj85{npxwho74cd~-Nscjgt{gXZ!d;(TL;DzWT67@JkQydvSp%gyWvs>wBPqmj6
zP5-jv{0}!+Q%!2)25#pe#}RsCUEbwZP^8&oXiH*90I+p{y*Z>NOCd=1qqOHJYN73Z
zJVuz9+`)c#<()gPP1yM0=JGIFR?KI287B?DXevRU4@_BW2zXwGnw$_J?PM}+(4ckt
zkn**qm!!<MG0EyCIQr)EgsOxRCx3{D`CK-5IWDqMQ!*6h8Uj^BN3*=1%Go#fhkijH
zJ-;G?;e-8v2RS<+X;tiWfVRB|?kym*hHId&n%9R9yAI4gu}Vl_Y$SFPC-<?R-&kAz
zODQ@t=fas2<*5$fE=lpT&HdCJ*krY+SH})ingNe_%Y~mC>|8$TqDL(aq*WQcW({HG
z$$fjA76-2kI8)B2@4<gWtwJuv_lNB5g1+H}MFDq0&o_pzJYTMI@nm29Xr~2Mh3XrV
zErCYc?%%iGu~l^-FA35elW^%I?~QwmUW0EPta$Ugkje;v=KswQwZx6lK=$!8S??fm
z@;>DJ#an^ss8OYxi(uHiIB8VPg20xTkMH`5_qO5}(j}uhyY1PG(yhL+o}*ZOxBj>o
z^a*^Q%=^Alh4sIO$~68X>IYc2hx7sRe*9uA+O{+Icdq=0<WnPWF7g*r98;~vck8?k
zMaPk0YV%&?>p6OQwt}2rG<t0w!Rw)Q@|80j@ejn|R$NXX+#UH<bjMx0{((OVpKx$F
z&?&)d{gU`PVaC$3KpH7vG~5#oPq=gtH0|S2;ZZl#r}8&{VF*zX7V`ya54~U^pY%z8
zM)LY16-F(?fl=<ZJ1f3@TP)9O!Yos<WNoYVj|%X#%zAs#`LUF;>YuSshjz44w+2Yc
zy+`5NJAerV3>A*#$vkpkIM3PiZ>$1%y}6co$KBf!L#jPp)};M9P>bm=4ObTBnKA}`
zZ)#>Y=iK|gIi~^yWSe8X3{7BzT88@M{qJH!StvQLpvoI{&9MG0Dt<kNtu~CLQG#yf
zD^gMcB<NExmgq5K^0I2i$>F1T(jWESZtvf$Exnht`rf-#=ZHV;6}RWTbp<EwQqL1U
z?eIEYPD@?g{pRuW-Sez`(?Ti754yw$4e@sSHeM@8c;Z;RvnQtWhiNeNx&OYLE`9HG
zEbH-;qutljZ_=Fp(8@NwkLOy=`3lPRYo~68jqMk0KiNJ;aUhI`dg=Q4AEJI^>+W8?
zsmj);#Oj>S!?h*B`obN_$Hrj_N#@if#y|e5i`7(EjOxW*_NH<{8V3cq`-ji!tq=}+
zH`_aT<n+b$aqhz31KR^43lw@C&f?L0U8w|{Ta71RP)$vi^)0H*QZF2yLDiTdBn8?i
z@fs!_6COuzQQ<H1iD579Wpz#G-SWfc(I|zC%W98(h1=`DNo{%J_E~(Y7jEOKIC$K}
zuW<b~pV&@mb2`25q>pWCjxXYM)vaA7XdNYCLX`&H2wC=XSUN^gA-JN2FR(oyzegRU
zOxd@Co0c|sZ+;_#_OTv;n3D_xA`F|MQvSvHaR>G9RrY#=x~N{TJN9G3lFAjXjn$|n
zIG#F|d{D_Pf$w+^*$GzDFILp7rV?=YuAGwckV~p?i5#oR(ivD|$1%r!l9O5J+Z&M2
z*c8iBaj??j%21?#fh+lmOQ*!7>vKad<|a%YX#Wggq2)A8p%uLm5j=TNz^KXf?B#n)
zMHH%cEKT)2B;uKNh!~JoRnsv|8s;7tYuRu3c&m}6?tT1NQK~BWX6|~SgvS#misW+v
z@m;SA+DoFC1}S*~h*+qff(wiqUq8^))KS9#o+`Br7!=eu$r$mio^xi5vnGN>REv>O
z?H*drr=#Tz!%bogMP{m(_vDM`xL9+GkxPG#`4F9-#58#GH3yaQV8vNEveCGOx>Z5g
zb^A|qs^mr9uiyF%;i~T9pS2eH`FGaZ7n`ZF!g=Q+GdL^e#o2u+o?R5qb+&~g2md?r
zD+}-m?D^fwYwB=U-41$m6AQzb@Uadrx~6&IK8Ug(+;?`!ri*sHk>BI5;<bju?Ng8*
ziX6Myd!%kUwGw6zM5+Og1^N$%h;PEJ_T+uk&tymk9%6K)3BH(n3Aa-ub0x7ND#0gq
zRzA1S*1``<SAlEDB3iFANAE{Txr$Ylc6<oA#OkYUSZBH$uQ8T>uc`#*S)FP6GzL?c
z1gA{r49ROeZZ-h{Z7r$r4E$4(wQHB>=tq-Cn-iL$HX}~+i|u6l;<5bSu(hm#2T|W<
zW1*eia5W^s&%MyC7cJZMfkv8(qw>rZitxe89mXNuY^HXI9}7VjbG<mton5(0a4sid
z=9q*xw0U8fiTzX64NdVg7LCad<7Ny&9IFnt8V=w_=^f{Soj-4{_=tc`^{8>4)G#Dd
z*3RvdI8GZ~?5z2HEwl3*OgCq=rY(HR^j}%g5!&h&ns-^&k9Hei3w05M)gKi}=k!AS
z`QY;Wp*9(r>aJ;_s|iud7h<lEBuo!T+r$@Pc)zON*KJX1>%=kbeD12YGVU3D|45^X
zoY|(mx!*V7HWr9QO|<=4G13t(#jMor04cb{S$X4gy>7Yt>$DLsEF@WnpU~3wPIDie
zRPklKEA7|V$rCL*>a}CcykTk=9CK=jqI2Cf3u*MA(bh@cDwFc{`%52H20{#rVQj=+
z+wV*bqm?GOefVsvTU003ddLRP)5+e^3%?Ogc^F$T;fiP*jWj*-LW?I6ra#IR8hIFe
zpdnX^0^U4HA&D=W%kQt+Dcf^Yjw1<sd(>i*1*Kfsfa(4t`}^BME`MCI+r9v&q32?S
zveo^E0bC=u%+lKmcN#a)YZykuJcA2)@|-YQAVdLpjxOLo8U8kU0>}LAZDO<-@Zhtx
z(D0jTR}Qf~haCR0=5|%ihnD4H5%R&iK$EL6Um|jom@wto4(kgByiMv@3$KRZ7y&0B
ze@G!`h1sCB?OjU`UzJd?4;KC$oP3%<eQ2$&+jj0sv(%<|Thh7-jxOZad_9RBhx^5&
znS76aDlefg59JBMM9kS|Ml`TA^{WXtq*!s`W=~R)1tkiM+?z%McJeIT$7WA>?9WGM
zWFm<a)ar(vS0vMeqeZi$W!)<o+kCu6FD>PUcC~E`My^cp^*=80-dHC|mtzcV$bO6~
z!f;`!m_nM|eCCc*3t5Z-w@K54IG96x?U8%BKA;c8^^~q@-5N4MG@kZav4qC~>*GF?
zM_QgBskPo-S)S`PsyJlnl`MS|_s_n*SRQB!fg5<GVnMC$wMdh}S~IW?d*DI>^xgz>
z(tmBIk=_F~@u;S?%W+yqm~f|20w)VG78L`nd{csZ6U{^}A_*6~PiW0_-N5az_|&m(
zU*90LEzWDOqK2b091KsYVmiLPv7qC+ppT=o2;$1exQ_LZ@lS;{%~u*-x4bizH_Tl#
zdGjMp%@?l9bAka@`4c^&F;?1lrtCm35?g7=850o4$ARM{lg95eK4usQmN#Zi_Z&Kk
z_i9E`<2;qUrJTvmDe>=tUwaQ<!A{?{psIPLn4J~lFnRUfg$v*?9b7@bMOk?*#*DLH
z2Od1x5;ii4wNxn5e&)knBDe5I-_oWjrEKawJ~0xwG|3r>8>Pyxv-h40`IYy~pGa2o
z3%tvc!@|Yh>CDb^YLCwdPL;$dxlzW@0wrMf=&dp1as6<9XCwwZDa0SV4W%pN$0+}-
zoClhKW1co|G=B88z49=LB`hr4=Si~ltf_3i&9{4HEU6I)Xf9{c@J}UR<H@sfBloE_
zJMVW!U`_em^JUQqJ{q6fX|TpuFeIYPft__r)!Ie7$OrRFMWWm5`HJBW^B*+$63k}#
zwhtt2EKZ3m_-GdqTPhV9yy&*)=2XD@%WQtP?s1H9tkl!{>$?J!3O^8F>DU0<yKjn}
zpS%~?mAuh~L}Hh+EX;vn^s~xW>gKban!Z{ncu*A$Uy$bF8CY?~?HK(4Jdon8K6iht
zeUl$)H}FV?_<jPu;ZO(#W(B^mCPHynzE8Hg8=Dq50y+(z2V<Ef<(2-WF#SQJP;C5_
zP|=l|-8|-0#(DZd{=vHC6K<3WXk-PaFS1gGv6)Dmn^`KDwpaPK&*oJ)pA>7;@8&C~
z*&1O<S<Ty4iG8-!<q7uq;L2<jose8Ymojb_C)o?aowv9DJNVI!Rsg=Qxha44m2P=&
zkUw{isK^EIS`G(gt=un&Q8|w&$!t9Dn*RNa<FY6k7V)CcX#wt!w>)1fBcu>)#CfX|
zSKo2>JhccZ;_iIyv8jyPfrsO?X8fd@b5-o<`*Gxl0}rdLnxO~_@p3JP0B?03r)ez^
zfdRfr3%-e;tQioSqPD5{5~$J+*Eo<m)ngNS12WzdUbuauU%XcD{pFbL2;oZU-66R-
zzwNE%raUDr_=}hJp5Xv7vgv~7xhmfuGTi_5hmK5?ucenKJFC}GxMifY==OX0`N4p`
z6Lf|-8OY?_0dVyGm3BJOLuNy+P`c@hHs@~8*knzmb+d16Rci`7-m|#Lm*<Ir+`;JU
zdY&qbAZ&xYP4z}+dn(xN!cx`tkh*7jt4XLKCo?VOgCo0`T>aExJ$`aCI8|Edj|Ktx
zV|=TX+_ZDiKw3U_!^>=Rgk6=BjL+WM64+XvjuiOp=v-(%qT*TNuwOwM@icNN*WQ%m
zxamK8EMG>RZfjmeD%7ZI+lX6Yb7}ba*l-{>QNFa&;uOi|KHhU=Uv;o`JQy}i>uU=Q
zJ}YW=U;g89r_Pvtez8B?xLB)zy*|3-<u8+4#ku$Nd+**$%+3TVu)m1;{WdJYrwk`a
z(iQ@k7YVU_nrKR+>P2p02!o~Tc`EMn-td~UL&Vs>y*Wb!7<NVtFX27yH;3He_D1yf
zVPwp1SGk{TtGc+oUCy<?vyx1m>&OVQ#pjOR(-osFgfT62A@a9wGY+*UhWbPIxHkc?
z8Nh=k0?aV=CGZtFKWTV>YP3}$=6BPgLCD+}?Y*fdJ`O-Mhq-o*Pvz=t4Nheyxt|r=
zL;tE&H55RAjLb{heWtc%2mYeW<2ILhs~mX|DghP0?#%Ypc*XW*e}7X5nW}vK>41eE
zQ3vOviDqXT!s)Z3K;kl^hV_4zcJk!Q)I|b$n274v^Esz#m9jw_1bFXh7$DJ<hv*^$
zV4v?fsZJO6hQ?18xqSxA_jD_Nh^umuH2o}e00A?^cG9~PVC9Z3M_@mnw<m-@54>e5
z5B=>_%ha*zEENQMN_8As($UY1|Dk~1cze<$Q|S@E=iIEmHSHXXad=h*n-Cd)#j|tp
z6_3)OXj|jT<~aBhmkX?29{U9q1G4UN3-CH=7!dTM`9r~;=5sFT%{E(!u+SROg?C2F
zfrY(5t@#jfPa(ZhU1+a;Vju!AU_E8)N_U{G9bewkUff>0Zqt99orAF)BpaldWz3UU
z%~__dkX}KarU80ON6{`Y{%U9aqKt4xj-^0_u#+3Rnw!MW!9_xezYZ|eXZJP}zd-#f
zVu^og45P0HB9v^a|4QiO0nMft@LxCyb5lP5JrbH4lvN^2YXM<pXm#NO5Z50ZxxJk*
zDH3{tw}M%5rkWnY9PSEr-Bv>>06gaOhZ1a<5>*QK8n#TN#_@a@Jbxj5v107hFuZe+
z1ms8sWEkko#|f6O{0QxFKw~iryrVbNL@J^feeQhYtNv|0Wp_$!UkiGcDEZY5dwW@u
z8Nt{ytM5s5y{Y;L0%5KoyNUx#coi(6z)0Yoi^NC#89&b-#tee|p#=p==LJfgB7jN7
z;KvxyoHD_Wj+}niHL|ksFD5a~xOr|RG&@!GPI@JI3&YF=_6zU`*Wx=xx<j!D?$ind
zWPxkkyW4we<OqW?6)dBz^zEUB2A!=C>#%|oUDJzbCM-Rd6XzY5;M3I0S8ey@Tb~8)
zNDKoBY7d&jRv&M5ZQj;*l@Qy5aolR+mga&W_W+_cMb~A4jDW+n=XullQWxLOC<P7l
z=E3Ltj#LwJWo5j-SWTTCHC3kX^woYZ5II(SBs5#+vA>1PGnF<nhEv0VKs!dFFBNwi
zSu6wWjG5S;u*|Zzb8AZo86gP`GP2Pt#RSMus9M!)3h2d-Iy)b&G6HAE)y8psC{4F%
zUgEV8eiN>B%)nANtX<+|<!O~)f}+UQft9^qWnI5RDaKv)S9WXy1r3O3Qr!w;fws~u
zzgUE)?o3Uq&q;{;`)>!$O&``a-H?!6n&5?z_4p1w2vFVLyiQr2_MPO!7&QPx+3aVz
z)re(Y)cZBsd%m86#{6u9uwrIn{So_j)SVq4XlBWy0~_HOE)oG;1qxP-T58XJ`96MB
z@yyp%vnjK49GGb>AlY>}c5;TifQgt@*S5`>U>Y!SdG5AM-HR(8J(rd4Un&M>@*j$_
z-?;gU-uNoQOe4p=+d|+nj3Tqv@aQ?l_YlEwDH!>cJ$>(SGsu5r@<2;TU=JD1kow$;
ztr}h@(0?nl(~0@rUV3xFh{NQM^{Gb_2eYlX8j=FL$^6b;WTCANo?9I#aV^4{-diba
zsX63=hC5aNbbD5>sWI>l&2o;}-CIkA+^Y`2Y;^q3O|AJbO!wLi8wT5N8j`}%L$h6%
z9Ww%WyT0|k{dHBTHpq_2T@tyu>X#+uw6p|Mae<F?{H&LIBF)rNQo^n#bR`2*8cTI{
znd2O&FiM^D^py(NlZm`#%6Ckp%`UeuTt@L#i%yjnN8HSY2y%WnI*i7Oe?y1_$SLr1
zKg6A;LN1=w!_^Mu`X2AlDmg;Tl`!czTtuN%<F(t=dykD&qSAj_4>O-2l_X~QHsvvD
zL5AcOm<sOt^^9d@i~5B<1)hOPA^|DibwfGA^(F*1nfL)FV%=}nZ&yhC2CL8-LJm>E
zX75zD=c{OV3+@Hs9RCP?NODZwE2eZ!ZM9PohOr@6aroV0EVSAIav<!jN1~0_pYITh
z265`~zuizeIll72(FQ_!FWjzcujy#L;T_Dz0wa8%)J!j5&F@2kY6t7@4|_c?VJ2E9
z6$@-SO#~`!&S=3lESfBZt3yV`q(Z=An#++5x-Y(&ZY*iN1QA{nLbxB+@!=d0<{9tI
zt#{S4&mM6C=ao~?NY_%EMu;xc5%)Ser@0$<N@+*D6+*tmqKU}wr&}HXoPJ{a#mW}8
z3*AKFlROUO>tmitNL5|khQbXVjcU#vwU=lhT(I1~q0{v1D~Pd4+(0OaDL2>VZy*F9
zwi6pL`!!$(IK#Llg5bpei#|m8SIOJMwZEH{R0Uu#M!3Lo^8s2~HKq1`|CC+UXLQQw
zdp`-8ZFuRF%owDb3G0VLdlAI+BZxzXcL}nz)pcqZyAVH$8c8*bc^;-~!&AKI8k4Y?
z^O&7HpQMjuQ4|nZ-M5AlhZ)9u)G*fvk?}_Lq?i|LfM~`4y6};~pWue7OHEwZ#r9?>
z|B954U*^j9bF6ZmWME}w?K0C3==OI!`TkacOhBGePn`8ZR|P@VtuQ9?^g*Q{4sXK%
z(-g--ikhq9p8aDn4goZDy2~7|u8Oa=;7*P%IEP+UavVcO+?f5W=Y8&D42GeAbi<e^
z@s|4@4K&OziNRDx|3-~gUdyo>88(pzB?Sr2^bj2IyTJYw?o<Oo2DskSyqD?DI@9*`
zxBzdN(B;pOzjUFfZGH}LHHb}yS_HXC+tds;yYlUAH>L3bqWbWO#AoYVwan^{yl;$*
za~VQ8w|ciCIu+Fn(6mBvYxk8CU?oHmC;~-EEL^mIW48R+5VsF&I9yC|fL0;j;h;kP
z*SqPUcc3*hNlFT*;I*UshO{`b#6+6csr%gTQYqxE@9(|itlI@X=!Dpgh}O(b-Mo_W
zz@g2UJKqK<2eZ^iAIPeTsXbe!mue7C+GdKWdpl$7xHLGEKs|HR@50wUA(YFEUFvDg
zPhD*bH5+Pm1}1U-kJMs`w;?Zqv!&n1(E$-_Tz$c9{KwdFYQmmwK3VbpOM}u!aR-RY
z<C~Z3q|5BUa0{7kRKD3(eR87N35RhO)*oT19(A;K6v^9Uozy6oqaX981>bQhk<RQC
z4c)E%F-?ozmgz4ga~%D*Z|v9jopBvRW>7Y+(hDV-V8F)#TCx4hDLoT#BXQ7*y>e8e
z`@cgFmy4C)mUYFQi-Q#$_L;E;WL*#7>6|OtZL)6eZ^<II@cKk1=bLE;zQd;aDXI=H
zc)G^!pJRFUCA0GwXv_#a>xVlWb8>wQPuu>CO0xYy5zp6iU#(%DK4zS5+kd<PtflF%
z%{N7<m}dWcuvFvkSx{hXPkpNkWhe=yP^~>*)Rlz@d-{DvB=MR_lXb}0VbfEIXC!SJ
zTv@x{Wf`|C?}~4_TTtt2@n845B;f#->Nh{g*giFb%m|Oax)IQ>s_%>`sY0lxWIY#*
zoW?>_{=j1Zq+i-AqnId@i`Mj(iN*2gDkdEKN2HH@zJrss$-KJOg;S<nVmk!$Vbn0g
zMG@*HU)fa4bf2jPmp82dt`3*;b+~?<;VL?(@*1!l4Ek^Jw+P}0(-YsvFKU^wR7Wxi
zy`Ja$mCGUg0B)bj0rJXWgXMrcY%Q*{``lNz5q*2~bwFN9y{g;D50neG93H9He4*uP
z3h9ZK0JV$~4RF6OOaR^lX?g0~&>JfMuNNSuLmFQl+YnBUJ$sFU5R`fqz|L5$t|fFc
zOQP32$-p+9Z0P+M)*PW7^UMo}sXyZju>xs-B25ny@8vXY-fdbr?SooX$;5rc6FVNj
z#y&%D&^qQ2)JRr3av)m<X<um>81Z=;a>-B9fgC+A&Qoi4gW$!;0^Sy7?Sd3%%j4os
zH&fCwlak+xD}`#fzTGcn2u#`*fHm3)Ei}@TA*8G=KVJZ$(+)?Yejer@c19RJIP>lN
z2)*(x0eyE&>HQZRX&~xo(^{7>DRPCJPJsup{ZDj{w*<j*lhJQ!dyw00vPVfJFFmln
zkU9iqt4_RAhaH*2jyM|XwK3()u4!fSZ#jtPE{Nx(A_C@|3$RkMd=+lAVu^^i{;F+0
zR<m!j^RD7B3wTOe`s>R-E-B_-{lw4IA4jkS<1+*_-MQv_59B2Rx7RWtcyqQMd%k=V
zA0`-_#)upZ4J5aoG!zCC&uubi#(^K<=L2u9Afw;hM#fJ>Qw(XWA*Br)0YJ+i4VnjJ
zY6dn18nn?!+W=|c<%}5NdZARii`tzdR<@5nY(QuOT_aeA4LnL6Q)(e&19|5d6OFPc
zZSaAkT^YjDe?o42SrLGc($}Jh?R&p`GYFq;dJZAus186tD@LM7c9s$yIcHWMcxd)K
z9alooob^6@s<jeP9$tIImvv1pnT<WSdWeM=I1=b=@kf&nXwq22p+fF^YH33zTrdOZ
zJ4lz?ZA+eR2JZ1;yB-$O48vXVso$6-{VgD`PhmWYP?$wNL{U7aF-}oolliG{>U8ND
zoX*{bui{`AXTl91WOqX}*4%T_IFX*P%EHzNBE*m}mqwy)`D;;s@LJ~ZODjdA{(wIj
zy$Tr!;Q-I~h!!keeD)tnj<ZV2p%|h-%2%WO`m->o0c8FM`f`vqr$-dCxIS05B!jXa
zk+Ywp-<T2eiVoK}F521FLu?An^QeZuXMNu_;c(0iCJU!7HkqLG+OsfgTpYeraQsyq
zih(JN8=fUB9zt{UBMVnnS%5~iWn>{J-j~#$LI%Tu?!g~I_W|1UM+K2Iu;a!SN*-Yc
zq<2p}st<i)BETvHBd}VYG^8b|g3-+kni}%C{d*0R%%Y*Kwo+$fBNYBE@=&*2Z@=D3
z)Voozp11t)0sLBJacwGQdNQM^_)^2Aa}3OJ&&lLF0fatN9e*kZoh5lG^hAm(7eR=s
z5G8W<;bRNXKEdaK&iR=&S&J@0%GDRr>Dq$8#Y>{cVq7Ltm2)8HnVqdO`)yafHoi7f
zWo<VSgQnHRh6J77BLLnxOJ4BV*MkP4oryyQRrS43XD2wOV~yg5*)e!;c6cd-Zt9Wj
zi6?eQ90;s6CQ2S^DQGwH5Eu$g(|}KjP={#11Gg{%6lYW?F$*%`2g+dsNw9&GZuLc7
zFayu{6oO}2gQ1SD@mf<Uc1IXgTuS_*wVF!$<Mn@wLTC=&sSyYUIQvBr1jisDkSnP9
z9OJ4@12LBBCHTKI$4R0&yQJ){WSKlz1yz$C4`0Yy*)w|(P@cfYF%3|hGe{3X|A1T_
z-G5CKj^*Y7jNgpTyUFCN7^eAzU~un3F%-@e@@p!-Q8!9+zDQYl8<#+lTsI!>aSp6p
zaz~ymjnerY{*FT>j!SMR<^dS`6Ctf#hd745(D$y{S&W^iM^y|Vu^lh&aRCn_ctFje
zR9CYAo3r4oBCojS8K#1sywL1NfVMvu31?PRRRw+g@*_n16a)ZiErDwBva2*Ap6HAM
zzn;xNjtIj4h4D@(#K9ZD70)08z4!W}E^_N9SV21FNI^874(ZX?-llC#P+=$o8LH&>
zNaBe{J}jULtP&D8Kv-mqA+Un;^}BBl!{PAnhpV@^gr?)1c4;d9KRh%7L8PTEjAFvF
zAth%kQ-`d$J^-OZl~xV<0CQu6%ZJ|Xw?J#T=*RsCM;b_nW0|TS9`g=@G8TA2<$A!V
zf7K@@V9LGSatv^f;GSP}?KwGMjyu%cC`Vg|N%bc(#spZY6B1pX>g_LpOb#^w5zgls
zYI{(Q_BZsIoOj;@f;|heO=w2;PSq`!zwvV7JprKg4$oT;m|BEDz%#yZEXja@!P>i_
zl-%%j0tlOKL7ZOkv|E1qpHxkd#v&J$xfn_sgM43RhWG(l-9xV~0)T)ac^nxaKize>
zQB@Eg*N|3s_7mg_R%1hkJYHLJzEE1wwxKi+yGc^Duk?CbhRto40t8EN+H;YfNU9GN
z9i>%-_iR3@c~JWM`xl41u_78X=u}p|SlQDO33T~f>L&5pZ$AJb2d6!fBL$+6&w)?)
zt4ik=fm>2AGu80H4o+Q_N!9s6(LxJ{`e;y%9>J-2ILyt@_j_+Xk{2~BCJ6qT_3}rW
zrduG!Ry;dQpuEUG0dsWQxT?tMwUfRaLM-tJ{o1Sdxx6HjiDIyu&X8<W@sDyAI|ClZ
zsUEBUGSUjBOvK0<X7O?7iAY^cN}w2g7zGXuGBCz(1BNFo!O9*~nv5gi$OFJn?kaLY
z>$wG~Gw@6l!=b4r6PGVmOJMj^epynTxDM9m7w872{IeD$7TyMb76Qhaj+Vt@3=^>p
z*L{UvtZ=v%kYB@d=l5D+)zWov&+JGZ{8jUO&W)SH8X$bXl-4ONdMx+kt4h>Q7|zjW
z#ubOV9z@hUrRqUxAzw^@ll2#4qfg}XM+!hrU3CkYW=T>C@%GZ>fwVg?=R_p^tLgA5
z)l0H-OO*~x6q<5o2USwg_sgK~ho_xlR8UMvQaf7q%F8#o(zK&xPkyxkS_a+#uqP<C
z<B2sK&rF|O!-FzAS@JOlNG&F^vtB#71<^C^vWn<mmp)h)VVIKxBj*|GBa8z7!{02<
zo82?XjmyoHtFv&T!&~L349g>U5F$TE&l!(uy({_N>aYoWh5V6EP{^oIMP3}G5Q=+F
zUPD!W2buVxZ#1qApd^py?zfiw;KVx5KQ*|BmQj|5Wdi@o6xb+`DSkGD1X<fa)8J)<
zhaG3^=*s2w4fe=<J^wU59m}{S$a<_^bZ?CY@V5=jL6HB~Nghn&+`kon)_(PRiK?|b
zRZZ4?3CJyTVoC@XfH8oI#~O%gw7OD0FVrZY8^Xf(J+}iV7<qVs2-q9*2$Ja{znoFg
zP^m`Fs6T`R7cx(P>L^&jivg@Q2{gsYNlf_j(Ey=_0mR|2024xP0fkxNE^J{uJTuoZ
z&f!Up7`^)@No}5G2bW)g6#~E#E<su|!N*@U-KXO?WIK;AC}t+>mRo<b_Ej>yd;mNr
zHN5<J1PO0Y#<%h+vQhcXG!^us8~>&CdIHHT;YHyAWK~g6S8<EpyD`*;IbUBa>Ym*T
zB3sosp4oW^#JW+7XWY83RC+)Eeq|4)4D@-EoHuV$9GBjL5?(-gWKd%q%l#y>%mb8(
zPTjnALS!Qui@F9Ov0p*HB6`q50O2eKfN@;?Dv~X2<osky;gS!)Z`RO3mRH4?abGoL
zR$5}g6}Zlf!^ZLBWl$pXS55JWRkNXZn*f=4OPl*fkj$38>6tydN9h}+%w*x3Q3(xy
zFK^=FZX^Whx4^|6_S#(UF14O;G(Lym?|$ud<WbB^aD=+I^FJ-Au#hxF^pFI4sJ*o}
z?68X>S9<4%06jDiBn41<?WJ`*E4H`B5z?w_@>Pc5T8sn0n9CB!mk>;lBeT#4g;TNr
z4v1EoramDI0!H@A_cn8Jxx9^ScK~d1#`nP#HG#*p#&`Zlwn8D6Vbs_>ZG@hX;Wr1z
zK5Ut^%|*&yQN~<?Fw}I2P>n1U7_<+mr5ZHsnKeObn)$C5z^0yb+CoT;vEVo@^%zTy
z6@VhB*M$3bx3!Tw$Z)*1K+sr(jm7i67|F#OKeB<^|9kr_323n>PQ{+2aZWz_*mg;#
zo1Mub^1a)=o9EAM)5Sk1>JIXED;yE2$vV^Tewfwt0vw$7i^_aGavT}Amww;ifv&y6
z1qVK{J*rMno4l=G$qd;)v_~l8)R?ggy|bDBmJ2$t3ZfD54tTAL0%#Z@KaP+aNgt#F
z=YCk>iv$rVqY%ICzL#1%otpJ%Cd|~eOKxjSN~%Ahk~YaW4KXFkG&t}ek6)$(?I}Gc
zV?u@petY0(lIJDQC|F=GP{Wj|xP+sGC_E35mGmPJJ>7l~pok1`=x5)zrV#Ro4<v|5
zkgA7Z0XUYtBSKW6KJ8kJnyd+22%@s$VU9HdBoT`{HCzc6IgDw?;LZ9kgsU<hbm>*(
zBll9;E77W95Ud1(1bv=d0wS^%0R9TjArPUU4Y}@-=b0MJu+N&uoO#;OX1_MT2o$}P
zlko%v4tK^XG}T&+c4-(r2!nX0u__N?uxqc~+_{l}LNyHJ{q(QCZvo($3-8;<K*GpL
z?F-jqQ+H`&+<j_o!izr;N&{Iw%??W-B$PXFP%CBx19&WEZBK;GW~osoNRui#xWPiW
zj6*^{bb}EW+&5PoN>E(~%%Cc(?4>bi5rS)8y6_sqEo2a6Y``c6%bs5Nn5I2=e(GwS
zJIFs5yvFT_){Q`K^A_7dx~Rfs=_*9W;Y^ewl*e5f&6od(CnpDG0!fwFQ%I_m<(%G4
zzMupwI@fh7MG{QoM^Q}qN6i;Pl5bYNwCI=6bzdY<Yzx1F#n46@q3DI9Ggd$;bOa;&
zkHZMK<O;gGO|`Fo^0QP#kucF?!4Z0qvn&7_k;(r^L(b0y+dSJKTl^JF{}Ry)g#psL
zA*G^%*C%Nv`)$A{fR6s1o`|X1fpLTTcE3sC1*V)=TBvv-0RpMR;Vld=w2i+B!Q6p*
z+#u#`3DpS5JzB_AFc6o;@%tL9UL%%4_$cQ-SKPi$2LK<(e5Uc;%L)6wP~U+KcT(Ao
zT>2w@J)_?5D4#IKmS~6`A*{M+1mV5a+TAZ!XJN(Q$rD(o5D*16f09))0OBQa>5*r!
z2g}ffKXiFR5{rcysKzA$t<y&)T!t%igiTRIvj;1_B#<Ev7#9Cn{Z>A2W7nz^plbf;
z-x=jlm?smlt-m$lCi9YAjx2jjC-4}OTMGmj{~zZ47hGPe1Fh-A&f|vV7^6J+FtgWJ
z{K`;l69<@$aQBlaSVOoug)h7HmRt2cY!&En0kp$kM<oQX!lsB(8Zum0P<G^xi4|)J
zA@>MHTji);^|a|<aHAZY4Y=I4I>{*W(DswbG@SiXP)4cR_0~yD>EZl2e)$R7IhXWu
za&eGkphgZYE!^S8IWZb<eGOfZMG_)t0T$eAK7Js6Z4aCITW%;Qt&fmIE&ctDv2mxM
zg#8ekoSwW|2NpX=jVFL?@F@HPa$e&w88B!-m@Iurhu}(DYP|EfOUhQx0I9G>muw8H
z9ZG(p!5rYopH%TWXTn23EujZm%b=5_ofS!~ThArT;*tP$IWuvdyC&^__GANW=r4CW
zg#r|?(?vvS^QAY_a+})Kf_?P(L%_(tuGqg@Xm0mtCkX2<y}LJV0+k!J!N**!1CrFV
z=!W_y0ZCqfy$NU9X&eRrPDt5UbD=GaW2B1VYg`jY32kE<6gp;ZkGmAU7WfcC9$5s&
z7i>D>CaJ_kX8b#LUYD8u(t8gmU6U{-hp9TB17k1Dlm(Q@dAJ&LPyz;mos4_Fu?JG`
z`-ZO}_c)5${#JU%yphcjIN}x0L^Wy%an2X-rE);!kzj&W!P?ZIzJMA{uGiXxdg6Db
z)boH~@v%k6X_Fv~gAO^TNvfC=BihFA$K^Ij*hI7#fa^wI{+1ldq>(5DIV0#zg0Gny
zx+4YHAefB*Xg#hHn(X*T(?wc@^XHlbZ+hb3^<~Dc3|ck5*TXxF6(Wot>=vCbNkp*V
z*&2$<S6Zv(W}>(v_;<sqC=gchT3AQTp<*=Hf*e_fc%C^GbfFU5?tyo7umM$<{*`;R
zZU9Wi$R9E%pMg~mWwR{pB~hRo^unX`TPW;|q-#_bU674MQc^!|%jSfoqdZ?D(lrf}
zZ`St=c-dbHx(k8leNkeBvn6G#jzHUp7i9=oP7JHE_MC_Zz!D6ZjXwmnXn;6xyn4;R
zV{zn9jfe`rYSCeRpY#2t3y_s~(&Xr}6Sj91%na?sM>YJsDvpx#ImHNJn;XqB?)xqy
z{qbw)8YL28`l7$?0@c01_RPKugw(klxH%FRA)_)Wg0++Z&?F^_Aj+~8Zhn3&fB@Ga
zX*xJ7+cH5Oq*T2wNbJj2?4dW_i9`<Q!brT_>qlFdaBLT6&ca_N2B0KgQh({8C8JH{
zRr*9Y&T*9UL#O*o@vqNaHJH;YE|<8rY9koTp%GyeKX+?Fzq8hOYwA%Eca74SrhM?H
zS|I7ZA2(|R1Ku6*Lvg;U+WH6qnM}w<nKwSrglsFgRN{=+k`(F(1a5v!UDPEx(=2tj
z+&pBG=3HnPyDz?hH~)Npned0=%qlM64B!yIfqEsTPB2!z=8|RTydSc6XY4>lQTPu!
zsp0j)i6+WG+kSnEYH$%ioUcg3@9Rp9nVsr*pFL3QJO2EHwz)#Sb6O1ZYbRs3?vfwZ
zYChUFx^ho~aO*;zPORqv7W2&VFrVj<yw>EVkd3wNUaK@1I`Mll+9(>TDpB5R-g3~H
z-1F4<4s^Det*$Z2YGX~wNOmI3lH=A;$K4LpEf*7FO53cP+m|aRQ|zj9Yez9rSLP*f
z!OMvTQ@&J~`J92a($syyB8VX~;iDoYWa4N)i?y9VYK0}v+pOMme9mlX<jE#>Sm|LA
zH^%k_VJ=Wl>3|Z5`m+HVx;&3rX=Xh0TG}YYpHw#^&OaoGMReK)?N#Bfw`RcaIdfQi
z5!$|bjwF?zm9499QG#AvxjF@zmkB>AP&Y4r4B8QRJy#WYDz|UI|Dxu(1#=)<d}C{j
z;ArdogozSk=1vb?9jp=$5r<&g6KqRv*R)0B2^GNx;f`2ms`P5!`cmo7LH>$a&+-2L
zOGi|eA#^267Eg@b(hZ#xT{n&C-(P%3xFM-BPwCE37AQEzR{|~P$e92FrVre^^gpdL
zhZ&ndh0t%IvIp1=KL)+4gN3$-UO@6mwhk)VY28W8va;eC(uGF&k^{Sy+i~Jt68pl6
zF;%DfLQ^i*C>o_1qac65*fRV~iP2pH?!zaQBhYvH6~T8xs|8AjmU<L2D{i-Y2SdwC
zvDrJ9Nyy@s1YbfOaevG#KKkZAVrTy&_M5!BTG#8V*MWGPHSe=@g1I7@vCK!%h1=c`
zKA&SP${Ct<*kC{EjUW5~Q795_)b112@68PbN=Im>EizMc1o1~Xe!!{$04{nQu|a+h
zP9tW!iYp~3oqk84p<eEc64~MOQC)E^$;n%OWX6)>f|W*Ohn*61KQEm?(h*_{o)Sd9
zu_HPkb;%blZt1B>E$iZV&ZI-bqT8Eo)SHIrcZK`4St<!Xhy&-q%?n>C%gv5^zSu<8
z&Q&9H`7wEjsbBzWSPD1RnU3w{dQFu7T#`hK8ols`P)lM`-^N8rC>`j(olU)6wLnBo
zRAPsnZM?H5fKw=eL&RzvIV+<Y-^R~L2ib>hLF$hSMec5DcOPcZ4KP#=7gjr12{g!d
zFUS`r2XztU=S-eFqr?YX)WHY4j(@imU~NmI^jUQ{+u%c?;8=yC%o>?od(T6ty4w-`
z#uW4bHQ_+FP;*E<Bg$V|AE(eTAd6vubb;fYUOTcET>xgXuhI!O44DT^T_muwLjCNr
zcr3X)m%!m$WrtM)@(w>GQ@z+O>SEonveC-RGP?=2=bQ4?u4f|yka%dITM&Q6Lj+pK
z5J{o)C=@yfi&6#5x`cLyk}x%#_Axz6Q9Q32vRKk^E1(1#>EG1;Xvo%uhx9^jlahp2
zWnRjNC!X%wCA(*ofD@0M)_OZkfmJ9uPD9NfHQvwNno~dJp-cr8%cV5|-nTU8YCTvG
zYtu>AY;7Kgd`Rg^Lm3eK5?NIAH*l$_v;F@PJq@z8v)wqyPKpzz;$%OgAyML32EDfz
zvYv#yT7-4?xT@oAA0Ff>ww7oZAb5_oVl9CwEd*}n^}Sz~_ZG0PXwVC4IeDUnZ!F`^
zLcc0m)R_8R%H+#XBc4T76xB1EU}w%j|7J{zbncF3o-<2AuQ7gVD)tpQ8K_X$)`c$!
zvFVJ~Z{6>|+G6~1=_c}9X=-?LTT;tgKpv)fwa_yzx45}B*kiB|NCj;;F11}zT3>g)
z&`$qB$=2=bs-CX1YewRStG-jP<LbLQYwV0Y#8AYV%T{bU7N6|I4IHK{AI0uOv{4u`
zCi}fn#?ml+SpwDCp`wX9PlEl>XU80E;KDLxE=P{<v}m#}19ywP=nVCTy34hpBdu9n
z0lu5AZ<PuU5a%bnj&_~bNjH&5<dx<uBd=L@Ro?x(r(W@JX}FbefOGk9WAM$SVYegb
zG!bnGGyo`DnH(k1(mJl1N*t5gQacZQVIYo*%8hCW4Q}U?+7M8<O~j;yeB<VIT*6sg
zLrA6r{F%#VT>q{6IK4jT1*oTqGNCsS4QS;I*e}3aYUk0OM1|1|)!gq@s3UT11-llx
zex&nGe-TDW7(*Gh<i)?Xgq0OF9m6+EdTp%8A$7MCse&66vyPwdZ4Xdmt{Y^fXFoMv
z$=dCj2(<)Ou^m>&hE}8>i;HRT3_H@kW>$$di9FNIS4xw@c}ZuG63a*x8O^JIVEq`%
zFrgXk1f_=~nO$ZccEY>HTn11(eT`BNRJtJSD+DOQniyfs&@XOz&?ap2KWj*}qa*{m
zN^%WTy^&rKrHCX(5{wM=BHBH&3V<FQlmZ?!4}j`?fV!+iL;cidlAg_lq~96tQ&KzI
z*Ap?!iM~^qYOW>aEk*dogbCRpmA0v!b7|i%W{xj*rJ~%kak>Q8JIPi1Xx@#Vj$}CK
zAxM9x{HdXDXvJ~HTNcqB^?RJgV%WeG6xzCL53;$DdKF2TTn5HdF&C&5=r?_~E4!_X
ztCb3?p@CHCXgp=Fz?N{I$ZYB_LyVtj$p6uM`&llt%HeYf)PVwHAKhdo>pCg5$8a2w
zGW&?kDP+2O1VkPr_@(!dMYN(iZPijM(I^SpibFZxb+uRiF5TDMJf&jC1g)+RaAj;s
zQDPx4Scv<DJ_<va5%Eno$ev&Q`qotJ@%rnFUgDPTJ#+i|_}(+~)Lo4^;2tMLlwUR3
z9=Ibn$Bbo<)QI-FFvk4co-B*sT{u!?xX~@OlKOa~QzP((WdsvU&N-*=LHtfUXalX_
zYTJBLLB7IUiqAZkB2P)E0Bay#Xoyf}Zsm~j6oZ>O>z};6AU3x7zHU?qSqucH!Nnu+
z;=W=Wz(tk_0qPyNZU>F5Dcx?u!}5hGhT^PrX8X;&)vfEo=WD&nzH0Je#;i0vx3U>R
zH!s^fG@U#>$)_IR>ZB~p$$Xfb4ZV(vZ~6ws21u1cRd%Iq#sEBqzd!T_dTtOy8>{o6
zH5RS_h?N9!TmX0pZjk6S(PttPr1%y#WC{*VlnG5IGQVqlMr&Kvd$i_9p+Cn+x23lv
zpWecBLua|rTKH7wzg~bz2A!m}GAl!@#_FQducEGLW}f%V8~5wNt+r{23vU;~n{HgD
zVqlXM_mmVCnRWM3%eXh&u67wU$kYfVNG;bwt8T6)Wyhw{zZ-BgHP2%}=rL95b~^KA
zCZ3OyIRfvhw~PyiZf;t7**Y;mry-w+z5DC)>n|H3hASq;d52f`mM9UD%#fwPq|YE5
zg??y=_7FAv&ri)V(&K+W$%`l$`S-&q@$W<EHwp-n{rkappcKTvpa1<BP~v|{g2dtf
zTPeYB*Y<Bdyy}#;-oM?-zw7O<^t&+I?N|D^-H+Co?C0$k6>3NAZPSL{i&k*IIO*JP
z-u%6<d9Q-wP#@FF{_nLFk%N=1<wr_&hTHCx`Y6VW<(Qmq>$z*6{xG=mV1{onb!Du}
zQ?<S@-9DzLk+HO~OPlxti9<J6uN}R)%8}>_SGNbBA}#!XfByGZ|ETf5l=xpt{I7P9
zWZ-{Q;s2Mau=(EQ-@ZSY%QNn0qaNt8i!(2NYet48D~5?A>aVpw&oi{QjNaP36=&W)
z9=Zz#JSz;l8gz80a1rK?IWl6eKDRIS4s7<h93U-ad~b8prFt`V<_MO2hJDo{#kA%&
zkCp1MSqNJzTf()t>&264DYF=Mn=L#@;PY2&oBTStvw4Mr^n~vF^m8!GQdn`=^<@rW
zPVI51=-027BR6G-a)T5bO;SvYKAmecNoS?S-H^4x2LDSV?4(|EiI6)qU{YcF`-j-n
z_7GoH?X2nD{Cpqpt$Swc>$65%pSr6qFU+PI-EkLRWNP3}@klRTVDa$#EH75wue$i|
z(G0(#$m*JY(&kosRjqVw)mlEwIt>~1%@J#x=nJ0txNx8CrJ0Kt6WoKJQ<qMg-8@}s
z8hP5$W}Vm0JI?%9*m~TxwWgxgx%18J&6D}cG}Vg4YCrk+Jwj4?7p6upcRWw4wTfcu
zD)c!WVi_g`aV!4jQuOH%4S9DV7LnGXH-?>z?XA44v$j6ZX*LVE2X2P-4X{O;vrHar
zUdZY+(--pg;T4SRc*7=pCi;m9QK|ld(0;2hd4~3N-et>9?d{Qmj~&Zv_Z%nPL(^}*
z)-yWa?6_j^pBOXSnr1;G>yP#Fuz`~5tclo{yljb5yr+Y6VvdB>%?;nYuQ$S;(=F1`
zJZ8?PbuHe5pmCL=ap<xv`AY)v6D2#>YCcW;4i{=Yhm8>G-^)+p$}@KTI68Q_zK&ep
z&0@=Qu01(hVjF}f=f~s*74^Eyg~@>>rY8E@t-i?XZo!h>pKcNR8h*dIa4gTJLuPSe
z`Fz#DGE)P6yO)RZd+Xpwo8`fYMm5)e`bd}O4j3+YG4F>Z+}Cn>z1*fRgnV-Bqrxk9
zD-FB4#F<l7QCRI2Jdlvx|E}COF^x%HOrFu`+C|l;&jj=DS7X?D-p9mivMJVw!UcAQ
zF)O&m)Xl{j8k+eWZIR_JWj{WhT^edr?kCU4qCS*=SncueOYD`8Y~swb<ageU)p^R{
zC~nhp@BNafl)>oDPNjW)TA%rvUwRDRY2NU7S~q7VPj&M8t-1P&Vt-A>K=%HdJR!B0
z4mSGf7O~{=6K3YG^_6CH3og@fdr$97&d6yu(Pm%aaP-KI&arS!*fH;%BxWRA%rUS^
zGX$hD0BQB`8<Op$SO{P4x4P^7{AZu;Ufv<CFbkFHB@{>Q`d;9z{flG2haVXxt)VW+
z`JeE$VOMw`D=%ffBV?RK{B2%F%6RQSn201lMF57qGCbI*cCgV|-spqM(%gfzcDB}V
z5#_Rm_wQbtttZM)PyhGK`NiR<X6w95S?RJNQ|?YGtV<1=)OY2_CC-Q)6?#m(S6p2d
zVA;if&@jLE=^_E7G-u6=*x|SmA3z)=Ce()nxEx;1X7*z%?bq0+H1Eamqly9_`7}V@
z$B5l=qopFAac$SbG{Pg_xLd+i%Sj%7pGq%nD-$2b^b$={*Z0b1YE{#yj8<I%({Q$6
z{qy>_?>em?6)}8d=OMnB0nW!n1N!FsQ!63$u9>U?e%UZmw+pNbi0I>hTiPtU&k@eD
z$2bJn>&421pW7757NIlRIeyi*%=lAAoO$-1X)(Lk;dOIqj~vdJN6EX~WM99`w*GY0
z{n-bVu#xLRTBi-t6N$GYR<~lBx95NE4g5j);>?(9%+41f>YZ}u)SQKkkyS!sfJ?Yx
z*mrq1Tb)e#{2ZMJU*uRvfe)$fLt5gwdYPNtUlw5U{zHyX_VGU51txf{{CfB4GNM+x
zdeifOar=||1`WEx7w>~uX!ej}uO63GF<)C#u+#b(S5(@N7*lt0kX`NLl#rO_=CsN2
zgP2~LO?}n%s+^`+i<@VDeQ_)n(iClD>Xqx{aUXpfu1J_az@Df7=FJ&`V=-%M^q!dn
z-^F>6hhA+fha<n+<y={&bI)<8!hH!my`0{5FU;^b4!7l_TqOzW#eF%q?k0zkmiCqF
zSgwZurnT2rWm}u~EZXwz$0pl(I4QRQmm{DvY*U|_=U>28K0$fC#4GpX&&mt#e2QVV
z#yg8G&zzy~wM#S2y2ZY8Xpi$iNsEMO^qMAY+{be3QS-|)pI=CRef6Qx^OIJ{^%9xr
z-E5&5H*q?qQf2R}qe3;sxn0gZZBt^6<9bGKWoVg}65z!VT3giOUfRkg$(qd`b^;`*
zM*a7fPcFRj`OFV>44gcwtDPcqJlIUv6kadAaIwBlTp!YUlOVC$<^tX(*}OxA`Q@#z
zURaI7_+y5au)Nb1k90hz*-y!9s*qtjT6y{|YPjd+?@fv~7b|NsJ*kUZr&-EKK7{F=
z)^%E+qFKti3O+}sql##8>4vD#<Ey;Qy-8Uz?_bHgQcHYxdY&=OUe)$Wzvx!@TMx!4
z`m<%8(d-gIO2d-htOa^bWIJ=5u5>$ar^vwntH?xA*<47M{kr^of=xxa`tFA3zjJEC
z%VxmyN$(x`T!;31-aPz{McB94CxQp)jmWSE=O~hlGQYiW;XBP#J(Qs!HheKKI;zrW
zI%`Ay_sKoy$O_C;*xt<OCf)gRzFA#9BP8Be<S46)4GZi!ws|MmtxSpC`Fj%-OV2-U
zv~{;E6rs5?@L&f!9L=zA_ao}wiH@?jDQ;m^nZ-t1DS7)FCVX{%X@#-RRHmkOmd)@V
z8!G=c4#qfgRZpegz0qZt@SY{{9T;YEd|<|UhDh~oyVl6Vj~tUe)Nwjwf5uIrWhVdq
zY*9WH)0(m!laJHN(!zzQPsfoZJx?oK?YXh~F!^b~1Ld6+WZ1jR0@m+YX;<Wnt)g0a
zmL($2mn{nFm~IC)$sQt{K6%$qzD_5d<?Lj(UJlO>dB#vt;qS4MTC(%Hgf-1hR(bDx
zx2rRq80*qLA8aoSwaI@G{k!n&ujkD|glE4-isv7vt;Y9@#iR`v28@k7jw%mXKFx$1
za&I~vcGlTwWUbBAk@2w9p|jqMrO_RM&e{Kmt+x(nx_iTir<f@5pjd#Q4$#pcNF$)&
z2&vH>BR9I!KoJy_(IDO3T_PwFlV-qxA>G|0-UH9`{GRXcec%11V;s&o_kHfTuIqdj
z;1Td*WdEo`b(6OQe-ln?6^(T3qnGQ>zIani1h+U>-k|#JDqEc3-jQy3b7LReovc7V
z*3&ERV|*Nu9H2ubi2W9lDIf2o)9L_h$A~*jk5l2`eOC=tn>hQ|%v-C%j&v1VZ#^BT
z-@g3F&jh=`)_T<h&1hF6ge@Xz+pfmU=P5o8->gL9DHg6at@2hlCz*QJlMIr%imCCC
z7&DVCCTH90?ptScsfRB`&-18S8n?$9VQj<U?ffchwQ80UL4!<B#6C{GSz<IIeY95U
zZ$+wy3>n+juvsyF5aQVvwqT-o`4yWAGCsP3i93lCTNDBf+L_uG-sSY47~XNy85h`g
zj7Gkk$%1>f>y~k`BXpV_a0?Zczkj#;Ofv-~1~@Qbh$daHwM5~)v={Mahi$)2mi@x{
z$%|#}KB>~aeX-nZ2+g~Bh0m*Nn&`vhKVj&{l>ZsS|5BdXx+bgD>{Vf2-L<cgKGtfR
zd!^7i%;tQ{Vv9=yBT3N8PG5Ct|DMS=@#CPMJ48L>OQri3eeUJ`HOIL&_O9GJC&|sc
zQaF0H(P!`N3Mcr__cY^i6ZMLtx|<m1Y;QNK3t47NO0!S9!zZLuOjoyZTlnR#b~4$a
zM#|dWZsIPWtwNd#(Nz64Z9XgP6`|MlS^OMI0=?1#xm@07K2tO0_BUY)?X?XQK`0rr
zss`ICG41hwXj0#I-jFK_mVXnlv`+Zgl$+;juJ$Q%k30pLwWtyt9mUxL?_rh2PF{)#
z$gDh2hqi+-%(z|1vNQS93w}{mj|F?UmRA|H(t0RroITa@=c2t3`At}mxE7LfTIBn3
zD)AAH^qV;J6VYV(5vmTS(&k(}uXcYet}<O?P;_08+Q+AMyErd5valWclLN!=Z5r1I
zTieJIy<{z+t0hwMY*-NW*{@Er^Y3iK_*RXr_vrfk9(abqka5vk-d*oaS%M)1(iz%Y
zGp2Jnttv~F@vREHQ80W?E7Ek(Ga8A<h^lgFAhXl$`@r|LX82a-c`F(9T!9mNSgpqI
z&}3$WI%<tSkV*<zg$?!NLjr%xz4;mZV`eEbC4#+0XjiE3ryO~L!aGKLlo+?ak6xr#
zHFR#dnkhI+bPA*6es4}4Y|lb8EjPBvj460S-QGhjTx&lEHQG@Djf;gx_iD2B(E908
z@2IfY(Za54mI(0rkMiwgDP62Tb|9R|;ohhTjWJ8}QRE74*b>(NmF?LKjwExlLVZs$
zePeb;6)E)#NqCcvf4x&e{lr?&il-ka6a*O#cj<X&32UdRcGjX)k29Sdt)P1KF0b+k
z7J4W*xoz)e7KRBw1Np;AvW$f7eU-WMq%w5wahqumD~+r>!e}EG8dQx?x?*!vvm`3Y
zXDE(@FMg1Tq;f<(zv@>K_P)5CDiM(^Cov0>f`@74j#Si)NW?;?U5iytn<zU-Vo#J~
zyB5tJmS1Llpwd;2R`x6V=#iBc)F`*S!pet*W~x%34m^DW?NO9XJIbWTOg)w=dyVXU
zQH-yHZt6-T+<og|lVwOE)VKeUuS`DX`r*C^;a)F$(~;vp=VA847T&5g+5hx7v`)jI
z4v`HKcv${N%SVCiW~d9<_nWagcoK->JIP9p*9WfANMjXjmR*`mloiqmzCSFTbS-+u
zww|BoxI|uYalCfBky^o|NFtsz0={UMdp1s;-oH;2onL+vcI-J@q-zYa$n>Bv2G3g)
zIOC6&n0S}+t4HXg|8S5b0(@ID&rT2@b+p-ZeD=ZN3R3xuwJApbCW~@q)*>Ab$kXp4
zHwEhm>MQ-xE1Z_aym$7=|GdjP&P^S6xhnr*22cg&`7J-I#Yc?KLKKS~&%@qVAsWp+
zSIrHhk$(2s&u;cz2PonbZjz|7Yw#PQyltlLszpUrC0b!?>QPG!hjQ-0zDSkJR-Ikv
zx@z9Gv8uBbp<Etzr3-(c#Xr#sE@;}~W8*1og2s@s#;iPvU9D0y!pxe+j5<WNmXuxo
zojEh{MG#d~oP;CAc?480QmskT$x~vzF22fccj)o6_pz4A=AQv3G2e!^Gxkf$A#z$L
zYe6w?`~0D**+N0(U;PC4d%YXvAQ7nFl@}C?x(tCNcQa<3<t;?Hpu(3n9;qs!`+p`R
zliY>8f<&EZ2W6WAHo<~YM(vUDTwk974}5-6OL-8+AuaZWxYLm3&pH&kq@tU%jeF=I
zGT<_d%J+XJQ~bHtFeDlDgQ3H*vQAw^#0=jksQY38JSO~2yhfRj_PB=n_r?0`=0q4@
z{l;ABWnATynadi{C$y;$=N+gXwUeATW1~Q=!}7v?Yj!in0ozf3TK4H+>R^eCQO<id
zbmJ@Ai_J5FhttC+g<gVjzfJz5&rEfV;NOqJ*u<$H;+r~aelwsV#ZM-qO8fLIWY>;?
z2s6QKYQ6w2!qnBWRcGe%oFy#xoQh#bTKAtV-)H!9KVtb*X&qO;1SCJPN>D&Ml_>C9
zf+lJ)i$yP7oxUZISWr8vXI|OlzF>ybXGzit5iCLX6c;Vo6&wa-XwP>#E2~@;ml@~B
zjO+<jZxhOzovV{~QifH|{esqc&sPj~@6>`a>xNNZOJ`Q18nUxK8I-FloOzenE|<&P
z+fM$s%92KZ_8YoG=5^8_X`0z*8-+W&j`ccM{?v>W=jRVSER5;B1;Qsr4-t#E8!(B=
zawz3#srXFGH<uX`R;u`c6^~^<_G`4?WGAj-Q{CgCQ*`omn&If8k;Qc%#}b8i?Di=A
z1z)9&!5H$GXR=JmLvi)RjN3}LLtY_cGKSMsm9)Y(ErZ@Jk@AM@-@lAm+VSz;6O-$+
ziLtU(SlT<9iAy4p5q<)f&AaflJKL-{od8Y>^*y!O9ElH?(-z8ckE?JybW&^*i_-Vv
zY=BXO$dC4L|MnHg_Ni@5VLAjBtH$PUyzn~DO7^3>@dY;Y#p0pIUoL_})|<Fgq&jnl
z3tOaHsk)myWOXshxC+^|`JFY_D|Sgl+k`GupQn<M?`nyOkt8ls6v+cOP~As#%5AN9
zHDfKKI4wnaoCYS>toFZL!JorZX4SAyhA+9ZMGshM5ALM&KO7#|7Qw@R<(losU`2jJ
z?JZZbmk+CIGZ|r<M4qds6e&1H1X$*$#>W5`WbK94U;|gP9NAf#pmLAeO@@*0hI}MM
z2%sE(a+T;3=Dq&y#0x`>U^$ftwTx2BKxVZ3%P7q<2TjvE5QrK1Wt}V4uUTKC8mH>~
zEb~XMYnFNF+J8pBJ9@3TUPq=37E%CRQw>H|(-1>5Gx|$KsY@)vQ|)8UDdBv(bhbNO
z%(O<VFtSN21$hjfmlls&_xW==dG8mYo_Ju7tz%ydC)HcPmLF+#c<ww4im5E~d7Yx(
z0a~KY7Tio-qwDjG%Sp&B>)i7(I(IB}+Ab9ye+4z+X$c5OK|$-C<ej&%kaLh%?_M~+
zO}kQx$bDTLg_gVk>StaDc$NU)W$j#p@EI>~gb@nR)n8>k_3YwZsS-XWgTJ#e{$#B1
z17(xJW%<LOWeT~L-NtnHo43PW-r|i%YCEZ7lD<(f&={+k7kV{w<#1r8-)-jo9G3i(
z^{Z$kX8BPNY&1fBSjAB~q(dHBdx4>8J|twPidT`|h-w;qTV=gN+t~X79|_@(lg*y$
zN^#h6fxPN7xZtboCqJL1HSuxlsR32<gdmBXVGs=ja_<A}(A{3@XMrG<A=DNr9ahYW
z7uOfU6ZL<wxl~dsfA5ZoY`PE*bvD`W{gq^)>SbBX<^^*!&0GV113U4X2f%NF{d^k@
z8;Kq<G2!p)TMB+N2w$3xeP^hB&rQRO@*ZbMa7<0QhUMNalbu4>qfAM>(x4R-o_{9t
zw3o}jBmgh@)R~?6{%(9WB~jtS3?R8@)BdL~4F!b;3A~v+2BB5@lbOfW!b(}4mQjRT
zj5s~R1E**APSf1x+2Gl@c^{I{MvFPiIJe05c2}JHntaA~RdjgPdX>TQ4^+f5x<|wr
z2G;UC-m(z*OOe8ONWkS}Rk`h7ShGR?SX0fg=HYD-ar0}U<f=N=HlAwXn-tTU0$Vo{
zY4EM3iFAHZqqel{wZ*?`pAUTfRit~AcHA>8i{JL+^Eyr+k4xHWcL+iA8f8wp^mDYL
zd@bK;y|#ClpraF8l1ei85GKumze};T+o9m)r{u2~u|c*a3|fqlQ1A7pe#{QB-VVz`
z*CCMB4+w;0A)TCT2*2p!iyvKA1`kK8Ni!sLf4q$XXXY<~60+$#THjx%(6yCm!)f#L
z=Zm^^4YQI5$(v?wpvf6UO3ZI&GQwd1HwbUCgU+$|Vb`HS%`BeY1KW>cE}yMT5&7sG
ztks>absw{-?zaubu!)G>G|cj|5kygi4R+8B#ASmwDJ0#*44Af^Tl^RI8=PP4Fw_)3
zjPxMI6MqdC1uls^x2)99uSlN_)#(mL;?ZHQQYqb55CGKOHIdN!&?ne-Yh=MnD|Tz)
zUoF5u{esY^C-bcYEz%8_D3L=o(1GoolyVweZjaYaI)T*4hD?xr;ua%RuZ*-8jWGC6
zl+>Lx1#}Vf!nxVNim=9NM0|Abb<*f!wraSNS-9#J`r@Vs(_AvO24)~mAg|1;m2a+3
zDtjL>+rDK$uq&=<=bkW)88!^@Y7Ub_Re0*@t<|kzmh5J`J)+qQYxPA-h5a1bI%p!B
z_SDAWl4xkN|EiXocYU3Ld+J-U=|0=1gf9KFqfuXb1N9D}e($JOQW$`XPj>=Wc1m~F
zNKVRd#emHBM%A8)P&AX>@Vizz9=|e=t9M8s42*Wd2(AIt#N*I;8(G^-iQedQBsFR#
zgY4xNCj0eEUS&&llEDFt{^)1nOF2xJ9BUNLqe1daQSp;^hp8_KM;ywqHZ$dARmy1$
z%8m2q-@8yzTRbrT>tyC4cPr%|gxs<s(t+T3<v9puRR*T`g7&osbG(!Y_uP(c*IA)+
zENK4?w8Y|*dvTx*FyKvz7w$~(X+Dj;)Ggjpb<k9%xm2tUONUnj0~G}FvQJK1duj_4
zC5ea2b0wUa9_=q%M=Y;)m7$;D9evQ@)IqdQSXB3la%qX7vi2s{gVvxOENq+^Ujh+K
zh}~Z#Eq7_X^CshXp>k69-b<=x7ANl~4TbheP_MYAwKL5PVjCkuMW{F-&k{7AZTZny
zLwn*<(^ezsyPH6nzq#1F8m@2SvDG!2Tgni^Y119fPk=TZt)G-G-ZCd5j4_3~@+aNE
z(?@AWit`2Vg@_KG`i<ZT(|7>crq8oL4BpAp4*j+aNaPCg7kkUccx#NhEF>m~j^$Q0
zlr5D!et}Mws$LZY;!;?dY`jso-n({QL*OXGX~FQ(B1@|jUUiiYI{eCuXl6Uw;16n#
zaFz`ejIpb~zgL3*91Pzr3ByrJQUcHSjgr)!feU~j3~jOuMJqI+R1PMHhyChjuB@%l
zjk^I^h+3P;gs#ZJY{Y4y6$(ncU*4H=nHjXb+v2_4ZSv#@gjX!HU5%{$6^Ox)t8_zg
zAQU&6lA|-T2K4aZOZE{Iye+I{s-MfXBU!_NtLQTqp=LJaiq3k$%s~%^tZ%A7$bERh
zHk1mB<3-a(&Fl!${mO04K*$9hN<3d*I1~1sMQNI!byQQBr`b@$OT+aeh+E6+iPJ=a
z^SUz)0hbEmR%v?^rM4ulgL#gZ;U3cr@NF-@g3zV4PM1qBCFJfnak+8S$mHLP1N(2V
zl|p}Pyui$V2BM|~Ek6@hf+cyFhH09>#85!J*yn8EwDDgcS0EaHmB~8A3#jFhMzulM
zFN?B;Hm#K{VzBHc@hDeK>%lx`;v}8{WN|F*e(1A!%j92$hcxlj^7gZmZ5>q)3w_L{
zhhNHCkE*N@5BlV8FrF!cI?%Q<@pA+<j>kT4wabXlEW#I?yMu~HtNs|Twie+L@UkHG
zI=B6y0Y;C6+k<M9Y7wpQ9i`oEg&(g4{T0>U7U|eu;yr=nPV0|wX*oK+xfZX%#?Hmo
zTKiU~2eopqfI+@8+sUaiLY}7czg(V`2~+n^!KqSemI<+jw4<4{2G!WDbdh}F(7IrB
z(%i&_eZ>6!o-2<E)|vpK*XY-ZSxoOOUf#@<CQHsIw`Y-O7mERg7Q!DC$!VGY%;`_e
zC+O1Ll-(}@^3u#y`-3;|&{8iy>aamSg<+MF(c!Yhg&hiz9R&`jbv8Cuy!`BbfH?;)
zmlh8#%<AcbViB+f(54h6?HHOrs&29IKKVU1zfVeE2t#HC4*yRX{D|>F8D9v$^~l)4
zo7<dU5xc=8a3M@x=q7yx#^AOhK%_@H6VYZEJ?vOD8&gfmr>K+?<e;#=k$M?ENK4C~
zBaDb?ip_ayx!)Uv+~8I{x`DdJc#-v3M<nFK?D}wxQ;!{IM|YWOFMUML)yhw3HZizk
zV){67`%3LsPIq%Pd5ei1y^t(Xa-k}BTKk~J^>(57FUybkwD<4A!iXY2QsNZHeofuB
zon3FJxBW=s6eF_tvg@MD$#OvtrWM6M@G~nDEVhLA&it$+NR4Lqm==|%sGphxT4bvF
zvWA`8<F3`?{bR?q9tT1qh{IAT<IhvE7!)Ry$xfJu+D6MP8p#Z&^~o~oOt<_99iW5D
zjPFWxqt<%*>u*EOp$5Xm6`D<2DJ!57kCor$iQg=$<|vZak>J1I=4>V#S6mqY^Wbyt
zE1E}vTxuGwbku5CEDYc;6;&1*lbCjoGLy3ti2;2~sAsS^F~!^$)*aYNcE-KPb924+
zcpkTmbLiho{sBkEM3136k@0NcuWP`l{LNr-VP@1T`K4)^eEEC)IzDE0_k$#FgJQOa
zk#K$r278DfP;JZl#bKwwwLB*BJVHSJ26T>>6Z8zQeS=1qTk3LrqkYL@ht(^bUrV{>
zRAHD;+EJVPdahx5W`7e#I$R#>vD?S1H$i$@H9y>rUN=u794yd#0YLW^4^Ki73lZ8G
z7Z9<Wn@b8xtKq9feZjl#gGp6bBZC!ts>MH#+opL}=pj|hKN7sI9JISYf^;r0Rr6&|
zJUas|0R)c=flFt@@FK<#?9?8&5Z4Z_xoANeFmNknY<9+gC<X{5GJd$)_5G~Y4|V)x
zQYy?jTGR<zo%JSnQ6-V5nIX(;eeD~q-}A6hl0jxpsk)%}D5#*4$mIweIy%1A3SQus
zEoxZOFwxnAZT_PuH|!My;#OVzOF4c1u*XH_cNy)zmMswp!z#iUFZ-3JKcH{a7<Zk&
zwCyx%knc!{xqLqFM9Kx{Xd;cX>8UPFTRW^<;gqpJ7g@hLoLn_o76PUED|LXf{o6D?
z>S1kTq!U1KbCY=IBE4tyThO;lk!%<PF<e{fd5Ws4VIaWP#dRZ1)G?Yr2bm0?X>p6E
zHkm!6Ud*>MZP@`iyR6EQurQELJ~}#?t3zd$OuFr7C3kkAu#w4vs(B#|JO{qpZPMe-
zYq%qA>(W8q_q2d#`}JTmS^Xz~SN%e?=n72pf0~-%_sq*~HuO;a+$b+6vHq>dO|O9+
zoqtcH)WseSE8lUTz!!~6`}KwE$ah;A{GX<!!U)(|YG)|y=}>=@68z5gie+d0gwR#y
z(;y+TxBnIS7Bt5N|5so692UM&T55J-MQfp(0VDg}ChP(Xrs?VC#@V963W4bG*_jLF
zKf0i=lXZh^f%I%xaqb0Y9VOl)$w7j4d8M-E<bddk;y42IG9>|`NT#J+05j=Ai4&bF
z!M~6(1<r!lB8H%m$8B-)#VA$_g32WkYX9&0FZMr!c!;H%WkE(GH=YJHM!37tx|$gt
zANnAa`cxy}6ylzK72H1QzwC<HM^whBKtR84Qi_8_<oSe9W(QT7Yj<0J@L8ekcmS;U
z4m1jY3fcv5{VV0xI)gk>jA>Lu4H{0LwMPnzsJ$h}O>N-f=0*WAe;Yt`PO>|T(a;df
z2WQSVGMgS9;)5eQ`z?{CR8g|rY6^6&?>T`_t0LTVZRb>=X?@>xHbCQaH!I_-#RL1R
z>CS0M8$RLM@9=^s`2Kgf8zLH|G7HoE2Qr4Vem_!19H|MKk%YlA`(oLmd8;UofaY+l
zG&(lHI!i~)e!zsGe8srr90={v|1>^anQQVx;g8*Q@kgU4?ABTGHDOQ)SD;Qh%$!IH
z$g4n5GqmQ;&jCubB+fjV7h4pSnXsODKmjE~url*2j8}xI3IcFc!Z3?un>AW5Bk3IV
z0~d1|)e3@ClnHA@i?KFZ;g{pA3iy(oR>s$SS+?~RK(TQ#>nO^O01dv_jG&3lh<rG2
z6&Cs~F5uaCebgi_3|{rsbP#UPY^d-<=%cEvcWJG+ZY1f5>YQh(`hzgX>CPiVZD#U6
zTQA(n6hBbI@S(l}RXE)Kk~0T2zAR;glGxleH+({RL2SZ+4C5a7Hq%cpw%d4Ry7jcP
zUkro4UwQk*epmqMHFlqmSzAyqYgqkD;h!LZb((@W*ccFgFMKn}C<;CP^JN>$O{t(I
zd>yn9-Q6=0K<xEjB=)Mc5fQWZRd;e+QJChprc43W*%=4>QNvU{^Q(%_yOEOuK~lOx
z<ivFkT6X68GI#E`BzW+631(qdrp#)PWY_O#J5y(s9o1Fb2G*$BopZDG&p$<BZtC%N
z#5|)%?UE-_X(uPHQ0DkXn$QmIfktgr5ODQNUI%|;7s}h`9kzmZky#mwFN;yS-8Km5
zxBWYEcV6tn{3l=$QlR>q6%N@nt1fZXlf1+pf4i^XSSr$_-3t`=mUBG5b1K^5SQdGA
z?u_j_uK-h~iY*$tX*p=e9i~qKG6RB3(^22LFD|<`Wb-+okh8-#O@k!e=lF#&go#xo
z?lbtp2azI_UNey<!b%3wctm5!L?!}!EWxtw^Iw<1iJ>0vUJTh8D%`aEpeo&FjwJ|v
z<Chfn0Y=edKAaS{Vv0Niv5n1S_*0}a`nPu-#F!2y!e7y4-ICjv^A5k}2{aS%h>L&#
zhQMxs>W2q@L$!@=NQ!r{o-0i`RrY(Ink);6RQS^Gb_dlywfl3KWNDht40En6pW*Un
z(JWCdNdSBQ34?w1&KlROoTFALgT^{qP~W*3!L;<=me!O`lpL6whv#;RCA)t~8MTFE
zSSxybPg3p0JULi_(+MK}o#p4wQOFAAC<tfCYlqg*tEb#Z0hJNP?!ycP1oACr@^6Nf
z^#KMCY0>k$$fw8o7JjjZ6(46h*a7v*NGie>y^SrCf?WuH;R)>G3MzSBz2@KY+%Zcg
znc}h`PdPr);>+#e<KTU|%lXKC1VWnD^`7!x)At7<{P@dh>*m&RVK^tJ@8;K9B1oKs
z{&dSgnhn=}Cw*+bSA<e;b3@l1qnRVF4t+hR1sv<fsLI%d`c*oJwevo<GVX9!I0HE$
znKSFA`{8mV@<bK`j?3JWnL0_g<j$jMpnkb~K)4E;n<|i}wne=Y4#f_BxIBbF_<==u
zc%JU3HkwwZu#=-|!ZR=NX&;o|M%<E(j*QnMtJb}GU%ve*1d@~GrJ_lhq5N=%n|_~s
zELsp2-q#BKLe3g9!~5PoBWXW2@C7fUEFS>gK}obCJ5)TJl0I%j2r$ui$hX0#&&!!Q
zE~&VogL5i?Gh(xt<Ato<6NA*pdBfNhOn#paIVYf0+tDgg>#1fv;*?Du_qnkG8}^BV
zXQdf+tmdTG461*_LB8(P9aS_Bwn&qz`7>0cWY{DjNdkq>9?la6_T=-}M=SP;`W;r^
z*<6_g0wF?TjoJ&Je3;y*2lMQ?-(9udivEMjcB8=IO1hS%S6GfWLK0TW&p=#bK^SDR
z^Mn%5^Z{YZ9E_PkSLRKva6(D05vN7*ciq6=q;nv<Ewm%uMz}AN>B_Jc=20T^h@}}D
z#p)lHyt?gT;Q}DV15D+MZc)1$RdXXB^JV#BR^H3a58C9*F#Mx&rkXSuuLo_;>1Vbw
zv1L1%oq%fpw&@lzQ)}MG#K{-wIT+$-zO0}&Z-Z)Vw3}@;(ZzcNBuCfVP$1(stBgmx
z`fe+XC{z1*;4d?SYF~6xwCb;Geq}ESXT)4SlE{;SE~+Fe4)+eAT%94Vk~v2n|1dsJ
zAA!(ws#iM=l-9CiOHPirtChiF0@WGdZbK}>59PXTpduJYwT5OJMmxFlS0GR6rpeKo
zQr8=}+VIO7d>vL-kqwNA#aDJ*fUsvQ0_wb|BG0N>Zwb)4U`c#(IMfZ-D$GJJSB&zA
zMlQf$U&Szo>q|D=l+;1FHGlXKYrl<B?pqZ0VfgR1dULzx&XmC!yiX8Jm4|_x^){0g
znyWz2^vmK6G)#}g*_9jDAm%kD^ofOuW@UaYK7OBkLMn!4<(#^cqh?5;3m|^ePD%7B
zse4Sf{UTWbhhkv$4|yrF-&0Q{2Pe_&w6L}#b{iJ!{9z@dz0OnN_Rs<cy(m4Mj^Yh_
z>_1WSAWQ`US?VnnN8)9?RH1JZM8RqbHRFV@2W!Qp0Il2!+s(M7Y2B@|n|-UINh)58
ztA{m)*$#!Tk?reZaj@tMeU33S@kX%->y;z3KK%|Sw|=K1NM1b+z9~Jod)kQtEA)|X
zhxjXTso?dBPlU(H3pNE|5IR6zCXKnPWzDU)Cgd=ZjVs8bV4CAKFq;uG2Lc+PRRhQO
zUQ=t_l|=RDY$r<#dI`Ye3MF%RK4{xC$w7x%qPM>$Hot1}+lvg65C-fCB5Lp=i}t5>
zDocw%!_v6hn}fV0_p7IydG|`wlQ0Mb5(Pw1PeQzkhBSE9ODzM8RWsal?GmVhCAIO;
zfV52ve^8ocIFa1s_6b9cS^39#$t%vL$*y1ZBGq`K86=|0)xyJltj9FR9fqeGu4p>p
zVprJihl!D2wA`@+i0{y-*b^k>ZfTzytbB6eL<NW0)XPqk)J{*?iLd_gIt?4=IV0rD
z0u~95>Mk&CBBOyCW3S05IHR^<PLe_ZPlB|bz+%GzAO`aXKy~>`2s~kOYd20zO6BVZ
z3;)Zp6x)q{`XHx+=K`+tjDug9Zq;b@0XsTRqu*lsZZBUKHzIfi0;3Wrqp*jM2W>ur
zjV6Lk3RfsbJ)GmItPS~+f`tY#hg~dv!%pXSNEKsKwsrVrP7Ikn{Qmwr-M6Clc`1PW
zh>xl`e%KONsuHAz=fA#Um$^+DB75;r=ni3pNS=HnQ4L4NmG=)(1c3qM%+l)d<_Yka
z8tT=c;{_c-V)R`Yy&je~)WivLemGO|l;xu3Yi>Ct2i{64;&-6GB;HM)%fL<d#WMbJ
zn@oAM=HNF*@vL;t_<Q#WXAlOx{V6<8F+gUSal?JS!UEyO$<i)2a2Pgx?Mrg&TMMa4
zp;x3Rr^z@YrgHyr5^8EAC9V)TRJC$n;lfPF=A8=4kX;Emce2tumeeQvJ#vL3@kx_6
zr4fc7z+9SckCj%`G{UydKnjrIl0qQEhc?-1DLfuQ>P;$4@_i`LmF0xIQZ?0XaqLWl
z$*^BGEUtR<t-H!zKXjiwfs{$Sl@X3+@t^1nG6WL|aJ+YqmZcrqtuVPAOEt6uUx=FE
zL^Ok{m58S!*dbC_2*;TzJbv30ncF%a!OANa{7&Wwj`G6ff&;-&=P#po9hBENvzrJ9
zOF&+R`=QWr3Oy)B{YP7CNI}bA2a3Q*D|z0&V1G*$<MiV!!T^9iEO3XX>g}{cW$eL!
zc*{^U(N?@?LjXukY*k6bFDpv8frcWI(SJ_msfJ9BM9+h{T=!{yIa<EkC95Nf>dQ8%
zL2{!Ht4XPGb*%v96BOeK-W)ocsG3jvPq*`lrAh~=oRakGPrO%ZXJ4zHPOY!7^Y=B-
zD8NqIz2QqXX9390ciJdWxd8o92!C8;eD76*i$EJxNgIB~n1SL<jCL7K-|c7TQ5P+A
zBlgcpIL!j4Qk_!XE{AolMvnQ;wLS6#2@xmgpPx|w6(Ll&3PT6w{4Xv}!Jc$QATjWZ
zhzoO()GthJa*<)du;telo447yf>_ED)X1ot83dzlAq1~5WErSQyH6IhJpBXsoF7ez
zOYK{YK7XptL_Y!T``?<p(_Vi<Ol*tpJ=EgFZ6%g~kOuIASJE&RAHvKi{t;1TJijad
z_{iq?L8ON`=-cFq7lHWa!JxV%4QQ03Q{}D9vixWxk7*aS!lHg(Kl->rGN^7x*AF;R
zqD%?G=NU8j4XFRbl|fbhMG2~~wv{mq<)`;h0ATNA5msOaL{%0LZ{+POm!J_~f#vC%
z(@UN_UaeJU9c5GIU&KoYz-c?$>&ZcYuFcaG#TL1d+zWGJu;?gSD)`ASQz$|X`#tz2
z730i`CttXdtTjy(+k{8u-FKQHimBSI9HlwTaIfrK*Zt#atrMzA_f{sK&DK%y@9K|O
zC+T{x>0G;@F9Pcf!t4sAp54Kw&`DbX=`|Xt&)y8Vc!IAQ+zuYjy1mR>8XD`CSY_co
z8k%8Dv>&F~kQm)w5zgVdZg9K*E$wR#x7+rpr@E+%@2eF>0#b0>A3ZNBzEv8-NvQ`L
zdk|!)r0?$NMx0@JmQ#}$U^Z1QLP25m+2pb*b@YR_>3iOv*+(^N)`0M`F1l$}rER)#
z|9+-U1mH_i(Y`<WS*l6HW;_D&Y~4(w!v@cU>1i8nZ{icE$Rq<8Q%pJq-yw9Lq)c!q
zO@SMPjs#HREP&+jj2`lo<wVy9x86I+gs;i?0Cm76oBR$H+;pX+4-g9C<PuR0Trrjr
zRAG8uY<@-gqtuzHeaY=2flC73cU-5cRZj}^Skow+2hi&&nCLTFsnfyh9#g06AoXJl
z)5kr2sPoQ&@)p03NWu6&ob|0-WP0`Ty0@5sl1DaIe9JQbC+Z`+$d+ZInTE}+umDy(
z9SFn9#<VtJO=~*aAyq0)GjT@YO=}O}6l_n{ycD{qK^|7Vc0O}+h^m;`kj(n?soHB=
z=qiviKR%ItOFfW)FVg`Q=&<bA*k=%k?N0T+8M^-<_!eoTnP?<+W(Fdx{~DGBm7V-@
z{%X>F9>N)jtUdf}Y%g^aMu$pM2jlrVA<F773b}#p%nq&<pYP-Ym;~!Rf8z*7>y0~-
zg-&Cg&grsYEg*HY*1-}?!l8MOzT&tEW}A<4iu_j~tR-$mgTqC-ir4(~lT|vzrlXC8
zZo~4qu4}Usj`4KFBL(Df&V9G4^jT5|8xx@hsrz%Kc!?a7+Y+T6id5n;1>PR=$sS$=
zL-X}fA>fS9&EbE5?>XH9Q3psR|M9)WYjTVh`H75L=!^BPgJiw!tRm(tz2YMvh-%7n
zLFy*S(LK>d8G)JWmN5fNVYD^RmvolrB>3OwaXoW7_eW`RV6++21U6N1KeWw36QM$T
zi2z72(<_*Xp|2=`a#XX>$LZ(fXvw{!@;(*6{ZKa?rGWMHL|hWfeZMm4pp`dz40EN7
zFY5(x#q{w+@`(US487!w8np5ycwOQlHvVu|C!O&1RMwdA7f_SGiM(_k^7J-RpA#rG
zSWqE)(tz|^xSDcS5?FwmzYO&xljj4Y9AHzd0?w>5x|mlFrp?1mzX_cP1pq?0_3Uj?
zyWMah%KQ3vuE#r_pXvApb6IZCgEHs71wg`oV44DL7gd_iY(0u-N`JZah(AiGgzPZ-
z?!2!6P1y>oJG!de{o@$RM)Zy(=!IpOw^Unn-s-3s&iC#d1I-rZt^lfg7N`p%&t53o
zk?N-MF~;a=LrWNky_m(e0XrXjZYYJ)Tc6N;SVfu506O&E6G@9CP)|HA-YjgpvJF}V
z3z4pxG44pJ{VT_b$m+3+UkbW)E;zltQ^V)a5fhH(ka*#FCd*{MMAlv}CX0EgHMiAD
zPlZ<F<zy$HZvg5_r6m5frg9k%a4i`@r-76fMt|My5FGWh%it&CepGW~rqi8#S&!al
zU1h^#Ek7mZ0PZZWrg$}u!P1br?pQie#6g|m1Tv{>0bzmP*4)E%lsZD9+v=ll_`lMr
z@<YFH&%tv9pADds1Ttd$vAl#32k@|YzB&SKwE0x`|Bd^8C0lxBx_fpJNT5=QOf&pU
zc&ydc^BVo_iD>h;RqSt1GCxFEmTssF2!G)W!wv(J0|<<SD*&`^l0Ka4+hmS77nl+E
zq9%YAKZA*`uyLupnW&Jc+HP_K?_G4;_4{E{k*;k^c-naBl29o2TgY|h@TDP6CEPag
z*eEKcE-OkyXSC(rc6)6oqgo>Ax~_q_+?#@>YPdy<nfQrmngYT_uPI1oxX-`sAP6-*
z1NJ%t`34(0ob@`r;{ZCeM~wQM>3!15oFr~#Vae|H*&3Ztyh-&H9`g&nmeZZi%mvRj
zK_#A(b_<d(gYXyu+Mt03#|^rP=!`G@l%(M%m{(HaSPDsv_q)-<iAzD6&XqjvhYNL$
zOd@a!D^h8UL%ch!LA<?N-r&4e{2Sf~D}yf`twA&MIX@M{yWUN327C1#BoH+DkJuZa
zHF_A}kxNk?7N+CUiXi<MEMK$tlV>lP+ySK|n>|p_PtOoej#7)qO3q}R*ZsMz)V;kO
zL80S@69Nems9j&1CLDc=J$B0>{T~2u$LWU=IO;AE+C%MEpQeOk&9<JOW$l3aR<Ih<
zHYMcU-gV40ry3t)Rt!T}Q>Tb3jPqwPhpxA8IWd(JzdXpQxsV-3Ex^$NB&WPhV|_sU
zT{-fgm(AXs#wgxC@KM%-OXoOT%!R<d<T8IsO#$G`**J!I`#S3jf{71HQ7)EDO7B>~
zr<*qBdGolQgUF)tYUg^cvqe%un?p}S(X}@(+|f~kAwW}U`z{~)tE;vSRGoU;OEDcy
zJ)Km6k~!W0iRcUkvOV|RE{>Dh?!@&Nn|dEbXtTN*$X-~^8c~&cwP5d8CiI#$b)MUH
z;QeczgvUMgx)*!uFFjh@QvRNeM)GG?L|o!(Id>ipmo>Y`CRr0q&ieXaEr7vqmI%19
zl1Q-Y%{}rl49H80vf3P-=?0C^*HzH>OXr<M2;qQ@@>DZ^D9c5-XGR|5dG{9&2HFDs
zGxU=3>N0Vi+u`%9y~1BQ_e&=Nq?KJ(Y#tEKI5tpq$jdVOhHMUTC$de6o+=ZyCWvHg
zdqwaQDyg#TU`1?}aGAY}zXWOvYQnTs`s3saheD_P>~)?Pv2{AX&HFbZUWdh{XkPNq
zH>I@cDB62>mj3D4t2l4>*$q#*@!hA^B*Jd;iI9eenj()rG~qBL<(N=R=Ut|rd=!hq
zJJ0+{Dm+6;-{mX=jGqojM(>Q{TNgf>Se%56ON6e~q_At6?Hl6D1@I5R(z0}T`uDbU
zoXz)~2B7)Om{wFa4dIym(2G);%1KqCGTpqGF+K)}SYV*o6}+cbwyEUi=pl^qjK8<G
zMkMBN5(N_(UxVoP7!4Qz@}s%GMG4WFYU9ef880)3vufF?^pmxc3Joq40Phah6TE6J
z;ooX3;+FLdRY!7H5M`fOa8c|v?74mZ{Lwo&bmzP0=dZuK#<qdBG?BS2r|4HAT2JMw
zY>cTUd$|KFi<zqatR`lFF_<-<<pVNmrZ8+p#g%7cWI`E<faT3tOf_h5<2IreL#}<6
z%=zV}37U_PO=Me8<HQX)2K!9+Xb?Zo?;fdh0>3mFh5w#fs{{mVc;)U~<=+=pr~!>G
zwS%iJy<u|JG{p1Z2&6ASZT0=zYmAL-yJqBeb)K9-fckkz$W6(x{}@)`igW=DcENhW
z=(npnUXO?k$ui;OBzGo<^rc}`UCg{q>jBUpTnPVfMz22=k6LClZZo;1wA*K#pfzi@
z=#j8ZbvQ}0JjY}>#P33sw@G!%y2UJ9!Cp3D&~jhcQgPC%dD_OZTF3p1thRoLP|3)m
zZT$C`=Zs~8Jh%<`kHVT@cvE!Ck*217e$u>b6fvt78bqU?`Eytu+nYFHP<M>FcJNa2
z<rrJxc-Kq6`eWd-C2*={fMA%}doWkpCXybHLTk$u&HLDxS896}kIu^0Z5n#k6Lz`F
z<mqS1qyD-30%`b_><?u0r}x1gO+WXT6e73CB&E>C90AFX)(*ofw@T0Z79DmfR7;&e
z2owVsbRN!Op38;?ITW|+v9*6Y^iQE{mWPWrw{oer+zlIWOo_nt5B)ZqYc1W{z|eF3
zxkFR(x7Af!>F^QoFQjoZAoXE}@wOu_frTMnq&B9@*tVQ*?(R0?hE@oB2>;!1xh6sG
zdi_;7CsUjmG&AyGP2GX^eV>$5U#f3K$CNW|mD*G(8R59nn3(bYR?UW|LKo?2|1~N<
z?#e#LGN|ydnmub>`1rXhz3+5;oM-yT=TV?zy&}(?X#LqQaG3)EfTa`t6wM$m!ABZg
zDwNtrvXo5PfJhwwx1e<&TYuDbf}Ea6#u}kPpH1|+GG7J<z-*9<nHfpz8r_Mvzi36n
zw+Gd@zKvI*A`ysN@azxg%{8ENHjHKX;1V>f@GgQYL%G52AvK9G^rztzK+JGoCG-5p
zmF>_Y^5FPWD~xeoUd(Kz7?SBuXUiC`m<I(|*l=~9#VNQN-+H8VJu?{|aMCe7Z!W@3
z73mzsp=VVb_OG)(hcS6qsy&Mc@OTvqrl$%WqEmB{e?lOshPjB;D-!oNjNo=S(vQlu
z&G(eMq`}oAFgAMkD4x;IlZogcs65u^+P3bh@K>m8Sf$^z*?o%~d%_c(ms+1k_j!<m
zXHTedUv-pqP4YxK7BLE)D=iSY%NM?RN6Tr%Oia`!r~VAUrG9L?4$OK90KMV|g!fn)
zH&gJKN+pM;_n;BOoWu`%ZyxHmZ<+Z>WSF?jbH=CEpS3YgAgUa1bwWdY*P>cg^%vpp
z8Aef?D!PI<(HH~y^C^j00u-r9_DZWH@pNSoO@&tP78Pkh2Qe=60SRE%6Y4u+cc`b$
zpHUiyxnzo@8p1wZF57z)QsOX}o`zvNiwr7XvJ<rwe^>dAWRQ@(4S+7eVZb)U7fiPo
zD$w<$e?<YVbSFTpm^8M6Tpi%p9dgP8a#Qj6C)kdgOl$V0-qU3>9|b5l#5g!M$P>G>
z-pW@v($;B>8|%5y>JUz@Xck?IESHR@H9wjz^ICeiNtnTq42s!M0PuHt)d8JyVdYUc
z^(^m((_Mw)ob~x;a1?t%*CNh%|0Ulj+Qili+#ue<v*KaAF(2+I>xX2l1M&K*Adn&K
z)*n*n9&8SuV)i^FPl5wdFL^a%VqTYU`wK*DA+8?P+=6gl7R%QTveoTV5Breu)Q=Bf
z`>!=gouW4EOuX;PaQtrMq4wX#vBeC#hxAy4Kj-yi?}W)R)v?!9<VCk4n5V(U@v_tC
z5i{2hnEsT~o%n^!7=I}KT<(iy*<0mrq6*6L?{n2%1}#KQ+O2upjQeXXe2G@-OZ$h4
ze>wbKvaEzBUHRD5CNlR!WIr<n$9P4}EB+`Wx5Xn(Vx}m>>82;Wp8~k)mA%WeKq*jy
zwF*ci_p^^Nxs$28BiAoHtdbMZ>{Ls!=SD{#u#b)NRjsuE{ZQbdA1t2(+}7>sHy`*_
z7cE#<_TuD;I2D8cb7$4U^xNDo7h2`u$Om(F^7Qq4(eYW=^u*8$40mm@c>%9+Ffzvt
zH;qyi>b}pA*&kb5#Q~z$3HQ%9cN};+EzMlns9(vb+8|1F=f7|zi_erWi!ty@yuoN2
zId8|llNpot#*G;`nd;Wg<$O*rOT1x78R$7&rA?Ko)V@?+@Yd>S{=B(AGX)a?u&(uw
z_`wWvI=`Cnj-0QR?}yZiYt4H+ZmG--Oo<HN*tu@Isu_Fj6}a}9d5Rh4nP*Wwgy*aC
z27eNqC3F?|ly4taTw<F8+F1r@HGOS9Hn4z+?F?k>p>nY6SgadY^@>ms2H5vEr~j>M
zr8cW`i0+i<vf5_@Ic2rIGoI${kiTRM%uE=)^RmUC?H~_a@l5A!qQqpp_Nrh-AG)63
zM`T~SP)NIxvqw|9qQ%~);Z$J3%Usuwu7BQ~7;^0{J17lZ4vC;rd3sUj#eSgMayA(#
zR-I0nrd$1(R40m@9qU{R&wBj@(V;Yd=vW$6G#Xq9IAxpwP6A<>A5%D<2I|0nb(c{M
ze}Hwaq_s-MT-X3pe_0i}tEGN^I!oln<@|3}QAm^@Cg@Pg2o3JG8>^6ASsKH9>8d(M
z?LZzYfGR@6!kjU1seF&3J6`iyFLxf*#AccbC{;71c?~5!lVzD6JXW_C^6{!tw4+rf
zyymyvJId#6$tR!Iadw-b?z=8Sc?Y!KMGxSOOt8D4bTdk1Thnu~H+i9|H*->biz^p;
zE+zP+_j`es35c-(Pu62re_Z^sj@;+$Z{TGf^kS!XS;58CWcIe~zSbrlwOxOKk2l*8
z36j7u76(&PyCmhG)qm0a{@GW34BIXsqBIa98^m}x6V7OwBV4?=|Ep+EGba3A9g~YW
zK14gUsz1{KZd4pvjE=YL>+Z)@K&_nW6#gu=7tcKFe$bIvgUu8a7U-q*EBr1--VDo{
zo~a`#1W3uV?r&hAkA!B>0(ih_rFnn+<tw=INN`c3+Yb<u*7LfTfUR!mbT4>pskxIe
z?yV1g?kGJZ9M1}Ux;g*yLLRZAiZqu1qzrw<MB?!hFcRq0A6GTYT!y?-`*>aPY&+<@
zBd8oCvJ>pnj0OvS>amiDMlr7cBz-6_s&RF^EU$`UECfzYla-Niy|vVb%Ume2%8CWx
z2KeZ&4-0A6<ddRBaZ@%Cxa*SFbUOS>f*3m4O{v=Q0xXjg<*)0?y`U-QzuncEI<cDg
zU6?$+Y_kq#Zys~{>3G9r!8e!W0E`^&niJ6>U(Dnp2O3$rI6!LK{>VbO#{yL^fEX^S
zES3JQC;pwHheYc?b?%D*nXkyn{jP@iBdp6UwRQ9H6A6wCPfJYj3V$95g+O!k9wQod
z{5pk)nnXH~mF9wP6Ew+&<&(HBX5tlN)U!YYM~J?cJf{FAU0fUS&!m>xd7F`EfBix<
zEalt*4^W^Tng;CjUyS>`-w@*G9%GBZcQtNGQo|KRbu)I^Z{-d7f{OxJcDjp%kaHd2
z{`6#=u^j-ls)k`&GraGVg*FaX)^%zvvJza>0(Y*XT@uHur&Qp_25Oa2dzU6}iaG~a
zevLg&06m~MBct_clI`OV6FXHul(veMe|p|M1uj1Zh^`)&=kwg=51p^N!mJ;^FrE&m
zA;_z4&}sn)I{S_Dhuu19nv~-Wj-k60Z>w(Bx9ocB13&IOqCXlxQGv@unGPCKHA`d4
zJe%!fZx^&+Wsh{JN$!=&j<QWiJU^fI)r2<TR&UtjHCOh#j<uH8JE1&tjA20eR+D?b
zD`%PbN`)Fu>Icm$kJq#=Hyf<Mwo!5b-4X4e>Z@yQSzu>=>@;TtbnwKN%6P#dwBrMy
z*!fH6mQ0pA%;2=?ux0E6RYy@Req}q64w@nT0zkkd@{=PgJ&)s^$3(d!O6EF6sX@o=
za&NBbpq&vbQPpv8u5?NQUZWF<s?nD1w%Tlvnu^!#2QBle$z3@eAf^EPSeTDBpvO+H
zznp=DQ+XBq)n59*B*bSgzI0dtq6(B4mEchvgFc5%E)Q)=!Gi%>j}M*!#%&j{g^C5a
zl$_ZH`VMV}Se60x*!zPV%!2tGpJJlK19jomrkoZ=-aoUJQ+G21M7gZop5rQqG#QPj
zg<fIo2Y*=iFuCG>|0v9h`>4v;aCc#<l0SQvN3wg8Hw%V7cxlJGL-&efI@;x7?F+$}
z$arLaz8UvSQNV^<-Q-N4AsFOFOm-~6ELE<UHNT>JC}-Tc?paa(?<XE@$H#Kned**O
z{CVs9(b*$D5pHDhl~ji<I{Fk)y2ya2Yqd3EF7O<WkT%?=B#+xqKZDP6r4yXJZN`dI
zcKoWr*PnzCCKSQDXfkruoGJsWqwr%N(>;N*B~O3Eh{*F1ym~3YEurIu`hi^i;RwO&
z;_G#1@7lk5F{$9zz~Qw1vBuua(bn-12OzxEk1F$kJhIR4c-`;j@gaS@v^XL`WVfe&
zt{4>F>m7&q;|-s4s<kL${c&OVq+YKv05E05+yIe#GcUeggUsi6#Kz0-71ay(AK#~c
z3N<i>9W5Ro_~ak#+!P8?gBIhw=q9T^BmaAr3p>-EweF8s-Bo+>epPM^f1(0j-;eSU
zT`)JI>wL)b%X?3!x74TJ+VrTBpIMu0j3kH3!HaHw%1yWzi|dctn;Aa%>d5*R2zYAT
zmm?#5QgDQ1eQ&k6k5=x;a1rvFV#wGPfTCL~IX%Aagt$PrxpFRe6;`{y69-}qej+hK
zgB@I|U{P>C`AOI+%-<K}2g<J_gku|UB}`n-*FEGPBx7q<;rR4|h1%~_WWA~A1Vk<B
z_SN{PW0XUw3FLicUEBwUJ15f!X`PO1)NrG{2tjXw+o}cvCs)P)z8GY9s<F$GSIm77
zT$Zx{&rgKXfk%`G9lAsWoHGV^LZ{BbrjC;62HpFx%?Y30f5i46=bpY4@4)lvD7Co9
zfWQ@YSVIZRl<7V=@Q95)ww?01!Z@dzb+mF<#%bi;;I;5dKu{Wj2h3b_(%%&X*oEV&
z0{scj^nYG559UfqBxEn-R7uPpcZ|~c{<NF&ARG%^eeZjjYId-lQ{3xG9F{KUp38>G
z1o`XgXa=&5DQjJlKJwu}>bQ|MFI$>XugTP&^A`DfOsn>cm|VEU1nOr>O#9CvxhH&U
zS(TP3)=sI8q?h<2*31Qj`j$ZYJn_t5&3W@j*;&;K2weVAb3{<`%=z1%^CjBO`~wk7
zqSqw8fUy1;w_X0(ad&>e>9zwJT~gv!J5>chrGH-!eLJnl7RjXZWL;&W3|nY$-pPFw
zdEwixA1fX@4j!+y*k7r9N*uB&UH2BiTTUHj>p8iLcsk|$;Su}(0}L{ATR|_2cu3HR
z2$mJIjNr2dfAXK#E9Cu6t!r})9AIqp*4yl=qiXxJAxIYvw)xe*!flG*D;Wza=_5sF
zo9mq1w&u3TAQ0PN4~pZvO%+J+@p)-94*Bm`z?{4i`MiHrR+TYB^~dr8pC{nE>q+eS
zn8%)cUFPdXZa;LAa=zGV67yLj&?myG_-BU*zx*KG2rgW|l<bqdJ>Kd64ED<HQf<Gl
zP2xB1?^z30_5DAkryM`&_SP&dv~A~W54bY<23deHFpuMEdVe>@>z*#o3amb_?SE!8
z3<hah9c;=DQbzhRwasg3y?0BL)tAW6Ev0ZeboqGxo%(3~y!?O$Mk?gy9R<BAb}$2m
z@@j%u|JYm;ut#aXC}L;hGhn#>8@2K;_uRkYs|@qJZJqwCrgDr(xm<i8|CycQ`U<`9
z4wGYzdAYiN8BuP3vT^}j6M^JBKkRk7T#548zBp2$_8av-Ln)qY*|^HAs+O?loNPL-
z2HzK9o!@nQa450BQAKE-ZgU3BK>?R1pVCfsb6(r8RQgigi2tSnsiXvRA$)&LQ%|IS
zha0IGh2?)aKQ)q9=Nt4yRI8_zsD34XMK@htp$rIeU**R7iCH~%`&0F)Qp<{d{&&2n
zvo1I||GwIv&z4I442jUwMd+s(XMlxWRA2_XGOg90-f7pxUdghe-}h76YU)PutA-x`
zG-)s+@VgI9+#Pc=;;YynL@dwHFYK=z+`b58ng6`Lofz`(z0kAD^~%^P)xW7#Zf;(T
z;?tE%mu?<)WMmu44P(y-pPw2MbIk*DtOi4Q_d4tTHwr{2pwkMwdxMIVDoID5SPG`E
zrWjazluVL6<u$jh_4x6ktl!9O{W4}Cal2nd5ZShrdjApSS&}B?vkwl|zq0`jd=G5-
zg!YSq7qfj4?D@$pSIFY!bNbhi#C&ht($3A2Iw$uLvDI`3E}$n+>Pa?6A8$$HkdsA+
zgY={w{r?RFQGKwf#REP-7B_UBHye@Skin6N+w}Juvln)o!)}+41pU2V+v0;+yHpHd
zqaQYo+FozkHU0mdoo|(3mlWMsKQ2(6?2>ukqmz?7>PW+OM`jgC#J|_`8eHb7LrDWG
z7X6=dqYjR}6S3Im|FUAuTM#d(=M=RVV>nY48ro|AWOTY8N?)A1q1*|Kr{#8RxjgmJ
zaVi&MlYbI~pUZy^Dm`3!0M^)j*i)|&$oQXw8r(jaR#$<kD(X#6*$6zl=vQxXquDhZ
zLDxZ)Lj2igaDI6``Rq=-=;_?u16Rst(nJuQvQFIezhNLY_cpauM0H=3&oRu)mUlgu
z$VcYrhu0+H!glg4Cz4AoKNgO)ZG*FyA<?T)TM3`%)}~=Y>)BMEoX3A(dSJg*MCHi{
zT0}(<65^_dw+OkJrQ3g~V9_>Rodq0;*qRY-ulaS@9`(@4ZsT3ol}A>Nr>j2c>?>&l
zV>tb<x4!_fPrJ^S-E7?#<~6r2=qlLdx^AD?JU|oF`p8r~n_j0c&}ySRn*;Ctz7w3D
zjOx?K7ik8pH?+5-p!2^A#DIP3KM6FCR5pC|%K5bVZek>lo0(IEgE$%{gz<gpFM+Fl
zd?(oqR&#IQXyJ37>@UXsNv%AZ%zxJhm^e#cJ*)Qg-%2#}xw`u+V8&Zau2G_HdaV<?
zRPNYf-I=9$<T|n%>?{Jki%ME{0g>q>s{g+OU#IQKK;@ka$eS%EYm2VwTpdgaZC*zb
zZNQlTXHb84rOs&y#^MMv4dt8DfM+2v(E<Da33v&Az~Ulp=y*65_~&IKaNOmCuIt?~
z5Xnn;@1GF`;L72*B9ssD*FQ0C#X9o8bKA)ZCV~=n%j}wbx4^Aub$m2_WwOrEovpep
z18huN*$R?~9PECp|5!xu)Qi6<FVPF*{*LHvzw3R*tNu$@5HhLR(rM3V*ilkY63(YQ
z4R{)RWwZ-jonZf{En?pI!e8!N89mtw`Jk$Kg`D@^8OWyTXD?doie5gLGydOPWuBp5
z$qwn0q3~APY~jTrU$nA+$*=L*ihUV3>gXo2o4VOdD;i_|*e$Vt$S+l_EEl_w>mpHG
zC$FIWLlhY7Qp4t~hLV`-e!ZBBZmZ5nhgkozLCT+E{{>}`lmzW+?pgF5*bu)ymztKw
zNYz4b#}>;?IF45^W+IPvHu=8Zp2IrRY+@#DZ#$g<&!*sMuH6>+_^HXRLuj$wNYHMW
z&j$rUh>(?ucdsm_WGDa}ufNRdHUw9yY2Y$uK4X#OkFO-+qBl}|X5~N-AY9hlr*hA=
z)LtT&8ai5}2oo*~++Ok7_zi@aZ3}<0jhE;<=cu37I@NpR09&8zv;x>?_2aJBPoCuJ
zrqP#fH6QOByMXr}2kjO4$PV5-q`~xG5q=LPV<c-=7?Q<^`y<_(QRQW$sPcvLca5`D
z@N$FB8}~Krr|<tib$xYMR9pM@fTALzC<02WgtUru3Ze`MA`LQxNOuekj*6fls6$DE
z(lvAp45f%PQbUI{LpKcZtpPpfyua)E)*s63Tzjo2@8@27x0{@A>c^(mvJ|PW%jmEN
zYlUHctS*cC+OB}l@PPQIzf5|OIcm}>Eff(w>2#`QQ)2#ExmNnbxPHdG>o8B={h0AC
zA1f|0%lr|?n+{&$Jp<$7cJ=kFUbdbRr$nq?j+BJvq3X2D&+0QdwVqt#Q|ot^r^=u`
zE$p*U`pnbzqbpt5YFXV*R8{j*r{<<uQJ8n}gha}S$c8X-y~j<S(fh@T1U(>!w!lvT
zza=QC>jVo(a(x{^P_UHZ3>nmH$h7{E+U~9nFpcb%Z!Yc6t}8?UF@jj&2OjqKn_B>_
z&rvMv0u~g#-zS9|{#I4aO9HV(QPw|g<ejjC>T=8)p`zoXr$l}rU063{ORpgPNqgiP
zdBe5+nOgI%&-(3@*~A$??y%*9?y`y>Tz3iW7HF$%UAm<8{Q|2*Fe>M=o}KJYNlPhZ
zJsqQgR};Rxw~{b;B5kRn-QMQsqp=@b#=|#a5_7#Tl=m(siwfwQXYP#;b4!mlIiLhN
zuS~-VM|R<7t2OUR>I+GMj-+_-ODZdR1m|<_mSIw@2i|}s%o;B@8fo!U3|3mT6(8DY
zaY_->U3>1Mqk6m@>A8KZjp7&5Wi-YisVIhr)?4sl8)q%m5@`uDhsvpolpevM-Dche
zZLGtz7b2%=73R3;nt~O)cp>L6de|V=M``R{C7X!_?siNHNNme>ejQg}^t2Q10OB`Y
z^9JaVE^yo+yg(hc0&D0?cw=~ebk7%`jG@DA@OilAZs2{)U2l0<d67bH`p??uWzRPq
z-g(8fmc>QpI4nriYy0*k_2~f{wGLDEVAoJs*1*d4t1Ej2IrCqh$|q7n7{^L!*!=M}
zS@Wfo6FyG4Lz<yO%r2eQ<qRf7y`#lLB7$NL6}0V3m&$mnWeYwQue+ov-VwTalg#B!
z{s$taY%a2XTd|z4n$0WXs>QGf2l4o_ocU7$D4@+KYjO2xx>tx4k2W|_n*Q$hc#iSo
z_{y#}9{7;VxmD3|#e_BIpW8nKUZ5)!d@#!3@$~xXf;pMu!;SuN_|gl&2xMk~HM2Zh
z#MRB{Bs)<D@wx8~6QeuX@ZWAll=a?a1GZdK?hj25iQH|XY~hfPPuYW?PL*zr{4S+A
zcVTk?Jv?7xNGxs|gAK#4tZ3aqxl{I%!YIZ+DASjy+iq2{^@gqoB^@q)cNl3#5G8yb
zsPJ!eFr{A)8>DYDvz6aPeXQIfwwIJak>?80m+_AAq`uAp7CBo~eN@qWY`u7k)t(!A
z92On9xY3{mJEqxX4FUd(q3PZWB?R#=2Y%Ty5eRCmFyqbg&jvkrvjacBF*t47D6$ko
zdT%fkzfgRAHn_~b!$ps*_7@83c1pTVnPKZxW3XqA!(h``mk-{5ug}h4NBl?h?Xkg6
zdsms_&wHJwq_32wNYwf@34bEQy5A07Y)Hv`%J9Ql5lIXh+85!_Zc(s=Q5~tj4{3ck
zQ*_O1_AV!MVZ@B#ft?;cNK>j*)NFPxh>edk9@!nyj+_0sVlB0eI0`N8=>E-uwjLjT
z0pbXPS42W&>m{j%Hr@wV*8Pd6TV#|uD;z9d{pkF_CRjb3`5aecO7tlNnZqDi$n2EF
zfL&!|&<Z*j=jK0qN=T)Lw6z3VzRo60?<jA||B*s#0*#334ZXX(5Oe;_cXUz??z)Wg
z+!WPFZI0Q{$5i9%kcb=W{S=aK&H~v9>53ubMiQbuqv=eskAzSqEIZw^-Ki>qz<2R2
zO6+-3j3)sH$GJQ47W#nqFBc#RcL&0(9V<NiL~uW8sq*%aNDTkL{OPjT^L!t~*v?&)
zNr2eeL>XR&RNTlNALgycl%S*bBWio?hMn{H6DwZsRa~9VqC<8dUi<2Qka(2PyS4RL
zUNbbdbD@;?<e7FGbpN#3k9+BR828ERUj8Re`n6lhZg*Iydr%gyvpV;^aL$dH-dSl-
zjWdhO4hpx`TT5-qoWSA$W3-z6iBvbxb%LAae1?`EbkXw*ispTdnyPJ(HnJ(ux$-KI
z?Q?x}^+kx(Nsqw+^=}_MP0y~VAGivLEu@I|+L^}e1l6AX+5F1a8~f(+D11i4**&{)
zLD~R?u!=!V8ro`K;lT5<+$VHvLMw-?+VNbx63CmiL8u0Y1+dIc9ae0j$1@d=g3{uc
z^I7GuKe-(2ha`(*O+ZQ-1aiEbCO4a9=P$Dt?*WEAV(mRUU(wpK8C>eH7tR4eAR~iS
zOdi9<G+i9V3dzIh=u7+FjX&XoqFE)U^uS}}G%jow+8u~}batCt(h9RF(Fp4_nFqqc
zwxExsZ-vn+6<tr~J3Mg{5?)Qer5fgWZn{+K_U6;uY})x>9bea~nG8H?+-$HYSm;r8
zH*ShHJ@j8kkIa8x$*AAB!<Nz7qD+6m11f{nVy=QiVbFnK+;aF%oYlk0k%~L&f~Q2g
zqK)y7n)X5k7?HH%;UqG$Ge!46>{M9v%Ms?s;(qZUG<?9w`8e7F84~Y;NLwcemIvbZ
zYb?l9-`p|*G%19lYt@S^Fn2UUK}3*7BT)p8<4cFM`QQ7}9cd9P7QxdoBsT<Eidr83
zBD?6?EY~sg3ip(QL;8*eb(9ioG6-dKBwsw$DM|lA^Q6@Ll{mqu7G-TwL!<~wavGnV
zZCzz!QL~?7T~T`3^nH}&N`eAdI2~7&Ei_>JiNg9V3eRIAG~`xS5#LzRN4~V%7}J@Y
zLq<gGSWa1AUST(ELW~*-T~;xUG%n+=mq`ik9C5edReAWf-Z{bH3`X$n<3ue3(N<pm
zbx}`ACgRje>laXkcyU)kvWVCM-lXPm$AFNRhNkl2rN67|s1)1bldD)F`DWGD3T|L3
zZ(dCAEp*xk)-vN@^|0%5job+qJko`l^x`J+c>=d#g)wh}b*46ZKCZFYTfHzGBJt7x
z-q|*uNz7z>s-jyk!z9^b@}d}JCA0F2Z{`)daa$|Oq&3iB&+~5iBdTh$uD|ws-i`b4
zLBD({(pD(a9)&;d+b(S{=C2=strghRe)|;Q8cWW@GHx=XVdP`WZLD{@{L_=EDjuHA
zgIU+#ZZ|$+E#DT0EfjFtfYou+`At{q1;&cL<EP#$)7x3(RpaJ=gfZ}+=b3L7cG2it
zdH%G{Hp#qMoB9k@BKA}t!~2Ta+_^v#*Q*<>>vJKPF%Xu6C}x;WGCB=EWc*jsNg@M@
zim!EgBGD!W>a(m+gFcez;{3oNK^h`W^_4E4DdM`E022AlFq?wH=BQ?p&@{?=u|{5>
z-o>UACDy1+%G<;FU*`9<n>f59Ry=0DI}Eoq%Ie4W%$(7><}`?F8X4C&*c{7<julpJ
z`TR9p;R?!{k9Jv@E0i!cl>w(WH$!d8pIDI0D!GAp2WDbC^yTG}y5jujas*HUl*g6f
zvkvrySq^niiR_$043p+7nm3)yhqACdiM%mSHqG$vq7K#t!sDfmS((3=WMrP%7S7V>
zdAm4mDO1&7Tl*~5NSymAf8UhO2V;T8-=QNLP2AF>K}-TH%#r|roU@xh{~(Hyfp0@(
z>p~oEx!W<m)2!({14uW0t*6J@-cJ)HFk07wS4_W{Wo>W?qxsVE21RZH6R{Z-q|wRj
zi14O(#yQ)hk1WirNWg;Vm=D^IT%^{<JY8{--4;}mW|S_N&**hn;!_k|v`OoAuuGk)
z$Ea@-1*9iQMel3s+??z3Dc3UGP}qtl4WlLv4QBNQL3Vcj2~_F^^7(W0kWWU|>(p!<
zTNfQM>Ic2)IrXF)1~($HmRdSkEQa_(o=q(tvRZCq%V=9jVz=kcoZhX7?66yw{808O
zb>?$g+ce84JMi(})K~3F&+09nf1n(PeOSQ=qLS5UMh33ARDzChSL<EQD?<$EYnl}T
z3l>F&FRsDb?sUro2NPasQP!{0C-_vCM#Jgl4qtd?i>Nzs#8@qDJ2M-^d_cnMriF1N
zOkHFV(=snKkg#f9#glEU%?B;ku&&a$lXA!Sw-|{gA?{30rgna(k4z#v>2DX+>R7qP
zxz2ewNBT-6egL`OLdx~Um{sNEwACj6DQI7iRQx8AMb{<5VNIlrXSOXRxMDlzq&PsP
zjApWS{4$q0@T26!)j*_OHZR0kfvF-q$7LEFZhVBvBY(GW(#n44GiaU7H;nue!&;!z
z#3<fk9fQq#NV=E4%%jRSvd<vHroo=YMAZ@|^_V9+R506@<NDdJtVv!+U%1@kGr(OQ
zGL)WUFBpCYUt@Cilt1fMZ1CD(d-1G}z16T;og0V7$;QDLL%NROM%2kP3|zyR(*6u}
z>65ae=4h=}V_R{{Cf;oYE$eDoUwt~ik4C1z;jBy~hfJF?JwI>2V6|=in}F{kMx8-6
zc9a)GAaxVup7VSKRs$l}`@DCU!uIxxVRf6H(EKsZlh-ikkzN*Mx+QxGD*VxKvUfzn
zS|g4-r%f$gvGo!IwyzX%-z!;)tJ+S`z*>~~@hyVquzY3jE9X=0#aX^9VA4x5wC~+e
z;&wmrL;t-{bE(-d&e#Hmlr@p*$5Ur!@lTyRTL#-~xpwUq7|cn_0=lr+px4U$LXS##
zG!qB7Mgd?(&QFL_IPS?t)O61Nx?Q97YlRxX6=}1-@`?|4zk-+q68?y$q=II<oGScI
zMA;dmH4`5T8hNEHwdmPce-p{W>mJbj8~DJcCvuYslAi@B({4M_m)hnvs>JEp3k{v5
zb06d%YRTG+o=sVbX}T3ddaBR)O*Dyq#Bjsm^+dR+Ab7LfVDnU+o9-I!Gk^m1KTWPK
zoVA2RCA^!q63Z`tS(jOjdw<oScd%l<?h1W19T@tzxrun&%=r^rcpxpz&pp3g9Or<X
zc`P>VD2r9YKv8@%)3KsmY)PVzvCsN+C~8y5*gwsqCtNZ)P6+%)%hDqPJ|ldUO4>!~
zw_aT!yF6nn82-X2|EJ?l{${j|s~(CN#ZMx(S3d6?!_I=9g_>LG&lFX?zdn}`!2)Ri
z+?p0zYNRTjxC{d!JQ*CM{<A4{oRYx?1_c%F?#aAD_C)Y|Ges{u*xO(cqh02!GT+Q>
z%ZDzhFmICq$Tux5o`As<Ms{Zs^EO6P$2WP9#<uZuN1L9wc8PY~?B$y2+cXh2yl&Y-
z4x;zX4RlJPD+D7Qsne2e`rr-y88r?|=vg18I|KVuIJe21I!+<#Av+Q@?TcCCQTPwv
z=bPM`4t=x2c4q3S#^n4xkz2!ae2Jl=dAnXYS!bEWi>IxG=$tEiiu8udS8yU|>Lx)G
zsT22@*ZZYCzkR}8idnt3E(XB&(e#1QY(<bS1hMlSVSW^a1gWU<o&Z8F?c@HMSQ2(F
zH&V3lJwy?VvjjgZ)3w>T&Aog=VRNWQ<pP*Ur5GR&<v+nrCea!L!-p+%o0e*auW1)b
z%xk7`y4>Y<GRc*Jm!<t*@SC=(rQ(>|DyEt6^uC*)`t-}%6icsOa8rC<=C#m<J?rd_
znO+f|5l}N8wnbGsKRC@Sg9_@N;Ek?y*0EWYT)yT8G*9L91s`$q_0mfaV#>jY-zj9;
z!+}X;`#vP-ie1Lfd8C%5=dV-~QOe}b=9gSYM-vr2Nga=y9qxWR9@l5*US6SG=M%Cn
zDsR@^QZ?hm6Vm7RsgASK)e}xVal1{7PkwTe+>S^dMg#GEyH?}`=Lu(c%Dbcsp53rM
zUwVkb!zPW*|Gf9C^S}$|QS?bOFH%O}b-M0#J%%6EfFOun1t(st{<6C@FRl2kmwNFV
zVO48bh1V%E-#Jpaa$5=`qboEK{cpL$$;V2~DC5rUfPbG2ks68`MDG_5zZ?G&yKhrI
z9(-1^ts{~*!@c|)bn#WY`-!hP!_n?>B?j<|0s{Hk#qayX5dEWG3*=5tuUeLR$PMY&
zqh>dwTn(^}Oed~gU+-5@B4^lL_q-6VL`$cfKnE~%X?Kvm&-ok*5n}u)x=Fp(60)GL
zF-=sJpN&#}4isu9KV2^iuhScBpych<>XGnE*Nx`N*Q?y@G$n?c1$zo{YtCw_LEW1j
zmhJ`1y_Q&v+;<sz7Um-m7Ro;D6Ft}BQ^2^??GWP{oKu&Nr8#qf#<aG~-S+3Iz`Cd)
zjK;|Bc^<d%qfr=;8MuVOfa-zm*0?@$ohvJu)7|b=#`port933cNp+CUsN)e{qr(|5
zgHqLee1!3FcaP5A@BC`&=M9`-hU3!MNKw%*Re+wsB8VZSy*H;F7YLz8*Tt_drVcyR
zUNDBLr?%8>7)cLRxvX#A%?8msUs$N)7^AA74L~546wo0~VSR;>&JjelCTj;n7iLOJ
zGCi2KtVNv{Nh(HuG|DujH}=`VaZ`uE!21E0s&#P7lSPQZpluPiX3dM&`|kT~isY*e
z`qH?~4J--d+PK$(K=im~Nyc@~Vy@X}rvo3$10D@QL0X<XHb?|eJws5d17K7cuW|Yr
z4EiAfph8$$g8~KlLEE7tK<`GMf$7KwDS3N#)+Ms3rajxb$Hq>#Z+<2lp8DM@5jlE>
z=7IeueWY{C-Ouh~XKY=5yEQr6oS=vU+UFxD5SkOgQXVVpldyY=xSzV|)Y?vk@4hL2
zE179|>{rxYB9>=|&Lb>;ceguywRNq9a@FdD^k|e%rD@-S53PBG)&_E7xl4%~f9D>S
zcCeJBiyDNa0}StJsXR9FzRe8VPoRC1*LaR}kOq_y2yi4Q84-Xqd&y|Nh7vJ{L6nj9
z1Vc(eNXz9m3%O+VFA*%f#N=nxSZ3J+C-Jeuw(eb2w9@CNN+X2sGLulR&#^)$(0-iS
zeiAI3(JVNJVc`jT6@ai2GUUqicr3_H^5!XmNQEB@R6Q7xL0xNEAN^Wfm;W`u5;DiE
z>ePm{wl$p9()f<NPw#}Vub4(dN;?aKqX8M9ly^)|iR|Sf({XYkZ8Nlgkay}aJ0akR
z`KH&!IIZU;*O5bdwhK1!Oo!L)YjLyLcUYi?DUkLviUZI3jFetog0~lIyTtEr>Vn^e
zUueS{*a`=7GTw@;c9oW8tx>FrM>|pD2zIxiFXC%P07M46yjJwXSAVCK^bA0FPXXBC
zC}4e`42|EuT5PR4Qv|Kz0@KblFe2#)lAh6Lf;6=#MOuI>!JhC`_U38}W@ntKK8<0S
zRiM?)%C|`AJ4q1?p18&ZlXWe6<t%<72>gQg+6q>^&K!4@ns#i;;A>m!8Y>z@woKE!
z^d7xLE@{v-P~?rC=beH?1+`m!+o3(lGjQahd|WClRqKb?_H%$!&6)p;)e}L4M}j9;
zaY!GK3sh0o3(|1Ob`*oIq@Ai}2kN@-=ltf>+^cAb+OA^l@Z5SjB~MH$b(84Tfh{D9
zMr9v+I8{e~+}cv}dM<?jK{K5urI7%01n{*9ZCGx*?^A3f5JeCJjzx92cTSHuiM#iG
z<}i=Gln=^0_SyKM@dqt)5J=)J8f&J@+8ZfJ@uChfF29A(?!0OciK6y{@OCd-@V{is
zC1pyc>LC)tuJQi#@l+hf;!7h~YFt0xt@`HETBk)n+!f9qTBx%j@(@67QHR6%7z+x!
z0#d$d?*-zZp6azCFmM)f0uVyAPEb!x)NYrtc>ZwvJDfC3%nLqmQvw4MgO2<sypBO}
zS?Jmi(IG28t&aeS6d>x=)Oo`bUG}jO>9nHjdkrB@D{jN4VijI*9o+^||9R)Lym@o(
zpe=lk*J7=_FoW}1uutn`2IJEScQ5oQ-W01m>)2s`>10}$%AT%q5d;KylhWB=4h!Y)
z8IOt}6X^GfJB*DyuiJ)PfR&pwKO8OF{cxTD<OzRs_FM>GR*43w(c#SZl?0H{fj*th
zBFk#23wfd;2Z;;dj=12_|0v;_E_G8dX9m%xwdB)>8dMh(!hyh?ZRp+ORTjlW@xB?S
z57cC65187+GYVm-u<yogpg8KxbuLblv`jE(Ds8}pWHzsmK*B-g%yMKwz&Cdi)Sosx
z+j{olV9G|n9zlx7;f>ik^7+G#*O!=9(Mbcy14SL0UY#>NTgthDG+rG*BfPq*33F$z
z!>wpu%`}*#_DD_aTM&0R{E~;js<X;a7H5J<>yw-|o%g&bl1Swypn*SpyCGuaq6STL
zaj63mh-7>ij(Bt!6lfOO4o1=M8+|VoKbHdXn_vyfw{rXH<%cV%97Q5X%r8YGNOY0T
z1+V<8a@1%(i8+XCQnSgkCNsj?3(MLcN2J~=0yYW`yRYos`L2%+C|Q)nt?4&1rUV$I
zTk(?2^|VGm5tp5369agcU@&aJ&LAYB+vE9+xtV&cOZwlhc|ei6UdrhCZLF3{=b-r0
z47Q}O)Ijd>Na9DM0vgo0O_>JJ+tMxF`(7<xae#1@aUN27CQ*wplekNqR5Gbr1iS-f
zGXn?JDUeqXLPQ9y1pwN?0|H!!P=PX2r}vVu8QQZ}P-PEJZREY4+9;FzH6Xs~oUeSX
z^S3=;=CF90x$96V9qy5(?+$^ph$o*=dNlSwV14j>vWA~<BDd^MV=b5N7IkI@g=exa
zvNlu?UJ*jQHqc1KnzvRh-44$)t9AA6BhgPqx^QxwG53?-kT58?dLk%;lNiFg8V3g4
zAMG;s=z`C$^_%Z!^|t)J_A5)!DJ+9UC<!?rJX9Y5KFt^Sn@{s8-?_d8<R>f$ArF4N
z8@~s@eeQC%&>9n0F6J}jQG%4_#1U$dUxh_GwYWcyeh4yZom^GE3JVjDJtZXOpf~q<
zD8{K77tqVMCW6bMtOrg!6^N0`OD$-B`j{t$c2rb6Y9*E&g1YGOCTZ92k}Mu$Nhj%}
zx@21mMy~Q7V3-I}Dh;qc<U!gV&CezmSl@bz6u{&QzeBjkn3zwmT{T+U$+ZymCRz?u
zvQJ2l<$G=Vick6`Q7ur>Mn<*!P6yt!ja?(WkqJ0u_TYy|AC<g5svlpPxN>u8<57KH
zW+9pyCn0(S=n}y+N2_p-XI&R-VTPlf0vwMs4H*9y1Rl(SRTUg|7BWiD#*zm{!^T8S
zV8CUDqY0f4nFo)y#D&`%-}~ak2UW!iK!W8mmI@;wt)rMg+MAcEzg+^@0YJ_3rd(r&
zRLfwb(<GRfc+bmSpu$knSTD7qrWrB%cAQ)#N<IcfRILgIgvA2Xk-urx>+X+c;8Yd(
zkE-Au@T;0KWV2JB8212Fsx}LtwQc6PRNB4is&31{3lMmxA~IH)ev8$HtK9szV}B<d
z()RPRRm3RAXfSEYV3;%eG$&W1%#DS{0Ah%t13rh$ycA|4Q~@(Bpsdd{Ia$zbeQB-L
zPKF$l!*wX!a(YX+>O`a3vR5{0wcJAJl}KD~^A{CSNm-(;VJ8@5?@5Vm%(VkaP*7sV
zRX&21pCO<$<^bkAqKce=+<M3dJ?{zaSYU-JcEqzve7p<S?jVOsIsbMmp{!Tt<Af+_
z8umBSrFh;2Ftz)xNCX#GC{@eOR{Dj4M|Z3B`Jh*B5VLaGR~GlZGnPTs&CBoBtXzQ9
zpTYbtLc^~vNQv6RWUj#nF2KoFz)<)uE^d7ga1$l49+*@0k@Ensm}70o7(8t##2N&O
zw=U~@kSTw;);X8or5g9ZYyFw+0c?8HKsqx^rKh6)+OjStalSqTvKq)8vE&4ZCYNPr
zs8HP;F>V0N{$^&R{}ZJ)vvI`0njw4{aWtC1t^sx8>PW~u6YEg-YN{{nNzaCW?o>!r
zIu7xJe=L-bM>A3>8bE#aaX!H&f;8kNkt=(<F?BA~?&q5~q*co!So{IXI@cJ38Y<F$
zvnBw!`L>-)|DW(e)t8<=yVEC4?IU=lc!IKD8ylf~4u~@d5@4U(6_KE9*^gl<yFRPN
zBXkn4#2$<%lYC&A#~u3^@->1*EZ-9~GV}emS}*b9<oT<=G$bB5TgoP^x@f@)2dwT+
zkJPhq`>iUmdRy2guq>Zd&x&AyP2#>t6aaudU)1u1wDDdeoM>4QaHhUImUM>wsFgX7
zQP9~ZK-ciAWH*k60R`rpYj+|_*J|v;ArV9s=s@h*Pf@we^V1LH9(w}WIzd@|qSXnj
zw=BDJ9eTnf_T}mfh;U0HSiUxL%20Zx&%>t!KjDbE$ysdByu>}H8l}SfKMpBLzy*8u
za^h6s<LVQj-u{F=*dGZTinC%M{KosKJ<s7~o_X<)g-X3t+GzQX$J9+*zzLk)#`IGg
zGeZ;~%uv|@-1V}zV+-ginS`}YbUQ9&I!6&$mueEgk_y;O?>O8qBN%3?QkIkD$vZTK
zHeTIFrG-*?a_&#0Y0j+PVMoctf+eSn>^a~&&5<hK*mHtH`POwG(uqVwYwEs<t(^M6
zL2xv>EFVooue6pwNwve5mbPp6Z4QzOOP@ZO9l`QinSSI*{|eRw;zcWWoeSt7fDyzs
ze91#wy^;7UaCle~?&rXn5TK}|B#FZsI1&PN;SQvli$IJU@3+&7c%q0uJ!npJIq$`?
zp4f#KId$Y(5JXe#*&3IYuJWfIl&@L_I99LAi6MLSq%8t-u2nw;2#>K03rOsTKy)EE
z6iH<EfV!#Ub{CW2c(kU59P>^0`X0$Q?_9!`9z=Z^(w}})`UAtVV&Um)nlZmo$i-pu
zl-Os66^aG59?Xgxn9Zk*L+Z^}&LFTr5qXY?R?3Bd%Yjop3vvp*2$g{L^2HADZirzj
zZ%3Y)HkWwV&TlI$E2IX9t~MYL0WOO(Fr|jjN5VyRKBln|*Qvl#XSt5xsmD4V)G&WU
zom`{LdG`~7L%^;A@Lyd=4#ImUU)!Z9<GNuBn|Mz~##;z^=voRu-b-*Da%jqW9<0D+
zBhjB11f)J|XaE8kA_BGfcz;L5PBKCjdgBKifjx4n2J0!mIp1@K+i0ktfan258wRHI
zlJiW_`60_>T0lj}X9B`8M<66DR2`%p7r-G9`rEMkE-iAqIZ4qZj8h=TEDxvAvk}7(
z3xD%fM>k?)l|1-uOv|GJAbQW9=UETW{(2&Tj-fIx7@E7hYOBK?t*I{i#Jh#*u{DtT
zZnpO(wz<)+PRb1E_N6Uk(gOMn#0Q|+An<c#9cn0RocFRBZXpiipN?{;F`GYYI19#^
zq5Soe+|KCpams*M=?r_oA#)+9CwUyyAEhY)3ALZ${ZX~)ETsAxr8Y2j6<_DCD-LsP
zo1*h)HUWbDO_~027)sWpDW5vwHbEkYS<6J{plIOAK#i>Hnj!JYZ+C>-GjcC$-!clT
z2&CM0yP<J_X!D!voGq})n@{^f8_=&&8EtM|j%g*cC7)H-^>nXKljhk#CRw#&SAFX9
zfyv-;dYy0Ojz%bU1k9?4Wt1{PRW*dJf)t2n)}ND+PI~9aZxp<sSS(zJpVd|V5d3=I
z8>DUk@h6n7ArNX%DEg-LehdQ9DFx<>4#}vUqnktt1*j1&Rv3hSw-T&BC8gJ`4ymLX
zo+2)hdT|lDDHNBW`z@v^Z)Diq^5Ki<(Y3UU>jAg!C5xlr1Gf(=Ch_4PPD8GNAbQDj
zmEmp6N=)<%2sc%tRt#4c@7F}X`+S$?e9jcvf*gVEUkKhUi4X$4LUE;dz6<ICd1L~F
z=GMJ1fY%jR@Dp)sEsi2)?~+L6j&OtITBSpH`Zt_*yl9QL7x046ch2IbwN3f$D4JsE
znxngG{FVJ6D(U*jb1cBf*F~%qr3`;3W`_9cJLFJ&`}()2|0IKA>orUA<JtvkfQGdb
zkWryqM3CWUuTbvg9nj6hH~j|Ev)@;$_nb*<6BIBkeV>N#8xPonOENP~SC>UO4k}u?
z3@Y-3li#T(6i7+%JS}B|3hcqJ2W?X$M~w8VoqkNYVIH}kNOQMy4g_g}y^fmEi3kwF
zdunT3OsfL;Ls*q(Md;9TmFEv)?<7+<p>wFDza6;%wYQ0N6jpI&z`g&&)d~As#=3d)
zI0`vt;}9YGZ>zm4X+DfQa2i<)#0(&P8q2H)R`b*XO-i0)8#+WfNvs6BSKv@rQ3r05
zd;aRGa~2VNzFex*8BKKPS)e4?wKnDiWz|5F0jh45NI=7)%V=}pE7C6Ju}F=&lVS8D
z4L6nAydSQBj&$mi@B7UE+$PY(hIm;KL_h>L;jt!J`7?aVnfY$~>1Zd$>5h8DmNnY2
zM4ZvCc$L>24JQtK8+wSRg3d*6eF&+B^FdF=3deDd>`bDkm*5Zq*;K6<P!J$QU^z{>
zmn^lq++}cuRJs@-qi+B37tcY`NIE&JKx7wk>gpDt5Hdrc_wT7I)5pv2`X@0pw+SH^
zKQp1qjXslkx|csG;%36D?1;tcwTXpgJnX00+b1`{ADmv>l^1iM=gH>m3NNefCCCTJ
zs~+51`c<J;IdW#X)b-bAwwdv`NuMT(jq;<@zTjI-`#n(g-$dl7oBFMzO`0hCTh~O}
z3LfJ{!e3Td%eZA{1l+u59^ZH7^NtSzW9D*v(Japs9t4s{$nd=xDw?w#6(Fi9Egq7?
z6Vgz_<X{F@keEhI0Rq)&IH1zSMPpf^t9atkM*xWc%rdbeZNWn6`@<e~H``}Fj>Uuc
z>Zfi01YNA~c}zJY1yb}h(SS$<*-B}IF84rAnqP+c9sRtDG7Ai4eIkZUpTB7O>Xu?h
z*IIDByVTbyjP2AuJ}$HMjs2HNU@j*1=NmlNPS^t#aSl7&zF8&(a+dN38dO9Ovx^>e
zZ)E0Tbf?Ky0W<|zB!DpgR2~IZE<*II@hB-m1Qx~OOSbp*EK|8%p0)ZDa*aGvu4E0W
zmk$D1lz76IqGq#+)KTGyTAdqtt@Rk)Q<9F#_g+NVl$43XWX)tMiN2+{U>WedCa=;w
zMW`{$`*CaV$qkokukf)2O*xa$YfC%ZX^q$0g#lo~3xFv}6jpX_>H@Ph(BH(5uae*w
zbp1Lc2!SC8&j=_KM4I&9K#c-j5gS+$Us>8{t8VHc6`daURHIv!%_-50b!ipDGFB_4
zV4U)M5kNxMQ?8r}uccR8^Xm|j6<OpUtDcltRFV~2jP$^vM^-sI61z;LM$Va+V@!Xn
z2=QpnYN;zkuFjXVD7G4{R^+_eJy-o^)rZ%^{cEZ_`Lu*f5GOYYxpC#`GON4*5Oz56
ze?JkZfu;&0Ch&d(2!(;yv$u4&+O2L@8OYxw(Ds{MxA66};*%+C5bf&fXMHXjawlu2
zzPJM9Q-K=zvD9d4!(<RuA~$(79VBen+F85<O=R5-dQv(kS?78eimdXoHhiq)Req#I
zFO)V$Hz<U<8W>!*jivDz;zyDD@-2y=A`-RwV*Nh=NhAlQ(VV2jI!-XCyC5W4psH4-
z@Tg0cnYl$^{jSe|I5!MXwe%uBg0~X_^St|RHyu#-nV$<LVu6is%=OKADroeQXQUhf
z3OPKpes!GtmYhVFIbNLRZCEIblnz-3GVir?#xB?s%cDsuux`n(-*^6bRrb@Y4!&)5
zLEO+?I7tmXzYV&gzrru(_RB7DArlOxtpEz&B7%Ffdllh2DKQP(a(>@;44U12`n;?n
z1dQdk2g6rASS;$d94HXWKtu_h?mt|4hr1Mh-Pik~Ob{5&Tz;^^;)pU!1i5#ICUDJV
zVcDB@up-vo8Xa0;n)0k|;FF`=fh!THrO*vtZad@eZU+YgD@YhvQ-y(w`ero4){jKS
zt+Vq&BjxM7$+GD>Z7FMR6g4Ve?egZk9Nn?26_175NCjGOtD+#ys?vroe{2bgThpiG
z?d^KLR!&^@Ij;^NFM4q(Q1E~~(XMxb5M5snP<+!~#_wxeXtFG!LSP{S;_wj}KTR5}
zXP{NmF9qIMCJbnDcADRvLML7!-BA%RMIHkrSs?z)$E`NLVOGx|<QHUgLmv<C@g$tL
zmOQj`{oUJ?p4hTpq%>!1TQIWdRyksgUgH(jpVj5|1eRd<!v~Oug-w2L8@x;tP%*Y%
zkXYk>t(IAKsZ_->FH37&vB?(ut$MiXj6BHrLHV$^VJE80s3v6qr^G)DK`0Q!14Qn$
z;<2T?<1$B%bLXi+q}K&zAyzMf(*%VCfE;y!hoRt%4nzxipL_6mQRzu*UFVlJwNYY)
zk&@ZfM-tvm-PRGO1Kx(hKQ~zo10;c3{p)y~lCXniS%quBe2FC|N6x4Zj&C)F1dSQq
z6uD_!>*&g@NxE2MN9+S^gg1ku04m$v_zYOH@XVCzCqA-tu`ej_(=iOm59~xvD;6Ez
z^kRH`OAj*lvYl&cRm6JMbF1?X&^pX{W+4m0t0(XNI;e5lU}7MQ_A6uF<<ku2PkQb>
zXPwRu)c?K+3T(WGwI{qMM>LV^)p|Eiahm9x!Rk#QZd#ydg<D-JE#WF3AGTEzodk1>
z0R<)>IrwFh@{z_l70ZFJ)~1B_=?yN;1LW&P@zYy_;_!nzs3u%t1dFdej=e~`CvaRF
zz^O=E-7KW08tF$6fl7Bo<lsKn5AGQ|Q3kRkOER|cQ2;u&w2!a;?T9v`2k};!GJrgv
zqgeW}ZOj}zK&UZb;fex?71R{ZJQ;bWgCgdcdS*C`sI~tENi9P><If&ZGI+&eN~<4j
z%cXWv<~soidALb)lSn;n^lsk1Wk#OyTyA8)H)mT)F>l7G&)RQSzS0qetI<)?Z4yo0
z6=xeigD=m$@$;X$LjR?Ls5_hg5VpQTK^?vC0pw{YU@rGp2>`AI!>=c-2@KqB3CJIJ
zFMp-00ODFr_F%QXH)BM?AQ5z0VA>Y3*#|T@JF85E-S2H9u19pUvC{-(_@Af`L9y`D
zR(B;jR@h~DrCYp8i9Oc``q;*ksLmbo^HG)OfMXE@x}x@_yi5E;NCu4#@6tC1yQiCp
zh<x;$-CCE5)i7K_g!@qGupO+A#Lw(rWZHMyvm964!iX1X%{KS-gXIRM291Wv4Nso7
z`gu~uW*F<LSDD&!yP0io1eJDqRQ!{;lmWj`-e8fQja<it%E6P)QRx=U<!vMoM&|VZ
zJ+JxSeTDxl-KvFOU0PlN@6-gvCXfRJ(FdNWzTRB-Y+zAYC=51g7iRFwYw8O;BWul?
zQ7z2*c5Vbq`YKFMYJtGhg`Iq(<d3!E)}m|r8eD09p0aRJl=nn62O0fV%pkMzs}KX7
z9Kl6aXvv=C;O%RC1N$!ZD?SC}73Z6V?M(H=QFJppT*yj?tF(ednE2;RZWycDd)JyM
z)rUIv_C-^knr3hCL>&H*TkaN5UAX;zO^{pZ=CqZmmr4@Xf)*IwO&Hc97Q7t8L0ok+
z($LfE^eB-G>StYjV80T%?rtfcR~CUD)eQ{(d4pfGOc3scpE>xTP!i?SO_kMlDKT_6
zUyN#SR*`A5;1}7V8;iBdzl-vAy&Koy-;cHN*MbIE_AHzyA~gr7IrMrT)0S;xiv#Ls
zA?it4x7!WXy#4T~oWwBx&W-aEzkK+wweyi>d6@OxySj!R3EL-EMiv@`<Zk6mRkdo}
zmAWE7S~P5JCiE$s-jvU+;P(mB>FRtE=gQ*bXD|yp`CU+yC=a$h8TAHM^{KFOe)_Zu
zBX|^6@6|y#>5{o+dq=%@-iuKKCGb3Htzdb=(b5;7F9D>&)R8}I<oZYsKJ7fK%qJse
zyZkF+{q=n1HXp{yqK4N{Rdee?N}z6LbCfba!>b3Jg8M@fo!uAgIgrz!mZfy58VFzA
z2Txa=#~?qRhckB$4wd4usOlU3c~{NCUzKvkUB$4Q?vBtK4TeyW4fF_i?ygGRaOd!C
z)SCFqZg<$~ZlKl)1FD#z`;Dz|F3iiXl=U{0_5~OnhYaw2xG%-m-9ZU)c*}+gwHBQ8
zq<j3@?8X*s=+d_w{Uy2tjx(6+5dfahij6s1C$gFvX9Apc#Q+U>Q1dvjD5q7M0>T|R
zD;}sf7?IC6QT4>-o?&Y9q9Lem++oN%NPGpW&Y01)B)%huMnL<PRxUWLBsJT>(KqBj
z%`O3wjVjCDxlqnfLY3imJ*J#Q3$<IS<=l@&JEJQ;UL6U`8__lCR<HFLc>2Q!#|lk)
zW;{-XA#HS49CpbB_t3Y;D``~a90a;pFlb%<;>XlH?YA(`rb^v>SmW%-%gSv#-1KSI
z*~U|C`Vm-hX3rYBCa~5wthqul6EOVV|J2l#LC&v&l+Htf{8W3geZ7hATXSTg*_Rkk
zSHJR^L_>UU05&~<Gr%epOWO!+<WP<LFLtb6#I<*XLU#LeK)W54I#fDh!JdWqK7ZQb
z7XTkbf_W}s9a{XpqONM`a|(HCjW;Jc@HCGJ4Xa@Di$J~R`1C?63qGhR(a3cpy~qth
zDL5^wT;0;MX2_YLU$w`=<dcm?bg%*SqVw<VVBGZpfN@e`1=JfVs*2UKoNge_0$`AO
z)X9BtKvhuk?RN)0nh%=;^Jc&Hsd;iM!}O8&V}-*5Y|3@EHvk;I6&m!;)kfCRbfhTE
zru;e#_BdL>63a8%r-+0(Ek0Q<Dl#{x9_vM}tJT2m<k3c+aaL$ayPINdv9aUS5+iYa
z{0!+tW-=lMIM#-&r%oAlKbWy$L-wm0?7{V-8&?x{;!p5kcFukFJ|B9~UIJ%3WH&=B
zBQrx)23ExQ>PrCl<+sv|z>%&1v9W)Cj2>s=cj`gm2Vn@7;w*R7A>{bJgW~zE!`<H%
zq~wpnV3&n$WCLMd!fnHM(BZsS{60s*#3OCKdYg212lHxIn)o!LOYf>vBhu9B`MPA2
z=GVT=x1ENNXt)j1$)jh4yE>i;O~!PWj_Z@)Z3N@Wt*csO^zSW|Ad82rAMI(h+6a*~
zgo!+0RP4`qI=T@GqZ)a*e+h@Ef3&^8*J%3V=G>PxJq~<~sQPA~mRy3(CjAq+59GZ8
zm#cUB(?@YRjqY|iO@o*3;se#<PZ*nwOcpA5<cR+OeM(jIkc5a(c*xlTy!?1&8;HA<
zcP{N7tqeZG`T(xnKD5MSW%V^V=tGYl;6T*e6xsHOqtX~5Wl7>SoGwe8gezL;EuS8n
zVQm0qF<9hBDu|T*AemYN;c2YC`|yLe5cj=56{x#e91^vH=A-ps=n+2i-f10~WY_B2
zB<dHdS+}!hq2$JQgZWx4DsmL(mp?8SRzC{o;hX1#Zn403^dNg{pjbo^3@TYi{On~m
zFI)!*$paTg6}JJ&3}Sn<d=^4Mzh>h8v`?<6eZJud%`K>F#7+$B=ogL(vlQDQSJ-Jp
z2?-#TYY|B0RYOiNe^z$m@`C1b#4j`jt?tP$f^gv5#%882AJj#|dSqRZmxSn6{F@7U
zSfh7NLT(&MYej(nxQR^4UjC6g-50T5uaC4|D}!vmYv;<^z7^&TR!ZS6RgB7xcKMI;
zfL;y$A=CmUjI@1o9fJG~)%#LF1m*FERinZ8q^}sgeQ=Ulh3-?Wn*mYKvtZ9eUkJb$
zeRDs)BC{KYixi7Bo#Ya_{Gil~dseNWD*Bl#6qj)7(eegg4(?||;IfqcJ9(q`Tr3#I
zZwF6|=-b+86?X%#Vms35m#-vhX*)0!iWAm&7rg7F^&0aqkUv^Zv-|^0sON3|lMvsZ
zdN&W%`)F{Lt5aV97g-ew6ras|qNSL473i_ND%RmDq}50U!L##X5Qpad&Q9bjgc-5}
zb&5z{hZmo!h~mqUg3YCcQ0o&}viv`!WdZ(%;@+NGD_e|^d~^76&DX86M-f?*K3>)q
zPsCr4Yt`iCLbObO)HlcVYcsQfU`9JtY5;3syg|{d?E)CI!~2Al&=3l4ry4KWJ`(46
z-o?k0V{+b|tgebW+HNyw#&1nFBokB}Af@Vz5n0^1L_1n4RG+>)6+hYM!~Zh43w}G|
z_REm)Jz6HIkL!;?`Bm^Xvsvw+ApVQN6OJ=)Nh^ycu%0@NKQM>Se^ev3WF&ySfR1>b
z+NSkk2*~B4NFprzGXfQQD-f0ev5yg#O2n4@SvA)hM@aUCZ2&m#!gw%m{r)T@k)Niu
z9N73Lg7Bf@B>2P0N309-{VO}K4!F4o0S;+0fb)BO=T)z!wDPB<mq}FhaENey)_^;E
z@C}nCtzb{0TlZ>U1tZ0*FjtiaAMp##+ip+$a6WzG<9)@r&LVZyo`sE+x_m?uNMF>J
zCT+^->=qU0b{Y3h^HOlMuL)4zTyXtenmx~N*l8r9W>TLP3&1`49wI{`UwtDUiS0U_
z8MvLW<7!3a9H>%J-;@VT_|*#V6w6ORf(58TV0~;NC_FH0PyId!PGWGn&5Z2oapYZI
z;=uoYA(Siqo%>OTs>{lA#cn%PV*dW+u3}=|V{EG&S?Q>E7NHn(mfZR#9Xrr_#Mk{|
zRMvoLJKl!cM}rzMq*}aCtPYzoqxS0)7=KjpNoXDYQ2vTpENOn*aDCI6%Ahce3;yIF
zMZRbZDze(WAB0UjTTTdLF%^E${e>pG7hMq}2Q%n%^0boCGmSI`0Gt)Z0vX1E3L7lq
zrQbOJr85H{cNwlH0?;ik{viIa4WwKubOnJ#$mhhDY@l>gsqcA>WKCc)sw9klAM?qi
z@5H`-1Stlq4Xl4H2xu0^szTEr(yWxQW>0D7G<)MM-hI$uKQTEVs9)6v@aazQ(F7w1
z(+e7!rFZ!g-sCOe<QpR1l=FhOYGP9uwqCim`V6SLkC%7idA9S0+)ahVpvba&)|&;1
zzpwSC55Iq>)+Q$1?`0Zx%$#an+xr@zpuOqFHR154q}fc(pf3oL>4EpwdqA_6p1-vw
z-Dj4lRljtJM9lB@YGu^}RtctQD@Kuh5oV0jBRh)~y4R*7uH>N%1KwU205(E3ga%7s
z&wvR9o?efA%MRuMJ3+xo8EVc^u2T5PsYt!Uh_Y%~sAf#VWFRZdIP7J<O_-(@cwct+
zC|C`*`P3ox$B%;eruU{&zG$MV&&>1l1?^MfTF6uIb9*P0p1;afrS^@TR<ZkWKL}q*
zW`13Uunr&8tvLStLHO}=TmrDu{!d$@AiTHizYVc<1_R2Y|83QtM|SDIn?@!6bLHb5
z%Zvon<$s#n2f~u;|7jIlaY>1|>qpz9jTg#6N#buaa(mqIch}!-AX#Z5u(|$EGmP6}
zA=je;ffH!7TyVhH`P*uj<C0{ta({pR{XfF}amP>i#iO4Ic@J{P{_cQCU-|pM5&xgf
zr~c>YoS2vxf|LVh+3}+0yKN2oPqp;0|6CDqtHSI+%vtw%WX->L|7YBp=?mI%KTZC0
z<kSD$QP?yQ`?8bs=sMDrL3)JH__!hL|ISlR(tkT6{I}~`+mioIS{a5N3WO|(MQJGf
zcq{F5FUP~4{|+ui@Rstv2pmuu2+f=xUGdNP)s3_5Tr|-~JF4^l=YHBpm29v_Z*=PE
z(E)^iw96bF9apDbRBrE1AWe=ZMZp2w5Coe49K_7M6uWci&8~5@1;I9k2g&rGrY%P2
zp#;19XF5%=U^VsMcBZWlbSC!br*yaKe@9YWOIcZY_#lw4QZlsgcMAQ{F)B{uA@~yA
zoWQ>qfJnQwx_E@mY=ROzXc-~s|BBpoLP;95@OMj~!vCkK{B%#mI`<vR5aPk-xWOv9
z8K8`R+M5bW4~eoDIF*jL*SbgBq%jxW{!t@oqiMKDSSfhVIH5JxZ-Mu%{AoAm8ygxL
zb`F>8u>MHR@TcdGwx^}f0s+eWZ<kAX=hiuYc^_XQ)PL#UH(%s_Y?49kn*gYr&@Aoh
z|2tL#VId(Qfrl%BsE5d&2+iXgr+r-km*@G9N-$eTfF91&9?v*+{no$Apxs;1ZuR2o
zpGVil{Z~K7%I~gw5X30yv|`3_*SgwHtnL3JIFQ_r?y>r;Da^-0Rk!jVL!xk7=;&nW
zj)O~<$DQBEx2yb*#h?yP?aaKdMF<wbcMVXu|0sP|J>kK;$b42d<U2f)yN?b*ps#?5
zDH{7@R|(s?9u6y`E)D4%?U(jx1|KB;(-5kYi(o_-j%RV=j%3-3%*p?r8K{)1_0IO#
zY#LVD{723be6mC_3LRm5m5lOeeI=2jD>B>Tfrb^q{+J-J4Y8ZI0Pc`|JTQ7$|I_~v
z_{_${LAH8_&urMy`H1#~=%s%J1JOY>`)~IuxE%ju(B?8#j!u4=<jIOX9_w2861du@
zKW3D0K@|fzF^qz$R!3oy=+O<NOH&#v*^mA_`iE0Z_|N1mT(UYIf1`fE5wPO(Zwn)6
zaenU!uN64w>;sNJgWNtJKUmf60y~~k!m)EG`&6vjmrDe`J7~UUoR$9?s%j)RJwZ9F
zSY{W0Cm$VvsCI7I`d3DzCkX~LbWPg8OX8z5CiL|2Whw`xz?2Y*+ke~L`r26i$9<}T
z+1HLXrIn;7{k7nP4d&q;GAL8gZ?-z1UQ1{dMK+cH+7w9m6i_y3*@f*oEC_-Xy;Y75
z8V$sR91gTH&=&>y8`1lOokE_MIo(dgTf=aYw<GM*&6o7al+Mzkxm?;EM9v7VcE;x>
zeX)IyWULQa@$RPL4Wt;YAfL6Ojr{dLJymXN<;7GwgiV-SctIG4n>f~Qo&;JVX!L`v
zU$K?h1|g-}gaN2G33*=Ty>#41#Os0jWbC@le&~b;(+fh#dh@p_zLF4NgC;l6>Y;?J
z%w7r+pT{i`hUoNKt~ba^2@UZqqjG5rk4W)UaID1o6E@-V7Y96^c>I~A`GpP~T_6kJ
zX*Ys}$$dH!!map$a2Pmu0`kjhqz83X@}te>J~!B6XeJ2FDPGz*+6__B>)zToV(fCJ
zfgXtd{6;uKDi4}JGq9V!PH}w5m4*EdoH;&mepjW9(6ix%2g}D+w7QF)`?%XT2;ZDT
zaFh>MRvpi8brStu4<%oMg55HD^+)a5aHGGht{)vrdg+e?x@95v1$%#+a6!uJf2^wE
zYJeQ--7-OW*`)v8i~DkrKIIr8zPQZt_c+0ThkuScZ%tW4*asTF+J?7*$F~a_oiG+1
z)*Wp(!nNr$m5_2HJ&%)*h7W{FOP{|dV}EVF9=P71IK}~vuzz3q@bA4IDb01@(k#)B
zuku#L(Zn51=Cj!6eI*-Kv&Yg2S!N7*um4b^bBKLM)q^lk&4aQdJzB{R!JnX2$8W26
zRJU16{e(pf6ZDV22<pi5r{AOC<AX=n4`lfOm5dlBT%UghNw~h+-|Od+g;cJK_WLB1
z%dcjy6RhOtmv&IzlgB0tLLZ`|=i!}ciH>F|fl5*zby2MV>eyMb;r-7gtO^44Ly|1f
z1>iQVWRF2N5b4_NWpe|&Wq&8P*I(xW>TAZVZOGvFZo)JvW7!&PMtWTT87RpXQ4b{_
zJ#WloM;#Xe>`EVl%K`s^7W2OEA>rg4<Y3*=$-yIR4N4<DTmPJ#=yg-VP^*|}w-xEd
zQ%(@q%{eP1|KF)foiYc?q#-aQ=a-3!NG<{UtAn#b^fqkv^*sJ4T&R8MFTz~N`E74h
zEQ8lZLflYr<UnP%)*Dyw12pL;4;e7Q87buoj?oiNeXL;9a+Cg@?>YbW<8sXXby4t2
zcOZ=?MnVSP!3a|Vu#^#HP7ekRrIMc%Rr=vD!aPW2@$0$3sE+0g{0wnM9^E~VMF?6M
zN|>qY29KZieH;I%$LIWzV1gicD>#N-L+tCh5X?OLC~E@@i3heo@x$@05F!+qgNNPD
zfgShvBEb>61TMfiqWL=w^<Rv^Z(+7*mJe5Duo`^?VFc}#)E8`gT9j?%H3aNF1i0+#
zB|2GbePuS&zn7%M9DK2Xh#j2F1t;t=CH~QX`Ij>r3}8Hd+V8_7C-UcM!Cp4Q*lW%(
zFtF+#pb|!C^f!Lt&Z`riy(ai}mLlO2^;RLz!zMUnC(xWCfbmUe%5P@i7cx@B6dl7~
z$n-vTxClhiFt`V*UqG%GBEAJC%JGk#h~fN&Bf`8hsyDdfn|H$q*qZ9GtdYGJMf+Rs
id+(ke4}+oZ!KuS*?2X?;)@ulthsr76&yg{F_5T2W<Ass{

literal 0
HcmV?d00001

diff --git a/nanoblas/docs/_config.yml b/nanoblas/docs/_config.yml
new file mode 100644
index 000000000..8c8c7b65b
--- /dev/null
+++ b/nanoblas/docs/_config.yml
@@ -0,0 +1,60 @@
+# Book settings
+# Learn more at https://jupyterbook.org/customize/config.html
+
+title: Introduction to Scientific Computing
+author: J. Schöberl
+logo: ASC_Logo_transparent_300ppi_RGB.png
+copyright : "2025"  # Copyright year to be placed in the footer
+
+
+# Force re-execution of notebooks on each build.
+# See https://jupyterbook.org/content/execute.html
+execute:
+  execute_notebooks: force
+  timeout: 300
+
+# Define the name of the latex output file for PDF builds
+latex:
+  latex_documents:
+    targetname: book.tex
+
+# Add a bibtex file so that we can create citations
+bibtex_bibfiles:
+  - references.bib
+
+# Information about where the book exists on the web
+repository:
+  url: https://github.com/JSchoeberl/IntroSC.git
+#  url: https://github.com/executablebooks/jupyter-book  # Online location of your book
+#  path_to_book: docs  # Optional path to your book, relative to the repository root
+#  branch: master  # Which branch of the repository should be used when creating links (optional)
+
+# Add GitHub buttons to your book
+# See https://jupyterbook.org/customize/config.html#add-a-link-to-your-repository
+html:
+  use_issues_button: false
+  use_repository_button: true
+
+
+# parse:
+#  myst_enable_extensions:
+#    # don't forget to list any other extensions you want enabled,
+#    # including those that are enabled by default! See here: https://jupyterbook.org/en/stable/customize/config.html
+#    - html_image
+
+
+
+
+
+
+parse:
+  myst_enable_extensions:
+#    # don't forget to list any other extensions you want enabled,
+#    # including those that are enabled by default! See here: https://jupyterbook.org/en/stable/customize/config.html
+    - html_image
+    - dollarmath
+    - amsmath
+    - linkify
+    - colon_fence
+  myst_dmath_double_inline: true
+  
\ No newline at end of file
diff --git a/nanoblas/docs/_toc.yml b/nanoblas/docs/_toc.yml
new file mode 100644
index 000000000..a11c4d6ac
--- /dev/null
+++ b/nanoblas/docs/_toc.yml
@@ -0,0 +1,11 @@
+# Table of contents
+# Learn more at https://jupyterbook.org/customize/toc.html
+
+format: jb-book
+root: intro.md
+
+
+
+
+
+
diff --git a/nanoblas/docs/intro.md b/nanoblas/docs/intro.md
new file mode 100644
index 000000000..308b0b740
--- /dev/null
+++ b/nanoblas/docs/intro.md
@@ -0,0 +1,73 @@
+# Welcome to nanoblas' documentation!
+
+
+nanoblas is a C++ library for basic linear algebra operations.
+The library provides template classes **Vector** and **Matrix**.
+
+## Installation
+
+install it via git-clone:
+
+    git clone https://github.com/TUWien-ASC/nanoblas.git
+
+
+To configure and build some tests do
+
+    cd nanoblas
+    mkdir build
+    cd build
+    cmake ..
+    make
+    
+
+## Using nanoblas
+
+To use ASC-bla in your code, set the compiler include path properly, and include the header files
+
+    #include <vector.hpp>
+    #include <matrix.hpp>
+
+All objects are implemented in the namespace ASC_bla. To use them with less typing, you can set
+
+    namespace bla = nanoblas;
+
+or even
+
+    
+    using namespace nanoblas;
+
+    
+
+You can create vectors and compute with vectors like:
+
+                 
+```cpp
+Vector<double> x(5), y(5), z(5);
+for (int i = 0; i < x.size(); i++)
+   x(i) = i;
+y = 5.0
+z = x+3*y;
+cout << "z = " << z << endl;
+```
+
+For matrices you can choose between row-major (`RowMajor`) or column-major (`ColMajor`) storage,
+default is row-major.
+
+```cpp
+Matrix<double,RowMajor> m1(5,3), m2(3,3);
+for (int i = 0; i < m1.rows(); i++)
+  for (int j = 0; j < m1.cols(); j++)
+    m1(i,j) = i+j;
+m2 = 3.7;
+Matrix<double> product = m1 * m2;
+```
+
+You can extract a row or a column of a matrix:
+
+```cpp
+Vector col1 = product.col(1);
+```
+
+some changes ...  
+
+   
diff --git a/nanoblas/nanoblas/__init__.py b/nanoblas/nanoblas/__init__.py
new file mode 100644
index 000000000..743fe69e7
--- /dev/null
+++ b/nanoblas/nanoblas/__init__.py
@@ -0,0 +1 @@
+from .nanoblas_impl import *
diff --git a/nanoblas/pyproject.toml b/nanoblas/pyproject.toml
new file mode 100644
index 000000000..e83f954ee
--- /dev/null
+++ b/nanoblas/pyproject.toml
@@ -0,0 +1,11 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+    "scikit-build>=0.13",
+    "cmake>=3.18",
+    "nanobind"
+]
+build-backend = "setuptools.build_meta"
+
+
+
diff --git a/nanoblas/setup.py b/nanoblas/setup.py
new file mode 100644
index 000000000..b1edd0eca
--- /dev/null
+++ b/nanoblas/setup.py
@@ -0,0 +1,17 @@
+from skbuild import setup
+
+import sys
+_cmake_args = []
+
+# if 'win32' in sys.platform:
+#    _cmake_args += ['-G', 'MinGW Makefiles']
+
+    
+setup(
+    name="nanoblas",
+    version="1.0.0",
+    author="J. Schoeberl",
+    license="MIT",
+    packages=["nanoblas"],
+    cmake_args=_cmake_args
+)
diff --git a/nanoblas/src/CMakeLists.txt b/nanoblas/src/CMakeLists.txt
new file mode 100644
index 000000000..900c71f16
--- /dev/null
+++ b/nanoblas/src/CMakeLists.txt
@@ -0,0 +1,18 @@
+# nanoblas core library
+
+set(NANOBLAS_HEADERS
+    vector.hpp
+    vecexpr.hpp
+    matrix.hpp
+    matexpr.hpp
+    lapack_interface.hpp
+)
+
+
+add_library(nanoblas INTERFACE)
+target_include_directories(nanoblas INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
+target_compile_features(nanoblas INTERFACE cxx_std_20)
+
+# Install headers
+install(FILES ${NANOBLAS_HEADERS} DESTINATION nanoblas/include)
+
diff --git a/nanoblas/src/bind_bla.cpp b/nanoblas/src/bind_bla.cpp
new file mode 100644
index 000000000..db974fd7c
--- /dev/null
+++ b/nanoblas/src/bind_bla.cpp
@@ -0,0 +1,72 @@
+#include <sstream>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "vector.hpp"
+
+using namespace nanoblas;
+namespace py = pybind11;
+
+
+PYBIND11_MODULE(nanoblas_impl, m) {
+    m.doc() = "Basic linear algebra module"; // optional module docstring
+    
+    py::class_<Vector<double>> (m, "Vector")
+      .def(py::init<size_t>(),
+           py::arg("size"), "create vector of given size")
+
+      .def("__len__", &Vector<double>::size,
+           "return size of vector")
+      
+      .def("__setitem__", [](Vector<double> & self, int i, double v) {
+        if (i < 0) i += self.size();
+        if (i < 0 || i >= self.size()) throw py::index_error("vector index out of range");
+        self(i) = v;
+      })
+      .def("__getitem__", [](Vector<double> & self, int i) { return self(i); })
+      
+      .def("__setitem__", [](Vector<double> & self, py::slice inds, double val)
+      {
+        // auto [start, stop, step, slice_length] = inds.compute(self.size()); // can do in nanobind
+        size_t start, stop, step, n;
+        inds.compute(self.size(), &start, &stop, &step, &n);
+        self.range(start, stop).slice(0,step) = val;
+      })
+      
+      .def("__add__", [](Vector<double> & self, Vector<double> & other)
+      { 
+        if (self.size() != other.size())
+          throw std::runtime_error("Vector sizes do not match: " + std::to_string(self.size()) + " and " + std::to_string(other.size()));
+  
+        return Vector<double> (self+other); 
+      })
+
+      .def("__rmul__", [](Vector<double> & self, double scal)
+      { return Vector<double> (scal*self); })
+      
+      .def("__str__", [](const Vector<double> & self)
+      {
+        std::stringstream str;
+        str << self;
+        return str.str();
+      })
+
+      /*
+     .def(py::pickle(
+        [](Vector<double> & self) { // __getstate__
+          // return a tuple that fully encodes the state of the object 
+          return py::make_tuple(self.size(),
+                                py::bytes((char*)(void*)&self(0), self.size()*sizeof(double)));
+        },
+        [](py::tuple t) { // __setstate__
+          if (t.size() != 2)
+            throw std::runtime_error("should be a 2-tuple!");
+
+          Vector<double> v(t[0].cast<size_t>());
+          py::bytes mem = t[1].cast<py::bytes>();
+          std::memcpy(&v(0), PYBIND11_BYTES_AS_STRING(mem.ptr()), v.size()*sizeof(double));
+          return v;
+        }))
+      */
+    ;
+}
diff --git a/nanoblas/src/clapack.h b/nanoblas/src/clapack.h
new file mode 100644
index 000000000..f58729f57
--- /dev/null
+++ b/nanoblas/src/clapack.h
@@ -0,0 +1,7254 @@
+/* header file for clapack 3.2.1 */
+
+#ifndef __CLAPACK_H
+#define __CLAPACK_H
+
+/* Subroutine */ int caxpy_(integer *n, singlecomplex *ca, singlecomplex *cx, integer *
+			    incx, singlecomplex *cy, integer *incy);
+
+/* Subroutine */ int ccopy_(integer *n, singlecomplex *cx, integer *incx, singlecomplex *
+			    cy, integer *incy);
+
+/* singlecomplex */ VOID cdotc_(singlecomplex * ret_val, integer *n, singlecomplex *cx, integer 
+				*incx, singlecomplex *cy, integer *incy);
+
+/* singlecomplex */ VOID cdotu_(singlecomplex * ret_val, integer *n, singlecomplex *cx, integer 
+				*incx, singlecomplex *cy, integer *incy);
+
+/* Subroutine */ int cgbmv_(char *trans, integer *m, integer *n, integer *kl, 
+			    integer *ku, singlecomplex *alpha, singlecomplex *a, integer *lda, singlecomplex *x, 
+			    integer *incx, singlecomplex *beta, singlecomplex *y, integer *incy);
+
+/* Subroutine */ int cgemm_(char *transa, char *transb, integer *m, integer *
+			    n, integer *k, singlecomplex *alpha, singlecomplex *a, integer *lda, singlecomplex *b, 
+			    integer *ldb, singlecomplex *beta, singlecomplex *c__, integer *ldc);
+
+/* Subroutine */ int cgemv_(char *trans, integer *m, integer *n, singlecomplex *
+			    alpha, singlecomplex *a, integer *lda, singlecomplex *x, integer *incx, singlecomplex *
+			    beta, singlecomplex *y, integer *incy);
+
+/* Subroutine */ int cgerc_(integer *m, integer *n, singlecomplex *alpha, singlecomplex *
+			    x, integer *incx, singlecomplex *y, integer *incy, singlecomplex *a, integer *lda);
+
+/* Subroutine */ int cgeru_(integer *m, integer *n, singlecomplex *alpha, singlecomplex *
+			    x, integer *incx, singlecomplex *y, integer *incy, singlecomplex *a, integer *lda);
+
+/* Subroutine */ int chbmv_(char *uplo, integer *n, integer *k, singlecomplex *
+			    alpha, singlecomplex *a, integer *lda, singlecomplex *x, integer *incx, singlecomplex *
+			    beta, singlecomplex *y, integer *incy);
+
+/* Subroutine */ int chemm_(char *side, char *uplo, integer *m, integer *n, 
+			    singlecomplex *alpha, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, 
+			    singlecomplex *beta, singlecomplex *c__, integer *ldc);
+
+/* Subroutine */ int chemv_(char *uplo, integer *n, singlecomplex *alpha, singlecomplex *
+			    a, integer *lda, singlecomplex *x, integer *incx, singlecomplex *beta, singlecomplex *y, 
+			    integer *incy);
+
+/* Subroutine */ int cher_(char *uplo, integer *n, real *alpha, singlecomplex *x, 
+			   integer *incx, singlecomplex *a, integer *lda);
+
+/* Subroutine */ int cher2_(char *uplo, integer *n, singlecomplex *alpha, singlecomplex *
+			    x, integer *incx, singlecomplex *y, integer *incy, singlecomplex *a, integer *lda);
+
+/* Subroutine */ int cher2k_(char *uplo, char *trans, integer *n, integer *k, 
+			     singlecomplex *alpha, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, 
+			     real *beta, singlecomplex *c__, integer *ldc);
+
+/* Subroutine */ int cherk_(char *uplo, char *trans, integer *n, integer *k, 
+			    real *alpha, singlecomplex *a, integer *lda, real *beta, singlecomplex *c__, 
+			    integer *ldc);
+
+/* Subroutine */ int chpmv_(char *uplo, integer *n, singlecomplex *alpha, singlecomplex *
+			    ap, singlecomplex *x, integer *incx, singlecomplex *beta, singlecomplex *y, integer *
+			    incy);
+
+/* Subroutine */ int chpr_(char *uplo, integer *n, real *alpha, singlecomplex *x, 
+			   integer *incx, singlecomplex *ap);
+
+/* Subroutine */ int chpr2_(char *uplo, integer *n, singlecomplex *alpha, singlecomplex *
+			    x, integer *incx, singlecomplex *y, integer *incy, singlecomplex *ap);
+
+/* Subroutine */ int crotg_(singlecomplex *ca, singlecomplex *cb, real *c__, singlecomplex *s);
+
+/* Subroutine */ int cscal_(integer *n, singlecomplex *ca, singlecomplex *cx, integer *
+			    incx);
+
+/* Subroutine */ int csrot_(integer *n, singlecomplex *cx, integer *incx, singlecomplex *
+			    cy, integer *incy, real *c__, real *s);
+
+/* Subroutine */ int csscal_(integer *n, real *sa, singlecomplex *cx, integer *incx);
+
+/* Subroutine */ int cswap_(integer *n, singlecomplex *cx, integer *incx, singlecomplex *
+			    cy, integer *incy);
+
+/* Subroutine */ int csymm_(char *side, char *uplo, integer *m, integer *n, 
+			    singlecomplex *alpha, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, 
+			    singlecomplex *beta, singlecomplex *c__, integer *ldc);
+
+/* Subroutine */ int csyr2k_(char *uplo, char *trans, integer *n, integer *k, 
+			     singlecomplex *alpha, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, 
+			     singlecomplex *beta, singlecomplex *c__, integer *ldc);
+
+/* Subroutine */ int csyrk_(char *uplo, char *trans, integer *n, integer *k, 
+			    singlecomplex *alpha, singlecomplex *a, integer *lda, singlecomplex *beta, singlecomplex *c__, 
+			    integer *ldc);
+
+/* Subroutine */ int ctbmv_(char *uplo, char *trans, char *diag, integer *n, 
+			    integer *k, singlecomplex *a, integer *lda, singlecomplex *x, integer *incx);
+
+/* Subroutine */ int ctbsv_(char *uplo, char *trans, char *diag, integer *n, 
+			    integer *k, singlecomplex *a, integer *lda, singlecomplex *x, integer *incx);
+
+/* Subroutine */ int ctpmv_(char *uplo, char *trans, char *diag, integer *n, 
+			    singlecomplex *ap, singlecomplex *x, integer *incx);
+
+/* Subroutine */ int ctpsv_(char *uplo, char *trans, char *diag, integer *n, 
+			    singlecomplex *ap, singlecomplex *x, integer *incx);
+
+/* Subroutine */ int ctrmm_(char *side, char *uplo, char *transa, char *diag, 
+			    integer *m, integer *n, singlecomplex *alpha, singlecomplex *a, integer *lda, 
+			    singlecomplex *b, integer *ldb);
+
+/* Subroutine */ int ctrmv_(char *uplo, char *trans, char *diag, integer *n, 
+			    singlecomplex *a, integer *lda, singlecomplex *x, integer *incx);
+
+/* Subroutine */ int ctrsm_(char *side, char *uplo, char *transa, char *diag, 
+			    integer *m, integer *n, singlecomplex *alpha, singlecomplex *a, integer *lda, 
+			    singlecomplex *b, integer *ldb);
+
+/* Subroutine */ int ctrsv_(char *uplo, char *trans, char *diag, integer *n, 
+			    singlecomplex *a, integer *lda, singlecomplex *x, integer *incx);
+
+doublereal dasum_(integer *n, doublereal *dx, integer *incx);
+
+/* Subroutine */ int daxpy_(integer *n, doublereal *da, doublereal *dx, 
+			    integer *incx, doublereal *dy, integer *incy);
+
+doublereal dcabs1_(doublecomplex *z__);
+
+/* Subroutine */ int dcopy_(integer *n, doublereal *dx, integer *incx, 
+			    doublereal *dy, integer *incy);
+
+doublereal ddot_(integer *n, doublereal *dx, integer *incx, doublereal *dy, 
+		 integer *incy);
+
+/* Subroutine */ int dgbmv_(char *trans, integer *m, integer *n, integer *kl, 
+			    integer *ku, doublereal *alpha, doublereal *a, integer *lda, 
+			    doublereal *x, integer *incx, doublereal *beta, doublereal *y, 
+			    integer *incy);
+
+/* Subroutine */ int dgemm_(char *transa, char *transb, integer *m, integer *
+			    n, integer *k, doublereal *alpha, doublereal *a, integer *lda, 
+			    doublereal *b, integer *ldb, doublereal *beta, doublereal *c__, 
+			    integer *ldc);
+
+/* Subroutine */ int dgemv_(char *trans, integer *m, integer *n, doublereal *
+			    alpha, doublereal *a, integer *lda, doublereal *x, integer *incx, 
+			    doublereal *beta, doublereal *y, integer *incy);
+
+/* Subroutine */ int dger_(integer *m, integer *n, doublereal *alpha, 
+			   doublereal *x, integer *incx, doublereal *y, integer *incy, 
+			   doublereal *a, integer *lda);
+
+doublereal dnrm2_(integer *n, doublereal *x, integer *incx);
+
+/* Subroutine */ int drot_(integer *n, doublereal *dx, integer *incx, 
+			   doublereal *dy, integer *incy, doublereal *c__, doublereal *s);
+
+/* Subroutine */ int drotg_(doublereal *da, doublereal *db, doublereal *c__, 
+			    doublereal *s);
+
+/* Subroutine */ int drotm_(integer *n, doublereal *dx, integer *incx, 
+			    doublereal *dy, integer *incy, doublereal *dparam);
+
+/* Subroutine */ int drotmg_(doublereal *dd1, doublereal *dd2, doublereal *
+			     dx1, doublereal *dy1, doublereal *dparam);
+
+/* Subroutine */ int dsbmv_(char *uplo, integer *n, integer *k, doublereal *
+			    alpha, doublereal *a, integer *lda, doublereal *x, integer *incx, 
+			    doublereal *beta, doublereal *y, integer *incy);
+
+/* Subroutine */ int dscal_(integer *n, doublereal *da, doublereal *dx, 
+			    integer *incx);
+
+doublereal dsdot_(integer *n, real *sx, integer *incx, real *sy, integer *
+		  incy);
+
+/* Subroutine */ int dspmv_(char *uplo, integer *n, doublereal *alpha, 
+			    doublereal *ap, doublereal *x, integer *incx, doublereal *beta, 
+			    doublereal *y, integer *incy);
+
+/* Subroutine */ int dspr_(char *uplo, integer *n, doublereal *alpha, 
+			   doublereal *x, integer *incx, doublereal *ap);
+
+/* Subroutine */ int dspr2_(char *uplo, integer *n, doublereal *alpha, 
+			    doublereal *x, integer *incx, doublereal *y, integer *incy, 
+			    doublereal *ap);
+
+/* Subroutine */ int dswap_(integer *n, doublereal *dx, integer *incx, 
+			    doublereal *dy, integer *incy);
+
+/* Subroutine */ int dsymm_(char *side, char *uplo, integer *m, integer *n, 
+			    doublereal *alpha, doublereal *a, integer *lda, doublereal *b, 
+			    integer *ldb, doublereal *beta, doublereal *c__, integer *ldc);
+
+/* Subroutine */ int dsymv_(char *uplo, integer *n, doublereal *alpha, 
+			    doublereal *a, integer *lda, doublereal *x, integer *incx, doublereal 
+			    *beta, doublereal *y, integer *incy);
+
+/* Subroutine */ int dsyr_(char *uplo, integer *n, doublereal *alpha, 
+			   doublereal *x, integer *incx, doublereal *a, integer *lda);
+
+/* Subroutine */ int dsyr2_(char *uplo, integer *n, doublereal *alpha, 
+			    doublereal *x, integer *incx, doublereal *y, integer *incy, 
+			    doublereal *a, integer *lda);
+
+/* Subroutine */ int dsyr2k_(char *uplo, char *trans, integer *n, integer *k, 
+			     doublereal *alpha, doublereal *a, integer *lda, doublereal *b, 
+			     integer *ldb, doublereal *beta, doublereal *c__, integer *ldc);
+
+/* Subroutine */ int dsyrk_(char *uplo, char *trans, integer *n, integer *k, 
+			    doublereal *alpha, doublereal *a, integer *lda, doublereal *beta, 
+			    doublereal *c__, integer *ldc);
+
+/* Subroutine */ int dtbmv_(char *uplo, char *trans, char *diag, integer *n, 
+			    integer *k, doublereal *a, integer *lda, doublereal *x, integer *incx);
+
+/* Subroutine */ int dtbsv_(char *uplo, char *trans, char *diag, integer *n, 
+			    integer *k, doublereal *a, integer *lda, doublereal *x, integer *incx);
+
+/* Subroutine */ int dtpmv_(char *uplo, char *trans, char *diag, integer *n, 
+			    doublereal *ap, doublereal *x, integer *incx);
+
+/* Subroutine */ int dtpsv_(char *uplo, char *trans, char *diag, integer *n, 
+			    doublereal *ap, doublereal *x, integer *incx);
+
+/* Subroutine */ int dtrmm_(char *side, char *uplo, char *transa, char *diag, 
+			    integer *m, integer *n, doublereal *alpha, doublereal *a, integer *
+			    lda, doublereal *b, integer *ldb);
+
+/* Subroutine */ int dtrmv_(char *uplo, char *trans, char *diag, integer *n, 
+			    doublereal *a, integer *lda, doublereal *x, integer *incx);
+
+/* Subroutine */ int dtrsm_(char *side, char *uplo, char *transa, char *diag, 
+			    integer *m, integer *n, doublereal *alpha, doublereal *a, integer *
+			    lda, doublereal *b, integer *ldb);
+
+/* Subroutine */ int dtrsv_(char *uplo, char *trans, char *diag, integer *n, 
+			    doublereal *a, integer *lda, doublereal *x, integer *incx);
+
+doublereal dzasum_(integer *n, doublecomplex *zx, integer *incx);
+
+doublereal dznrm2_(integer *n, doublecomplex *x, integer *incx);
+
+integer icamax_(integer *n, singlecomplex *cx, integer *incx);
+
+integer idamax_(integer *n, doublereal *dx, integer *incx);
+
+integer isamax_(integer *n, real *sx, integer *incx);
+
+integer izamax_(integer *n, doublecomplex *zx, integer *incx);
+
+logical lsame_(char *ca, char *cb);
+
+doublereal sasum_(integer *n, real *sx, integer *incx);
+
+/* Subroutine */ int saxpy_(integer *n, real *sa, real *sx, integer *incx, 
+			    real *sy, integer *incy);
+
+doublereal scabs1_(singlecomplex *z__);
+
+doublereal scasum_(integer *n, singlecomplex *cx, integer *incx);
+
+doublereal scnrm2_(integer *n, singlecomplex *x, integer *incx);
+
+/* Subroutine */ int scopy_(integer *n, real *sx, integer *incx, real *sy, 
+			    integer *incy);
+
+doublereal sdot_(integer *n, real *sx, integer *incx, real *sy, integer *incy);
+
+doublereal sdsdot_(integer *n, real *sb, real *sx, integer *incx, real *sy, 
+		   integer *incy);
+
+/* Subroutine */ int sgbmv_(char *trans, integer *m, integer *n, integer *kl, 
+			    integer *ku, real *alpha, real *a, integer *lda, real *x, integer *
+			    incx, real *beta, real *y, integer *incy);
+
+/* Subroutine */ int sgemm_(char *transa, char *transb, integer *m, integer *
+			    n, integer *k, real *alpha, real *a, integer *lda, real *b, integer *
+			    ldb, real *beta, real *c__, integer *ldc);
+
+/* Subroutine */ int sgemv_(char *trans, integer *m, integer *n, real *alpha, 
+			    real *a, integer *lda, real *x, integer *incx, real *beta, real *y, 
+			    integer *incy);
+
+/* Subroutine */ int sger_(integer *m, integer *n, real *alpha, real *x, 
+			   integer *incx, real *y, integer *incy, real *a, integer *lda);
+
+doublereal snrm2_(integer *n, real *x, integer *incx);
+
+/* Subroutine */ int srot_(integer *n, real *sx, integer *incx, real *sy, 
+			   integer *incy, real *c__, real *s);
+
+/* Subroutine */ int srotg_(real *sa, real *sb, real *c__, real *s);
+
+/* Subroutine */ int srotm_(integer *n, real *sx, integer *incx, real *sy, 
+			    integer *incy, real *sparam);
+
+/* Subroutine */ int srotmg_(real *sd1, real *sd2, real *sx1, real *sy1, real 
+			     *sparam);
+
+/* Subroutine */ int ssbmv_(char *uplo, integer *n, integer *k, real *alpha, 
+			    real *a, integer *lda, real *x, integer *incx, real *beta, real *y, 
+			    integer *incy);
+
+/* Subroutine */ int sscal_(integer *n, real *sa, real *sx, integer *incx);
+
+/* Subroutine */ int sspmv_(char *uplo, integer *n, real *alpha, real *ap, 
+			    real *x, integer *incx, real *beta, real *y, integer *incy);
+
+/* Subroutine */ int sspr_(char *uplo, integer *n, real *alpha, real *x, 
+			   integer *incx, real *ap);
+
+/* Subroutine */ int sspr2_(char *uplo, integer *n, real *alpha, real *x, 
+			    integer *incx, real *y, integer *incy, real *ap);
+
+/* Subroutine */ int sswap_(integer *n, real *sx, integer *incx, real *sy, 
+			    integer *incy);
+
+/* Subroutine */ int ssymm_(char *side, char *uplo, integer *m, integer *n, 
+			    real *alpha, real *a, integer *lda, real *b, integer *ldb, real *beta, 
+			    real *c__, integer *ldc);
+
+/* Subroutine */ int ssymv_(char *uplo, integer *n, real *alpha, real *a, 
+			    integer *lda, real *x, integer *incx, real *beta, real *y, integer *
+			    incy);
+
+/* Subroutine */ int ssyr_(char *uplo, integer *n, real *alpha, real *x, 
+			   integer *incx, real *a, integer *lda);
+
+/* Subroutine */ int ssyr2_(char *uplo, integer *n, real *alpha, real *x, 
+			    integer *incx, real *y, integer *incy, real *a, integer *lda);
+
+/* Subroutine */ int ssyr2k_(char *uplo, char *trans, integer *n, integer *k, 
+			     real *alpha, real *a, integer *lda, real *b, integer *ldb, real *beta, 
+			     real *c__, integer *ldc);
+
+/* Subroutine */ int ssyrk_(char *uplo, char *trans, integer *n, integer *k, 
+			    real *alpha, real *a, integer *lda, real *beta, real *c__, integer *
+			    ldc);
+
+/* Subroutine */ int stbmv_(char *uplo, char *trans, char *diag, integer *n, 
+			    integer *k, real *a, integer *lda, real *x, integer *incx);
+
+/* Subroutine */ int stbsv_(char *uplo, char *trans, char *diag, integer *n, 
+			    integer *k, real *a, integer *lda, real *x, integer *incx);
+
+/* Subroutine */ int stpmv_(char *uplo, char *trans, char *diag, integer *n, 
+			    real *ap, real *x, integer *incx);
+
+/* Subroutine */ int stpsv_(char *uplo, char *trans, char *diag, integer *n, 
+			    real *ap, real *x, integer *incx);
+
+/* Subroutine */ int strmm_(char *side, char *uplo, char *transa, char *diag, 
+			    integer *m, integer *n, real *alpha, real *a, integer *lda, real *b, 
+			    integer *ldb);
+
+/* Subroutine */ int strmv_(char *uplo, char *trans, char *diag, integer *n, 
+			    real *a, integer *lda, real *x, integer *incx);
+
+/* Subroutine */ int strsm_(char *side, char *uplo, char *transa, char *diag, 
+			    integer *m, integer *n, real *alpha, real *a, integer *lda, real *b, 
+			    integer *ldb);
+
+/* Subroutine */ int strsv_(char *uplo, char *trans, char *diag, integer *n, 
+			    real *a, integer *lda, real *x, integer *incx);
+
+/* Subroutine */ int xerbla_(char *srname, integer *info);
+
+/* Subroutine */ int xerbla_array__(char *srname_array__, integer *
+				    srname_len__, integer *info, ftnlen srname_array_len);
+
+/* Subroutine */ int zaxpy_(integer *n, doublecomplex *za, doublecomplex *zx, 
+			    integer *incx, doublecomplex *zy, integer *incy);
+
+/* Subroutine */ int zcopy_(integer *n, doublecomplex *zx, integer *incx, 
+			    doublecomplex *zy, integer *incy);
+
+/* Double singlecomplex */ VOID zdotc_(doublecomplex * ret_val, integer *n, 
+				       doublecomplex *zx, integer *incx, doublecomplex *zy, integer *incy);
+
+/* Double singlecomplex */ VOID zdotu_(doublecomplex * ret_val, integer *n, 
+				       doublecomplex *zx, integer *incx, doublecomplex *zy, integer *incy);
+
+/* Subroutine */ int zdrot_(integer *n, doublecomplex *cx, integer *incx, 
+			    doublecomplex *cy, integer *incy, doublereal *c__, doublereal *s);
+
+/* Subroutine */ int zdscal_(integer *n, doublereal *da, doublecomplex *zx, 
+			     integer *incx);
+
+/* Subroutine */ int zgbmv_(char *trans, integer *m, integer *n, integer *kl, 
+			    integer *ku, doublecomplex *alpha, doublecomplex *a, integer *lda, 
+			    doublecomplex *x, integer *incx, doublecomplex *beta, doublecomplex *
+			    y, integer *incy);
+
+/* Subroutine */ int zgemm_(char *transa, char *transb, integer *m, integer *
+			    n, integer *k, doublecomplex *alpha, doublecomplex *a, integer *lda, 
+			    doublecomplex *b, integer *ldb, doublecomplex *beta, doublecomplex *
+			    c__, integer *ldc);
+
+/* Subroutine */ int zgemv_(char *trans, integer *m, integer *n, 
+			    doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex *
+			    x, integer *incx, doublecomplex *beta, doublecomplex *y, integer *
+			    incy);
+
+/* Subroutine */ int zgerc_(integer *m, integer *n, doublecomplex *alpha, 
+			    doublecomplex *x, integer *incx, doublecomplex *y, integer *incy, 
+			    doublecomplex *a, integer *lda);
+
+/* Subroutine */ int zgeru_(integer *m, integer *n, doublecomplex *alpha, 
+			    doublecomplex *x, integer *incx, doublecomplex *y, integer *incy, 
+			    doublecomplex *a, integer *lda);
+
+/* Subroutine */ int zhbmv_(char *uplo, integer *n, integer *k, doublecomplex 
+			    *alpha, doublecomplex *a, integer *lda, doublecomplex *x, integer *
+			    incx, doublecomplex *beta, doublecomplex *y, integer *incy);
+
+/* Subroutine */ int zhemm_(char *side, char *uplo, integer *m, integer *n, 
+			    doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex *
+			    b, integer *ldb, doublecomplex *beta, doublecomplex *c__, integer *
+			    ldc);
+
+/* Subroutine */ int zhemv_(char *uplo, integer *n, doublecomplex *alpha, 
+			    doublecomplex *a, integer *lda, doublecomplex *x, integer *incx, 
+			    doublecomplex *beta, doublecomplex *y, integer *incy);
+
+/* Subroutine */ int zher_(char *uplo, integer *n, doublereal *alpha, 
+			   doublecomplex *x, integer *incx, doublecomplex *a, integer *lda);
+
+/* Subroutine */ int zher2_(char *uplo, integer *n, doublecomplex *alpha, 
+			    doublecomplex *x, integer *incx, doublecomplex *y, integer *incy, 
+			    doublecomplex *a, integer *lda);
+
+/* Subroutine */ int zher2k_(char *uplo, char *trans, integer *n, integer *k, 
+			     doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex *
+			     b, integer *ldb, doublereal *beta, doublecomplex *c__, integer *ldc);
+
+/* Subroutine */ int zherk_(char *uplo, char *trans, integer *n, integer *k, 
+			    doublereal *alpha, doublecomplex *a, integer *lda, doublereal *beta, 
+			    doublecomplex *c__, integer *ldc);
+
+/* Subroutine */ int zhpmv_(char *uplo, integer *n, doublecomplex *alpha, 
+			    doublecomplex *ap, doublecomplex *x, integer *incx, doublecomplex *
+			    beta, doublecomplex *y, integer *incy);
+
+/* Subroutine */ int zhpr_(char *uplo, integer *n, doublereal *alpha, 
+			   doublecomplex *x, integer *incx, doublecomplex *ap);
+
+/* Subroutine */ int zhpr2_(char *uplo, integer *n, doublecomplex *alpha, 
+			    doublecomplex *x, integer *incx, doublecomplex *y, integer *incy, 
+			    doublecomplex *ap);
+
+/* Subroutine */ int zrotg_(doublecomplex *ca, doublecomplex *cb, doublereal *
+			    c__, doublecomplex *s);
+
+/* Subroutine */ int zscal_(integer *n, doublecomplex *za, doublecomplex *zx, 
+			    integer *incx);
+
+/* Subroutine */ int zswap_(integer *n, doublecomplex *zx, integer *incx, 
+			    doublecomplex *zy, integer *incy);
+
+/* Subroutine */ int zsymm_(char *side, char *uplo, integer *m, integer *n, 
+			    doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex *
+			    b, integer *ldb, doublecomplex *beta, doublecomplex *c__, integer *
+			    ldc);
+
+/* Subroutine */ int zsyr2k_(char *uplo, char *trans, integer *n, integer *k, 
+			     doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex *
+			     b, integer *ldb, doublecomplex *beta, doublecomplex *c__, integer *
+			     ldc);
+
+/* Subroutine */ int zsyrk_(char *uplo, char *trans, integer *n, integer *k, 
+			    doublecomplex *alpha, doublecomplex *a, integer *lda, doublecomplex *
+			    beta, doublecomplex *c__, integer *ldc);
+
+/* Subroutine */ int ztbmv_(char *uplo, char *trans, char *diag, integer *n, 
+			    integer *k, doublecomplex *a, integer *lda, doublecomplex *x, integer 
+			    *incx);
+
+/* Subroutine */ int ztbsv_(char *uplo, char *trans, char *diag, integer *n, 
+			    integer *k, doublecomplex *a, integer *lda, doublecomplex *x, integer 
+			    *incx);
+
+/* Subroutine */ int ztpmv_(char *uplo, char *trans, char *diag, integer *n, 
+			    doublecomplex *ap, doublecomplex *x, integer *incx);
+
+/* Subroutine */ int ztpsv_(char *uplo, char *trans, char *diag, integer *n, 
+			    doublecomplex *ap, doublecomplex *x, integer *incx);
+
+/* Subroutine */ int ztrmm_(char *side, char *uplo, char *transa, char *diag, 
+			    integer *m, integer *n, doublecomplex *alpha, doublecomplex *a, 
+			    integer *lda, doublecomplex *b, integer *ldb);
+
+/* Subroutine */ int ztrmv_(char *uplo, char *trans, char *diag, integer *n, 
+			    doublecomplex *a, integer *lda, doublecomplex *x, integer *incx);
+
+/* Subroutine */ int ztrsm_(char *side, char *uplo, char *transa, char *diag, 
+			    integer *m, integer *n, doublecomplex *alpha, doublecomplex *a, 
+			    integer *lda, doublecomplex *b, integer *ldb);
+
+/* Subroutine */ int ztrsv_(char *uplo, char *trans, char *diag, integer *n, 
+			    doublecomplex *a, integer *lda, doublecomplex *x, integer *incx);
+
+/* Subroutine */ int cbdsqr_(char *uplo, integer *n, integer *ncvt, integer *
+			     nru, integer *ncc, real *d__, real *e, singlecomplex *vt, integer *ldvt, 
+			     singlecomplex *u, integer *ldu, singlecomplex *c__, integer *ldc, real *rwork, 
+			     integer *info);
+
+/* Subroutine */ int cgbbrd_(char *vect, integer *m, integer *n, integer *ncc, 
+			     integer *kl, integer *ku, singlecomplex *ab, integer *ldab, real *d__, 
+			     real *e, singlecomplex *q, integer *ldq, singlecomplex *pt, integer *ldpt, 
+			     singlecomplex *c__, integer *ldc, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgbcon_(char *norm, integer *n, integer *kl, integer *ku, 
+			     singlecomplex *ab, integer *ldab, integer *ipiv, real *anorm, real *rcond, 
+			     singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgbequ_(integer *m, integer *n, integer *kl, integer *ku, 
+			     singlecomplex *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real 
+			     *colcnd, real *amax, integer *info);
+
+/* Subroutine */ int cgbequb_(integer *m, integer *n, integer *kl, integer *
+			      ku, singlecomplex *ab, integer *ldab, real *r__, real *c__, real *rowcnd, 
+			      real *colcnd, real *amax, integer *info);
+
+/* Subroutine */ int cgbrfs_(char *trans, integer *n, integer *kl, integer *
+			     ku, integer *nrhs, singlecomplex *ab, integer *ldab, singlecomplex *afb, integer *
+			     ldafb, integer *ipiv, singlecomplex *b, integer *ldb, singlecomplex *x, integer *
+			     ldx, real *ferr, real *berr, singlecomplex *work, real *rwork, integer *
+			     info);
+
+/* Subroutine */ int cgbrfsx_(char *trans, char *equed, integer *n, integer *
+			      kl, integer *ku, integer *nrhs, singlecomplex *ab, integer *ldab, singlecomplex *
+			      afb, integer *ldafb, integer *ipiv, real *r__, real *c__, singlecomplex *b, 
+			      integer *ldb, singlecomplex *x, integer *ldx, real *rcond, real *berr, 
+			      integer *n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, 
+			      integer *nparams, real *params, singlecomplex *work, real *rwork, integer *
+			      info);
+
+/* Subroutine */ int cgbsv_(integer *n, integer *kl, integer *ku, integer *
+			    nrhs, singlecomplex *ab, integer *ldab, integer *ipiv, singlecomplex *b, integer *
+			    ldb, integer *info);
+
+/* Subroutine */ int cgbsvx_(char *fact, char *trans, integer *n, integer *kl, 
+			     integer *ku, integer *nrhs, singlecomplex *ab, integer *ldab, singlecomplex *afb, 
+			     integer *ldafb, integer *ipiv, char *equed, real *r__, real *c__, 
+			     singlecomplex *b, integer *ldb, singlecomplex *x, integer *ldx, real *rcond, real 
+			     *ferr, real *berr, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgbsvxx_(char *fact, char *trans, integer *n, integer *
+			      kl, integer *ku, integer *nrhs, singlecomplex *ab, integer *ldab, singlecomplex *
+			      afb, integer *ldafb, integer *ipiv, char *equed, real *r__, real *c__, 
+			      singlecomplex *b, integer *ldb, singlecomplex *x, integer *ldx, real *rcond, 
+			      real *rpvgrw, real *berr, integer *n_err_bnds__, real *
+			      err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real *
+			      params, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgbtf2_(integer *m, integer *n, integer *kl, integer *ku, 
+			     singlecomplex *ab, integer *ldab, integer *ipiv, integer *info);
+
+/* Subroutine */ int cgbtrf_(integer *m, integer *n, integer *kl, integer *ku, 
+			     singlecomplex *ab, integer *ldab, integer *ipiv, integer *info);
+
+/* Subroutine */ int cgbtrs_(char *trans, integer *n, integer *kl, integer *
+			     ku, integer *nrhs, singlecomplex *ab, integer *ldab, integer *ipiv, singlecomplex 
+			     *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cgebak_(char *job, char *side, integer *n, integer *ilo, 
+			     integer *ihi, real *scale, integer *m, singlecomplex *v, integer *ldv, 
+			     integer *info);
+
+/* Subroutine */ int cgebal_(char *job, integer *n, singlecomplex *a, integer *lda, 
+			     integer *ilo, integer *ihi, real *scale, integer *info);
+
+/* Subroutine */ int cgebd2_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     real *d__, real *e, singlecomplex *tauq, singlecomplex *taup, singlecomplex *work, 
+			     integer *info);
+
+/* Subroutine */ int cgebrd_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     real *d__, real *e, singlecomplex *tauq, singlecomplex *taup, singlecomplex *work, 
+			     integer *lwork, integer *info);
+
+/* Subroutine */ int cgecon_(char *norm, integer *n, singlecomplex *a, integer *lda, 
+			     real *anorm, real *rcond, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgeequ_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, 
+			     integer *info);
+
+/* Subroutine */ int cgeequb_(integer *m, integer *n, singlecomplex *a, integer *
+			      lda, real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, 
+			      integer *info);
+
+/* Subroutine */ int cgees_(char *jobvs, char *sort, L_fp select, integer *n, 
+			    singlecomplex *a, integer *lda, integer *sdim, singlecomplex *w, singlecomplex *vs, 
+			    integer *ldvs, singlecomplex *work, integer *lwork, real *rwork, logical *
+			    bwork, integer *info);
+
+/* Subroutine */ int cgeesx_(char *jobvs, char *sort, L_fp select, char *
+			     sense, integer *n, singlecomplex *a, integer *lda, integer *sdim, singlecomplex *
+			     w, singlecomplex *vs, integer *ldvs, real *rconde, real *rcondv, singlecomplex *
+			     work, integer *lwork, real *rwork, logical *bwork, integer *info);
+
+/* Subroutine */ int cgeev_(char *jobvl, char *jobvr, integer *n, singlecomplex *a, 
+			    integer *lda, singlecomplex *w, singlecomplex *vl, integer *ldvl, singlecomplex *vr, 
+			    integer *ldvr, singlecomplex *work, integer *lwork, real *rwork, integer *
+			    info);
+
+/* Subroutine */ int cgeevx_(char *balanc, char *jobvl, char *jobvr, char *
+			     sense, integer *n, singlecomplex *a, integer *lda, singlecomplex *w, singlecomplex *vl, 
+			     integer *ldvl, singlecomplex *vr, integer *ldvr, integer *ilo, integer *ihi, 
+			     real *scale, real *abnrm, real *rconde, real *rcondv, singlecomplex *work, 
+			     integer *lwork, real *rwork, integer *info);
+
+/* Subroutine */ int cgegs_(char *jobvsl, char *jobvsr, integer *n, singlecomplex *
+			    a, integer *lda, singlecomplex *b, integer *ldb, singlecomplex *alpha, singlecomplex *
+			    beta, singlecomplex *vsl, integer *ldvsl, singlecomplex *vsr, integer *ldvsr, 
+			    singlecomplex *work, integer *lwork, real *rwork, integer *info);
+
+/* Subroutine */ int cgegv_(char *jobvl, char *jobvr, integer *n, singlecomplex *a, 
+			    integer *lda, singlecomplex *b, integer *ldb, singlecomplex *alpha, singlecomplex *beta, 
+			    singlecomplex *vl, integer *ldvl, singlecomplex *vr, integer *ldvr, singlecomplex *
+			    work, integer *lwork, real *rwork, integer *info);
+
+/* Subroutine */ int cgehd2_(integer *n, integer *ilo, integer *ihi, singlecomplex *
+			     a, integer *lda, singlecomplex *tau, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cgehrd_(integer *n, integer *ilo, integer *ihi, singlecomplex *
+			     a, integer *lda, singlecomplex *tau, singlecomplex *work, integer *lwork, integer 
+			     *info);
+
+/* Subroutine */ int cgelq2_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     singlecomplex *tau, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cgelqf_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     singlecomplex *tau, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cgels_(char *trans, integer *m, integer *n, integer *
+			    nrhs, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, singlecomplex *
+			    work, integer *lwork, integer *info);
+
+/* Subroutine */ int cgelsd_(integer *m, integer *n, integer *nrhs, singlecomplex *
+			     a, integer *lda, singlecomplex *b, integer *ldb, real *s, real *rcond, 
+			     integer *rank, singlecomplex *work, integer *lwork, real *rwork, integer *
+			     iwork, integer *info);
+
+/* Subroutine */ int cgelss_(integer *m, integer *n, integer *nrhs, singlecomplex *
+			     a, integer *lda, singlecomplex *b, integer *ldb, real *s, real *rcond, 
+			     integer *rank, singlecomplex *work, integer *lwork, real *rwork, integer *
+			     info);
+
+/* Subroutine */ int cgelsx_(integer *m, integer *n, integer *nrhs, singlecomplex *
+			     a, integer *lda, singlecomplex *b, integer *ldb, integer *jpvt, real *rcond, 
+			     integer *rank, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgelsy_(integer *m, integer *n, integer *nrhs, singlecomplex *
+			     a, integer *lda, singlecomplex *b, integer *ldb, integer *jpvt, real *rcond, 
+			     integer *rank, singlecomplex *work, integer *lwork, real *rwork, integer *
+			     info);
+
+/* Subroutine */ int cgeql2_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     singlecomplex *tau, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cgeqlf_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     singlecomplex *tau, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cgeqp3_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     integer *jpvt, singlecomplex *tau, singlecomplex *work, integer *lwork, real *
+			     rwork, integer *info);
+
+/* Subroutine */ int cgeqpf_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     integer *jpvt, singlecomplex *tau, singlecomplex *work, real *rwork, integer *
+			     info);
+
+/* Subroutine */ int cgeqr2_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     singlecomplex *tau, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cgeqrf_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     singlecomplex *tau, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cgerfs_(char *trans, integer *n, integer *nrhs, singlecomplex *
+			     a, integer *lda, singlecomplex *af, integer *ldaf, integer *ipiv, singlecomplex *
+			     b, integer *ldb, singlecomplex *x, integer *ldx, real *ferr, real *berr, 
+			     singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgerfsx_(char *trans, char *equed, integer *n, integer *
+			      nrhs, singlecomplex *a, integer *lda, singlecomplex *af, integer *ldaf, integer *
+			      ipiv, real *r__, real *c__, singlecomplex *b, integer *ldb, singlecomplex *x, 
+			      integer *ldx, real *rcond, real *berr, integer *n_err_bnds__, real *
+			      err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real *
+			      params, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgerq2_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     singlecomplex *tau, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cgerqf_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     singlecomplex *tau, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cgesc2_(integer *n, singlecomplex *a, integer *lda, singlecomplex *
+			     rhs, integer *ipiv, integer *jpiv, real *scale);
+
+/* Subroutine */ int cgesdd_(char *jobz, integer *m, integer *n, singlecomplex *a, 
+			     integer *lda, real *s, singlecomplex *u, integer *ldu, singlecomplex *vt, integer 
+			     *ldvt, singlecomplex *work, integer *lwork, real *rwork, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int cgesv_(integer *n, integer *nrhs, singlecomplex *a, integer *
+			    lda, integer *ipiv, singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cgesvd_(char *jobu, char *jobvt, integer *m, integer *n, 
+			     singlecomplex *a, integer *lda, real *s, singlecomplex *u, integer *ldu, singlecomplex *
+			     vt, integer *ldvt, singlecomplex *work, integer *lwork, real *rwork, 
+			     integer *info);
+
+/* Subroutine */ int cgesvx_(char *fact, char *trans, integer *n, integer *
+			     nrhs, singlecomplex *a, integer *lda, singlecomplex *af, integer *ldaf, integer *
+			     ipiv, char *equed, real *r__, real *c__, singlecomplex *b, integer *ldb, 
+			     singlecomplex *x, integer *ldx, real *rcond, real *ferr, real *berr, 
+			     singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgesvxx_(char *fact, char *trans, integer *n, integer *
+			      nrhs, singlecomplex *a, integer *lda, singlecomplex *af, integer *ldaf, integer *
+			      ipiv, char *equed, real *r__, real *c__, singlecomplex *b, integer *ldb, 
+			      singlecomplex *x, integer *ldx, real *rcond, real *rpvgrw, real *berr, 
+			      integer *n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, 
+			      integer *nparams, real *params, singlecomplex *work, real *rwork, integer *
+			      info);
+
+/* Subroutine */ int cgetc2_(integer *n, singlecomplex *a, integer *lda, integer *
+			     ipiv, integer *jpiv, integer *info);
+
+/* Subroutine */ int cgetf2_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     integer *ipiv, integer *info);
+
+/* Subroutine */ int cgetrf_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     integer *ipiv, integer *info);
+
+/* Subroutine */ int cgetri_(integer *n, singlecomplex *a, integer *lda, integer *
+			     ipiv, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cgetrs_(char *trans, integer *n, integer *nrhs, singlecomplex *
+			     a, integer *lda, integer *ipiv, singlecomplex *b, integer *ldb, integer *
+			     info);
+
+/* Subroutine */ int cggbak_(char *job, char *side, integer *n, integer *ilo, 
+			     integer *ihi, real *lscale, real *rscale, integer *m, singlecomplex *v, 
+			     integer *ldv, integer *info);
+
+/* Subroutine */ int cggbal_(char *job, integer *n, singlecomplex *a, integer *lda, 
+			     singlecomplex *b, integer *ldb, integer *ilo, integer *ihi, real *lscale, 
+			     real *rscale, real *work, integer *info);
+
+/* Subroutine */ int cgges_(char *jobvsl, char *jobvsr, char *sort, L_fp 
+			    selctg, integer *n, singlecomplex *a, integer *lda, singlecomplex *b, integer *
+			    ldb, integer *sdim, singlecomplex *alpha, singlecomplex *beta, singlecomplex *vsl, 
+			    integer *ldvsl, singlecomplex *vsr, integer *ldvsr, singlecomplex *work, integer *
+			    lwork, real *rwork, logical *bwork, integer *info);
+
+/* Subroutine */ int cggesx_(char *jobvsl, char *jobvsr, char *sort, L_fp 
+			     selctg, char *sense, integer *n, singlecomplex *a, integer *lda, singlecomplex *b, 
+			     integer *ldb, integer *sdim, singlecomplex *alpha, singlecomplex *beta, singlecomplex *
+			     vsl, integer *ldvsl, singlecomplex *vsr, integer *ldvsr, real *rconde, real 
+			     *rcondv, singlecomplex *work, integer *lwork, real *rwork, integer *iwork, 
+			     integer *liwork, logical *bwork, integer *info);
+
+/* Subroutine */ int cggev_(char *jobvl, char *jobvr, integer *n, singlecomplex *a, 
+			    integer *lda, singlecomplex *b, integer *ldb, singlecomplex *alpha, singlecomplex *beta, 
+			    singlecomplex *vl, integer *ldvl, singlecomplex *vr, integer *ldvr, singlecomplex *
+			    work, integer *lwork, real *rwork, integer *info);
+
+/* Subroutine */ int cggevx_(char *balanc, char *jobvl, char *jobvr, char *
+			     sense, integer *n, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, 
+			     singlecomplex *alpha, singlecomplex *beta, singlecomplex *vl, integer *ldvl, singlecomplex *
+			     vr, integer *ldvr, integer *ilo, integer *ihi, real *lscale, real *
+			     rscale, real *abnrm, real *bbnrm, real *rconde, real *rcondv, singlecomplex 
+			     *work, integer *lwork, real *rwork, integer *iwork, logical *bwork, 
+			     integer *info);
+
+/* Subroutine */ int cggglm_(integer *n, integer *m, integer *p, singlecomplex *a, 
+			     integer *lda, singlecomplex *b, integer *ldb, singlecomplex *d__, singlecomplex *x, 
+			     singlecomplex *y, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cgghrd_(char *compq, char *compz, integer *n, integer *
+			     ilo, integer *ihi, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, 
+			     singlecomplex *q, integer *ldq, singlecomplex *z__, integer *ldz, integer *info);
+
+/* Subroutine */ int cgglse_(integer *m, integer *n, integer *p, singlecomplex *a, 
+			     integer *lda, singlecomplex *b, integer *ldb, singlecomplex *c__, singlecomplex *d__, 
+			     singlecomplex *x, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cggqrf_(integer *n, integer *m, integer *p, singlecomplex *a, 
+			     integer *lda, singlecomplex *taua, singlecomplex *b, integer *ldb, singlecomplex *taub, 
+			     singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cggrqf_(integer *m, integer *p, integer *n, singlecomplex *a, 
+			     integer *lda, singlecomplex *taua, singlecomplex *b, integer *ldb, singlecomplex *taub, 
+			     singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cggsvd_(char *jobu, char *jobv, char *jobq, integer *m, 
+			     integer *n, integer *p, integer *k, integer *l, singlecomplex *a, integer *
+			     lda, singlecomplex *b, integer *ldb, real *alpha, real *beta, singlecomplex *u, 
+			     integer *ldu, singlecomplex *v, integer *ldv, singlecomplex *q, integer *ldq, 
+			     singlecomplex *work, real *rwork, integer *iwork, integer *info);
+
+/* Subroutine */ int cggsvp_(char *jobu, char *jobv, char *jobq, integer *m, 
+			     integer *p, integer *n, singlecomplex *a, integer *lda, singlecomplex *b, integer 
+			     *ldb, real *tola, real *tolb, integer *k, integer *l, singlecomplex *u, 
+			     integer *ldu, singlecomplex *v, integer *ldv, singlecomplex *q, integer *ldq, 
+			     integer *iwork, real *rwork, singlecomplex *tau, singlecomplex *work, integer *
+			     info);
+
+/* Subroutine */ int cgtcon_(char *norm, integer *n, singlecomplex *dl, singlecomplex *
+			     d__, singlecomplex *du, singlecomplex *du2, integer *ipiv, real *anorm, real *
+			     rcond, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cgtrfs_(char *trans, integer *n, integer *nrhs, singlecomplex *
+			     dl, singlecomplex *d__, singlecomplex *du, singlecomplex *dlf, singlecomplex *df, singlecomplex *
+			     duf, singlecomplex *du2, integer *ipiv, singlecomplex *b, integer *ldb, singlecomplex *
+			     x, integer *ldx, real *ferr, real *berr, singlecomplex *work, real *rwork, 
+			     integer *info);
+
+/* Subroutine */ int cgtsv_(integer *n, integer *nrhs, singlecomplex *dl, singlecomplex *
+			    d__, singlecomplex *du, singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cgtsvx_(char *fact, char *trans, integer *n, integer *
+			     nrhs, singlecomplex *dl, singlecomplex *d__, singlecomplex *du, singlecomplex *dlf, singlecomplex *
+			     df, singlecomplex *duf, singlecomplex *du2, integer *ipiv, singlecomplex *b, integer *
+			     ldb, singlecomplex *x, integer *ldx, real *rcond, real *ferr, real *berr, 
+			     singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgttrf_(integer *n, singlecomplex *dl, singlecomplex *d__, singlecomplex *
+			     du, singlecomplex *du2, integer *ipiv, integer *info);
+
+/* Subroutine */ int cgttrs_(char *trans, integer *n, integer *nrhs, singlecomplex *
+			     dl, singlecomplex *d__, singlecomplex *du, singlecomplex *du2, integer *ipiv, singlecomplex *
+			     b, integer *ldb, integer *info);
+
+/* Subroutine */ int cgtts2_(integer *itrans, integer *n, integer *nrhs, 
+			     singlecomplex *dl, singlecomplex *d__, singlecomplex *du, singlecomplex *du2, integer *ipiv, 
+			     singlecomplex *b, integer *ldb);
+
+/* Subroutine */ int chbev_(char *jobz, char *uplo, integer *n, integer *kd, 
+			    singlecomplex *ab, integer *ldab, real *w, singlecomplex *z__, integer *ldz, 
+			    singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int chbevd_(char *jobz, char *uplo, integer *n, integer *kd, 
+			     singlecomplex *ab, integer *ldab, real *w, singlecomplex *z__, integer *ldz, 
+			     singlecomplex *work, integer *lwork, real *rwork, integer *lrwork, integer *
+			     iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int chbevx_(char *jobz, char *range, char *uplo, integer *n, 
+			     integer *kd, singlecomplex *ab, integer *ldab, singlecomplex *q, integer *ldq, 
+			     real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *
+			     m, real *w, singlecomplex *z__, integer *ldz, singlecomplex *work, real *rwork, 
+			     integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int chbgst_(char *vect, char *uplo, integer *n, integer *ka, 
+			     integer *kb, singlecomplex *ab, integer *ldab, singlecomplex *bb, integer *ldbb, 
+			     singlecomplex *x, integer *ldx, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int chbgv_(char *jobz, char *uplo, integer *n, integer *ka, 
+			    integer *kb, singlecomplex *ab, integer *ldab, singlecomplex *bb, integer *ldbb, 
+			    real *w, singlecomplex *z__, integer *ldz, singlecomplex *work, real *rwork, 
+			    integer *info);
+
+/* Subroutine */ int chbgvd_(char *jobz, char *uplo, integer *n, integer *ka, 
+			     integer *kb, singlecomplex *ab, integer *ldab, singlecomplex *bb, integer *ldbb, 
+			     real *w, singlecomplex *z__, integer *ldz, singlecomplex *work, integer *lwork, 
+			     real *rwork, integer *lrwork, integer *iwork, integer *liwork, 
+			     integer *info);
+
+/* Subroutine */ int chbgvx_(char *jobz, char *range, char *uplo, integer *n, 
+			     integer *ka, integer *kb, singlecomplex *ab, integer *ldab, singlecomplex *bb, 
+			     integer *ldbb, singlecomplex *q, integer *ldq, real *vl, real *vu, integer *
+			     il, integer *iu, real *abstol, integer *m, real *w, singlecomplex *z__, 
+			     integer *ldz, singlecomplex *work, real *rwork, integer *iwork, integer *
+			     ifail, integer *info);
+
+/* Subroutine */ int chbtrd_(char *vect, char *uplo, integer *n, integer *kd, 
+			     singlecomplex *ab, integer *ldab, real *d__, real *e, singlecomplex *q, integer *
+			     ldq, singlecomplex *work, integer *info);
+
+/* Subroutine */ int checon_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     integer *ipiv, real *anorm, real *rcond, singlecomplex *work, integer *
+			     info);
+
+/* Subroutine */ int cheequb_(char *uplo, integer *n, singlecomplex *a, integer *
+			      lda, real *s, real *scond, real *amax, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cheev_(char *jobz, char *uplo, integer *n, singlecomplex *a, 
+			    integer *lda, real *w, singlecomplex *work, integer *lwork, real *rwork, 
+			    integer *info);
+
+/* Subroutine */ int cheevd_(char *jobz, char *uplo, integer *n, singlecomplex *a, 
+			     integer *lda, real *w, singlecomplex *work, integer *lwork, real *rwork, 
+			     integer *lrwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int cheevr_(char *jobz, char *range, char *uplo, integer *n, 
+			     singlecomplex *a, integer *lda, real *vl, real *vu, integer *il, integer *
+			     iu, real *abstol, integer *m, real *w, singlecomplex *z__, integer *ldz, 
+			     integer *isuppz, singlecomplex *work, integer *lwork, real *rwork, integer *
+			     lrwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int cheevx_(char *jobz, char *range, char *uplo, integer *n, 
+			     singlecomplex *a, integer *lda, real *vl, real *vu, integer *il, integer *
+			     iu, real *abstol, integer *m, real *w, singlecomplex *z__, integer *ldz, 
+			     singlecomplex *work, integer *lwork, real *rwork, integer *iwork, integer *
+			     ifail, integer *info);
+
+/* Subroutine */ int chegs2_(integer *itype, char *uplo, integer *n, singlecomplex *
+			     a, integer *lda, singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int chegst_(integer *itype, char *uplo, integer *n, singlecomplex *
+			     a, integer *lda, singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int chegv_(integer *itype, char *jobz, char *uplo, integer *
+			    n, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, real *w, 
+			    singlecomplex *work, integer *lwork, real *rwork, integer *info);
+
+/* Subroutine */ int chegvd_(integer *itype, char *jobz, char *uplo, integer *
+			     n, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, real *w, 
+			     singlecomplex *work, integer *lwork, real *rwork, integer *lrwork, integer *
+			     iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int chegvx_(integer *itype, char *jobz, char *range, char *
+			     uplo, integer *n, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, 
+			     real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *
+			     m, real *w, singlecomplex *z__, integer *ldz, singlecomplex *work, integer *lwork, 
+			     real *rwork, integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int cherfs_(char *uplo, integer *n, integer *nrhs, singlecomplex *
+			     a, integer *lda, singlecomplex *af, integer *ldaf, integer *ipiv, singlecomplex *
+			     b, integer *ldb, singlecomplex *x, integer *ldx, real *ferr, real *berr, 
+			     singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cherfsx_(char *uplo, char *equed, integer *n, integer *
+			      nrhs, singlecomplex *a, integer *lda, singlecomplex *af, integer *ldaf, integer *
+			      ipiv, real *s, singlecomplex *b, integer *ldb, singlecomplex *x, integer *ldx, 
+			      real *rcond, real *berr, integer *n_err_bnds__, real *err_bnds_norm__, 
+			      real *err_bnds_comp__, integer *nparams, real *params, singlecomplex *work, 
+			      real *rwork, integer *info);
+
+/* Subroutine */ int chesv_(char *uplo, integer *n, integer *nrhs, singlecomplex *a, 
+			    integer *lda, integer *ipiv, singlecomplex *b, integer *ldb, singlecomplex *work, 
+			    integer *lwork, integer *info);
+
+/* Subroutine */ int chesvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, singlecomplex *a, integer *lda, singlecomplex *af, integer *ldaf, integer *
+			     ipiv, singlecomplex *b, integer *ldb, singlecomplex *x, integer *ldx, real *rcond, 
+			     real *ferr, real *berr, singlecomplex *work, integer *lwork, real *rwork, 
+			     integer *info);
+
+/* Subroutine */ int chesvxx_(char *fact, char *uplo, integer *n, integer *
+			      nrhs, singlecomplex *a, integer *lda, singlecomplex *af, integer *ldaf, integer *
+			      ipiv, char *equed, real *s, singlecomplex *b, integer *ldb, singlecomplex *x, 
+			      integer *ldx, real *rcond, real *rpvgrw, real *berr, integer *
+			      n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, integer *
+			      nparams, real *params, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int chetd2_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     real *d__, real *e, singlecomplex *tau, integer *info);
+
+/* Subroutine */ int chetf2_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     integer *ipiv, integer *info);
+
+/* Subroutine */ int chetrd_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     real *d__, real *e, singlecomplex *tau, singlecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int chetrf_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     integer *ipiv, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int chetri_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     integer *ipiv, singlecomplex *work, integer *info);
+
+/* Subroutine */ int chetrs_(char *uplo, integer *n, integer *nrhs, singlecomplex *
+			     a, integer *lda, integer *ipiv, singlecomplex *b, integer *ldb, integer *
+			     info);
+
+/* Subroutine */ int chfrk_(char *transr, char *uplo, char *trans, integer *n, 
+			    integer *k, real *alpha, singlecomplex *a, integer *lda, real *beta, 
+			    singlecomplex *c__);
+
+/* Subroutine */ int chgeqz_(char *job, char *compq, char *compz, integer *n, 
+			     integer *ilo, integer *ihi, singlecomplex *h__, integer *ldh, singlecomplex *t, 
+			     integer *ldt, singlecomplex *alpha, singlecomplex *beta, singlecomplex *q, integer *ldq, 
+			     singlecomplex *z__, integer *ldz, singlecomplex *work, integer *lwork, real *
+			     rwork, integer *info);
+
+/* Character */ VOID chla_transtype__(char *ret_val, ftnlen ret_val_len, 
+				      integer *trans);
+
+/* Subroutine */ int chpcon_(char *uplo, integer *n, singlecomplex *ap, integer *
+			     ipiv, real *anorm, real *rcond, singlecomplex *work, integer *info);
+
+/* Subroutine */ int chpev_(char *jobz, char *uplo, integer *n, singlecomplex *ap, 
+			    real *w, singlecomplex *z__, integer *ldz, singlecomplex *work, real *rwork, 
+			    integer *info);
+
+/* Subroutine */ int chpevd_(char *jobz, char *uplo, integer *n, singlecomplex *ap, 
+			     real *w, singlecomplex *z__, integer *ldz, singlecomplex *work, integer *lwork, 
+			     real *rwork, integer *lrwork, integer *iwork, integer *liwork, 
+			     integer *info);
+
+/* Subroutine */ int chpevx_(char *jobz, char *range, char *uplo, integer *n, 
+			     singlecomplex *ap, real *vl, real *vu, integer *il, integer *iu, real *
+			     abstol, integer *m, real *w, singlecomplex *z__, integer *ldz, singlecomplex *
+			     work, real *rwork, integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int chpgst_(integer *itype, char *uplo, integer *n, singlecomplex *
+			     ap, singlecomplex *bp, integer *info);
+
+/* Subroutine */ int chpgv_(integer *itype, char *jobz, char *uplo, integer *
+			    n, singlecomplex *ap, singlecomplex *bp, real *w, singlecomplex *z__, integer *ldz, 
+			    singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int chpgvd_(integer *itype, char *jobz, char *uplo, integer *
+			     n, singlecomplex *ap, singlecomplex *bp, real *w, singlecomplex *z__, integer *ldz, 
+			     singlecomplex *work, integer *lwork, real *rwork, integer *lrwork, integer *
+			     iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int chpgvx_(integer *itype, char *jobz, char *range, char *
+			     uplo, integer *n, singlecomplex *ap, singlecomplex *bp, real *vl, real *vu, 
+			     integer *il, integer *iu, real *abstol, integer *m, real *w, singlecomplex *
+			     z__, integer *ldz, singlecomplex *work, real *rwork, integer *iwork, 
+			     integer *ifail, integer *info);
+
+/* Subroutine */ int chprfs_(char *uplo, integer *n, integer *nrhs, singlecomplex *
+			     ap, singlecomplex *afp, integer *ipiv, singlecomplex *b, integer *ldb, singlecomplex *x, 
+			     integer *ldx, real *ferr, real *berr, singlecomplex *work, real *rwork, 
+			     integer *info);
+
+/* Subroutine */ int chpsv_(char *uplo, integer *n, integer *nrhs, singlecomplex *
+			    ap, integer *ipiv, singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int chpsvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, singlecomplex *ap, singlecomplex *afp, integer *ipiv, singlecomplex *b, integer *
+			     ldb, singlecomplex *x, integer *ldx, real *rcond, real *ferr, real *berr, 
+			     singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int chptrd_(char *uplo, integer *n, singlecomplex *ap, real *d__, 
+			     real *e, singlecomplex *tau, integer *info);
+
+/* Subroutine */ int chptrf_(char *uplo, integer *n, singlecomplex *ap, integer *
+			     ipiv, integer *info);
+
+/* Subroutine */ int chptri_(char *uplo, integer *n, singlecomplex *ap, integer *
+			     ipiv, singlecomplex *work, integer *info);
+
+/* Subroutine */ int chptrs_(char *uplo, integer *n, integer *nrhs, singlecomplex *
+			     ap, integer *ipiv, singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int chsein_(char *side, char *eigsrc, char *initv, logical *
+			     select, integer *n, singlecomplex *h__, integer *ldh, singlecomplex *w, singlecomplex *
+			     vl, integer *ldvl, singlecomplex *vr, integer *ldvr, integer *mm, integer *
+			     m, singlecomplex *work, real *rwork, integer *ifaill, integer *ifailr, 
+			     integer *info);
+
+/* Subroutine */ int chseqr_(char *job, char *compz, integer *n, integer *ilo, 
+			     integer *ihi, singlecomplex *h__, integer *ldh, singlecomplex *w, singlecomplex *z__, 
+			     integer *ldz, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cla_gbamv__(integer *trans, integer *m, integer *n, 
+				 integer *kl, integer *ku, real *alpha, singlecomplex *ab, integer *ldab, 
+				 singlecomplex *x, integer *incx, real *beta, real *y, integer *incy);
+
+doublereal cla_gbrcond_c__(char *trans, integer *n, integer *kl, integer *ku, 
+			   singlecomplex *ab, integer *ldab, singlecomplex *afb, integer *ldafb, integer *
+			   ipiv, real *c__, logical *capply, integer *info, singlecomplex *work, real *
+			   rwork, ftnlen trans_len);
+
+doublereal cla_gbrcond_x__(char *trans, integer *n, integer *kl, integer *ku, 
+			   singlecomplex *ab, integer *ldab, singlecomplex *afb, integer *ldafb, integer *
+			   ipiv, singlecomplex *x, integer *info, singlecomplex *work, real *rwork, ftnlen 
+			   trans_len);
+
+/* Subroutine */ int cla_gbrfsx_extended__(integer *prec_type__, integer *
+					   trans_type__, integer *n, integer *kl, integer *ku, integer *nrhs, 
+					   singlecomplex *ab, integer *ldab, singlecomplex *afb, integer *ldafb, integer *
+					   ipiv, logical *colequ, real *c__, singlecomplex *b, integer *ldb, singlecomplex *
+					   y, integer *ldy, real *berr_out__, integer *n_norms__, real *errs_n__,
+					   real *errs_c__, singlecomplex *res, real *ayb, singlecomplex *dy, singlecomplex *
+					   y_tail__, real *rcond, integer *ithresh, real *rthresh, real *dz_ub__,
+					   logical *ignore_cwise__, integer *info);
+
+doublereal cla_gbrpvgrw__(integer *n, integer *kl, integer *ku, integer *
+			  ncols, singlecomplex *ab, integer *ldab, singlecomplex *afb, integer *ldafb);
+
+/* Subroutine */ int cla_geamv__(integer *trans, integer *m, integer *n, real 
+				 *alpha, singlecomplex *a, integer *lda, singlecomplex *x, integer *incx, real *
+				 beta, real *y, integer *incy);
+
+doublereal cla_gercond_c__(char *trans, integer *n, singlecomplex *a, integer *lda, 
+			   singlecomplex *af, integer *ldaf, integer *ipiv, real *c__, logical *capply,
+			   integer *info, singlecomplex *work, real *rwork, ftnlen trans_len);
+
+doublereal cla_gercond_x__(char *trans, integer *n, singlecomplex *a, integer *lda, 
+			   singlecomplex *af, integer *ldaf, integer *ipiv, singlecomplex *x, integer *info, 
+			   singlecomplex *work, real *rwork, ftnlen trans_len);
+
+/* Subroutine */ int cla_gerfsx_extended__(integer *prec_type__, integer *
+					   trans_type__, integer *n, integer *nrhs, singlecomplex *a, integer *lda, 
+					   singlecomplex *af, integer *ldaf, integer *ipiv, logical *colequ, real *c__,
+					   singlecomplex *b, integer *ldb, singlecomplex *y, integer *ldy, real *berr_out__,
+					   integer *n_norms__, real *errs_n__, real *errs_c__, singlecomplex *res, 
+					   real *ayb, singlecomplex *dy, singlecomplex *y_tail__, real *rcond, integer *
+					   ithresh, real *rthresh, real *dz_ub__, logical *ignore_cwise__, 
+					   integer *info);
+
+/* Subroutine */ int cla_heamv__(integer *uplo, integer *n, real *alpha, 
+				 singlecomplex *a, integer *lda, singlecomplex *x, integer *incx, real *beta, real 
+				 *y, integer *incy);
+
+doublereal cla_hercond_c__(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			   singlecomplex *af, integer *ldaf, integer *ipiv, real *c__, logical *capply,
+			   integer *info, singlecomplex *work, real *rwork, ftnlen uplo_len);
+
+doublereal cla_hercond_x__(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			   singlecomplex *af, integer *ldaf, integer *ipiv, singlecomplex *x, integer *info, 
+			   singlecomplex *work, real *rwork, ftnlen uplo_len);
+
+/* Subroutine */ int cla_herfsx_extended__(integer *prec_type__, char *uplo, 
+					   integer *n, integer *nrhs, singlecomplex *a, integer *lda, singlecomplex *af, 
+					   integer *ldaf, integer *ipiv, logical *colequ, real *c__, singlecomplex *b, 
+					   integer *ldb, singlecomplex *y, integer *ldy, real *berr_out__, integer *
+					   n_norms__, real *errs_n__, real *errs_c__, singlecomplex *res, real *ayb, 
+					   singlecomplex *dy, singlecomplex *y_tail__, real *rcond, integer *ithresh, real *
+					   rthresh, real *dz_ub__, logical *ignore_cwise__, integer *info, 
+					   ftnlen uplo_len);
+
+doublereal cla_herpvgrw__(char *uplo, integer *n, integer *info, singlecomplex *a, 
+			  integer *lda, singlecomplex *af, integer *ldaf, integer *ipiv, real *work, 
+			  ftnlen uplo_len);
+
+/* Subroutine */ int cla_lin_berr__(integer *n, integer *nz, integer *nrhs, 
+				    singlecomplex *res, real *ayb, real *berr);
+
+doublereal cla_porcond_c__(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			   singlecomplex *af, integer *ldaf, real *c__, logical *capply, integer *info,
+			   singlecomplex *work, real *rwork, ftnlen uplo_len);
+
+doublereal cla_porcond_x__(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			   singlecomplex *af, integer *ldaf, singlecomplex *x, integer *info, singlecomplex *work, 
+			   real *rwork, ftnlen uplo_len);
+
+/* Subroutine */ int cla_porfsx_extended__(integer *prec_type__, char *uplo, 
+					   integer *n, integer *nrhs, singlecomplex *a, integer *lda, singlecomplex *af, 
+					   integer *ldaf, logical *colequ, real *c__, singlecomplex *b, integer *ldb, 
+					   singlecomplex *y, integer *ldy, real *berr_out__, integer *n_norms__, real *
+					   errs_n__, real *errs_c__, singlecomplex *res, real *ayb, singlecomplex *dy, 
+					   singlecomplex *y_tail__, real *rcond, integer *ithresh, real *rthresh, real 
+					   *dz_ub__, logical *ignore_cwise__, integer *info, ftnlen uplo_len);
+
+doublereal cla_porpvgrw__(char *uplo, integer *ncols, singlecomplex *a, integer *
+			  lda, singlecomplex *af, integer *ldaf, real *work, ftnlen uplo_len);
+
+doublereal cla_rpvgrw__(integer *n, integer *ncols, singlecomplex *a, integer *lda, 
+			singlecomplex *af, integer *ldaf);
+
+/* Subroutine */ int cla_syamv__(integer *uplo, integer *n, real *alpha, 
+				 singlecomplex *a, integer *lda, singlecomplex *x, integer *incx, real *beta, real 
+				 *y, integer *incy);
+
+doublereal cla_syrcond_c__(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			   singlecomplex *af, integer *ldaf, integer *ipiv, real *c__, logical *capply,
+			   integer *info, singlecomplex *work, real *rwork, ftnlen uplo_len);
+
+doublereal cla_syrcond_x__(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			   singlecomplex *af, integer *ldaf, integer *ipiv, singlecomplex *x, integer *info, 
+			   singlecomplex *work, real *rwork, ftnlen uplo_len);
+
+/* Subroutine */ int cla_syrfsx_extended__(integer *prec_type__, char *uplo, 
+					   integer *n, integer *nrhs, singlecomplex *a, integer *lda, singlecomplex *af, 
+					   integer *ldaf, integer *ipiv, logical *colequ, real *c__, singlecomplex *b, 
+					   integer *ldb, singlecomplex *y, integer *ldy, real *berr_out__, integer *
+					   n_norms__, real *errs_n__, real *errs_c__, singlecomplex *res, real *ayb, 
+					   singlecomplex *dy, singlecomplex *y_tail__, real *rcond, integer *ithresh, real *
+					   rthresh, real *dz_ub__, logical *ignore_cwise__, integer *info, 
+					   ftnlen uplo_len);
+
+doublereal cla_syrpvgrw__(char *uplo, integer *n, integer *info, singlecomplex *a, 
+			  integer *lda, singlecomplex *af, integer *ldaf, integer *ipiv, real *work, 
+			  ftnlen uplo_len);
+
+/* Subroutine */ int cla_wwaddw__(integer *n, singlecomplex *x, singlecomplex *y, singlecomplex 
+				  *w);
+
+/* Subroutine */ int clabrd_(integer *m, integer *n, integer *nb, singlecomplex *a, 
+			     integer *lda, real *d__, real *e, singlecomplex *tauq, singlecomplex *taup, 
+			     singlecomplex *x, integer *ldx, singlecomplex *y, integer *ldy);
+
+/* Subroutine */ int clacgv_(integer *n, singlecomplex *x, integer *incx);
+
+/* Subroutine */ int clacn2_(integer *n, singlecomplex *v, singlecomplex *x, real *est, 
+			     integer *kase, integer *isave);
+
+/* Subroutine */ int clacon_(integer *n, singlecomplex *v, singlecomplex *x, real *est, 
+			     integer *kase);
+
+/* Subroutine */ int clacp2_(char *uplo, integer *m, integer *n, real *a, 
+			     integer *lda, singlecomplex *b, integer *ldb);
+
+/* Subroutine */ int clacpy_(char *uplo, integer *m, integer *n, singlecomplex *a, 
+			     integer *lda, singlecomplex *b, integer *ldb);
+
+/* Subroutine */ int clacrm_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     real *b, integer *ldb, singlecomplex *c__, integer *ldc, real *rwork);
+
+/* Subroutine */ int clacrt_(integer *n, singlecomplex *cx, integer *incx, singlecomplex *
+			     cy, integer *incy, singlecomplex *c__, singlecomplex *s);
+
+/* singlecomplex */ VOID cladiv_(singlecomplex * ret_val, singlecomplex *x, singlecomplex *y);
+
+/* Subroutine */ int claed0_(integer *qsiz, integer *n, real *d__, real *e, 
+			     singlecomplex *q, integer *ldq, singlecomplex *qstore, integer *ldqs, real *rwork, 
+			     integer *iwork, integer *info);
+
+/* Subroutine */ int claed7_(integer *n, integer *cutpnt, integer *qsiz, 
+			     integer *tlvls, integer *curlvl, integer *curpbm, real *d__, singlecomplex *
+			     q, integer *ldq, real *rho, integer *indxq, real *qstore, integer *
+			     qptr, integer *prmptr, integer *perm, integer *givptr, integer *
+			     givcol, real *givnum, singlecomplex *work, real *rwork, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int claed8_(integer *k, integer *n, integer *qsiz, singlecomplex *
+			     q, integer *ldq, real *d__, real *rho, integer *cutpnt, real *z__, 
+			     real *dlamda, singlecomplex *q2, integer *ldq2, real *w, integer *indxp, 
+			     integer *indx, integer *indxq, integer *perm, integer *givptr, 
+			     integer *givcol, real *givnum, integer *info);
+
+/* Subroutine */ int claein_(logical *rightv, logical *noinit, integer *n, 
+			     singlecomplex *h__, integer *ldh, singlecomplex *w, singlecomplex *v, singlecomplex *b, 
+			     integer *ldb, real *rwork, real *eps3, real *smlnum, integer *info);
+
+/* Subroutine */ int claesy_(singlecomplex *a, singlecomplex *b, singlecomplex *c__, singlecomplex *
+			     rt1, singlecomplex *rt2, singlecomplex *evscal, singlecomplex *cs1, singlecomplex *sn1);
+
+/* Subroutine */ int claev2_(singlecomplex *a, singlecomplex *b, singlecomplex *c__, real *rt1, 
+			     real *rt2, real *cs1, singlecomplex *sn1);
+
+/* Subroutine */ int clag2z_(integer *m, integer *n, singlecomplex *sa, integer *
+			     ldsa, doublecomplex *a, integer *lda, integer *info);
+
+/* Subroutine */ int clags2_(logical *upper, real *a1, singlecomplex *a2, real *a3, 
+			     real *b1, singlecomplex *b2, real *b3, real *csu, singlecomplex *snu, real *csv, 
+			     singlecomplex *snv, real *csq, singlecomplex *snq);
+
+/* Subroutine */ int clagtm_(char *trans, integer *n, integer *nrhs, real *
+			     alpha, singlecomplex *dl, singlecomplex *d__, singlecomplex *du, singlecomplex *x, integer *
+			     ldx, real *beta, singlecomplex *b, integer *ldb);
+
+/* Subroutine */ int clahef_(char *uplo, integer *n, integer *nb, integer *kb, 
+			     singlecomplex *a, integer *lda, integer *ipiv, singlecomplex *w, integer *ldw, 
+			     integer *info);
+
+/* Subroutine */ int clahqr_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ilo, integer *ihi, singlecomplex *h__, integer *ldh, singlecomplex *w, 
+			     integer *iloz, integer *ihiz, singlecomplex *z__, integer *ldz, integer *
+			     info);
+
+/* Subroutine */ int clahr2_(integer *n, integer *k, integer *nb, singlecomplex *a, 
+			     integer *lda, singlecomplex *tau, singlecomplex *t, integer *ldt, singlecomplex *y, 
+			     integer *ldy);
+
+/* Subroutine */ int clahrd_(integer *n, integer *k, integer *nb, singlecomplex *a, 
+			     integer *lda, singlecomplex *tau, singlecomplex *t, integer *ldt, singlecomplex *y, 
+			     integer *ldy);
+
+/* Subroutine */ int claic1_(integer *job, integer *j, singlecomplex *x, real *sest, 
+			     singlecomplex *w, singlecomplex *gamma, real *sestpr, singlecomplex *s, singlecomplex *c__);
+
+/* Subroutine */ int clals0_(integer *icompq, integer *nl, integer *nr, 
+			     integer *sqre, integer *nrhs, singlecomplex *b, integer *ldb, singlecomplex *bx, 
+			     integer *ldbx, integer *perm, integer *givptr, integer *givcol, 
+			     integer *ldgcol, real *givnum, integer *ldgnum, real *poles, real *
+			     difl, real *difr, real *z__, integer *k, real *c__, real *s, real *
+			     rwork, integer *info);
+
+/* Subroutine */ int clalsa_(integer *icompq, integer *smlsiz, integer *n, 
+			     integer *nrhs, singlecomplex *b, integer *ldb, singlecomplex *bx, integer *ldbx, 
+			     real *u, integer *ldu, real *vt, integer *k, real *difl, real *difr, 
+			     real *z__, real *poles, integer *givptr, integer *givcol, integer *
+			     ldgcol, integer *perm, real *givnum, real *c__, real *s, real *rwork, 
+			     integer *iwork, integer *info);
+
+/* Subroutine */ int clalsd_(char *uplo, integer *smlsiz, integer *n, integer 
+			     *nrhs, real *d__, real *e, singlecomplex *b, integer *ldb, real *rcond, 
+			     integer *rank, singlecomplex *work, real *rwork, integer *iwork, integer *
+			     info);
+
+doublereal clangb_(char *norm, integer *n, integer *kl, integer *ku, singlecomplex *
+		   ab, integer *ldab, real *work);
+
+doublereal clange_(char *norm, integer *m, integer *n, singlecomplex *a, integer *
+		   lda, real *work);
+
+doublereal clangt_(char *norm, integer *n, singlecomplex *dl, singlecomplex *d__, singlecomplex 
+		   *du);
+
+doublereal clanhb_(char *norm, char *uplo, integer *n, integer *k, singlecomplex *
+		   ab, integer *ldab, real *work);
+
+doublereal clanhe_(char *norm, char *uplo, integer *n, singlecomplex *a, integer *
+		   lda, real *work);
+
+doublereal clanhf_(char *norm, char *transr, char *uplo, integer *n, singlecomplex *
+		   a, real *work);
+
+doublereal clanhp_(char *norm, char *uplo, integer *n, singlecomplex *ap, real *
+		   work);
+
+doublereal clanhs_(char *norm, integer *n, singlecomplex *a, integer *lda, real *
+		   work);
+
+doublereal clanht_(char *norm, integer *n, real *d__, singlecomplex *e);
+
+doublereal clansb_(char *norm, char *uplo, integer *n, integer *k, singlecomplex *
+		   ab, integer *ldab, real *work);
+
+doublereal clansp_(char *norm, char *uplo, integer *n, singlecomplex *ap, real *
+		   work);
+
+doublereal clansy_(char *norm, char *uplo, integer *n, singlecomplex *a, integer *
+		   lda, real *work);
+
+doublereal clantb_(char *norm, char *uplo, char *diag, integer *n, integer *k, 
+		   singlecomplex *ab, integer *ldab, real *work);
+
+doublereal clantp_(char *norm, char *uplo, char *diag, integer *n, singlecomplex *
+		   ap, real *work);
+
+doublereal clantr_(char *norm, char *uplo, char *diag, integer *m, integer *n, 
+		   singlecomplex *a, integer *lda, real *work);
+
+/* Subroutine */ int clapll_(integer *n, singlecomplex *x, integer *incx, singlecomplex *
+			     y, integer *incy, real *ssmin);
+
+/* Subroutine */ int clapmt_(logical *forwrd, integer *m, integer *n, singlecomplex 
+			     *x, integer *ldx, integer *k);
+
+/* Subroutine */ int claqgb_(integer *m, integer *n, integer *kl, integer *ku, 
+			     singlecomplex *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real 
+			     *colcnd, real *amax, char *equed);
+
+/* Subroutine */ int claqge_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, char *
+			     equed);
+
+/* Subroutine */ int claqhb_(char *uplo, integer *n, integer *kd, singlecomplex *ab, 
+			     integer *ldab, real *s, real *scond, real *amax, char *equed);
+
+/* Subroutine */ int claqhe_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     real *s, real *scond, real *amax, char *equed);
+
+/* Subroutine */ int claqhp_(char *uplo, integer *n, singlecomplex *ap, real *s, 
+			     real *scond, real *amax, char *equed);
+
+/* Subroutine */ int claqp2_(integer *m, integer *n, integer *offset, singlecomplex 
+			     *a, integer *lda, integer *jpvt, singlecomplex *tau, real *vn1, real *vn2, 
+			     singlecomplex *work);
+
+/* Subroutine */ int claqps_(integer *m, integer *n, integer *offset, integer 
+			     *nb, integer *kb, singlecomplex *a, integer *lda, integer *jpvt, singlecomplex *
+			     tau, real *vn1, real *vn2, singlecomplex *auxv, singlecomplex *f, integer *ldf);
+
+/* Subroutine */ int claqr0_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ilo, integer *ihi, singlecomplex *h__, integer *ldh, singlecomplex *w, 
+			     integer *iloz, integer *ihiz, singlecomplex *z__, integer *ldz, singlecomplex *
+			     work, integer *lwork, integer *info);
+
+/* Subroutine */ int claqr1_(integer *n, singlecomplex *h__, integer *ldh, singlecomplex *
+			     s1, singlecomplex *s2, singlecomplex *v);
+
+/* Subroutine */ int claqr2_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ktop, integer *kbot, integer *nw, singlecomplex *h__, integer *ldh, 
+			     integer *iloz, integer *ihiz, singlecomplex *z__, integer *ldz, integer *
+			     ns, integer *nd, singlecomplex *sh, singlecomplex *v, integer *ldv, integer *nh, 
+			     singlecomplex *t, integer *ldt, integer *nv, singlecomplex *wv, integer *ldwv, 
+			     singlecomplex *work, integer *lwork);
+
+/* Subroutine */ int claqr3_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ktop, integer *kbot, integer *nw, singlecomplex *h__, integer *ldh, 
+			     integer *iloz, integer *ihiz, singlecomplex *z__, integer *ldz, integer *
+			     ns, integer *nd, singlecomplex *sh, singlecomplex *v, integer *ldv, integer *nh, 
+			     singlecomplex *t, integer *ldt, integer *nv, singlecomplex *wv, integer *ldwv, 
+			     singlecomplex *work, integer *lwork);
+
+/* Subroutine */ int claqr4_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ilo, integer *ihi, singlecomplex *h__, integer *ldh, singlecomplex *w, 
+			     integer *iloz, integer *ihiz, singlecomplex *z__, integer *ldz, singlecomplex *
+			     work, integer *lwork, integer *info);
+
+/* Subroutine */ int claqr5_(logical *wantt, logical *wantz, integer *kacc22, 
+			     integer *n, integer *ktop, integer *kbot, integer *nshfts, singlecomplex *s, 
+			     singlecomplex *h__, integer *ldh, integer *iloz, integer *ihiz, singlecomplex *
+			     z__, integer *ldz, singlecomplex *v, integer *ldv, singlecomplex *u, integer *ldu, 
+			     integer *nv, singlecomplex *wv, integer *ldwv, integer *nh, singlecomplex *wh, 
+			     integer *ldwh);
+
+/* Subroutine */ int claqsb_(char *uplo, integer *n, integer *kd, singlecomplex *ab, 
+			     integer *ldab, real *s, real *scond, real *amax, char *equed);
+
+/* Subroutine */ int claqsp_(char *uplo, integer *n, singlecomplex *ap, real *s, 
+			     real *scond, real *amax, char *equed);
+
+/* Subroutine */ int claqsy_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     real *s, real *scond, real *amax, char *equed);
+
+/* Subroutine */ int clar1v_(integer *n, integer *b1, integer *bn, real *
+			     lambda, real *d__, real *l, real *ld, real *lld, real *pivmin, real *
+			     gaptol, singlecomplex *z__, logical *wantnc, integer *negcnt, real *ztz, 
+			     real *mingma, integer *r__, integer *isuppz, real *nrminv, real *
+			     resid, real *rqcorr, real *work);
+
+/* Subroutine */ int clar2v_(integer *n, singlecomplex *x, singlecomplex *y, singlecomplex *z__, 
+			     integer *incx, real *c__, singlecomplex *s, integer *incc);
+
+/* Subroutine */ int clarcm_(integer *m, integer *n, real *a, integer *lda, 
+			     singlecomplex *b, integer *ldb, singlecomplex *c__, integer *ldc, real *rwork);
+
+/* Subroutine */ int clarf_(char *side, integer *m, integer *n, singlecomplex *v, 
+			    integer *incv, singlecomplex *tau, singlecomplex *c__, integer *ldc, singlecomplex *
+			    work);
+
+/* Subroutine */ int clarfb_(char *side, char *trans, char *direct, char *
+			     storev, integer *m, integer *n, integer *k, singlecomplex *v, integer *ldv, 
+			     singlecomplex *t, integer *ldt, singlecomplex *c__, integer *ldc, singlecomplex *work, 
+			     integer *ldwork);
+
+/* Subroutine */ int clarfg_(integer *n, singlecomplex *alpha, singlecomplex *x, integer *
+			     incx, singlecomplex *tau);
+
+/* Subroutine */ int clarfp_(integer *n, singlecomplex *alpha, singlecomplex *x, integer *
+			     incx, singlecomplex *tau);
+
+/* Subroutine */ int clarft_(char *direct, char *storev, integer *n, integer *
+			     k, singlecomplex *v, integer *ldv, singlecomplex *tau, singlecomplex *t, integer *ldt);
+
+/* Subroutine */ int clarfx_(char *side, integer *m, integer *n, singlecomplex *v, 
+			     singlecomplex *tau, singlecomplex *c__, integer *ldc, singlecomplex *work);
+
+/* Subroutine */ int clargv_(integer *n, singlecomplex *x, integer *incx, singlecomplex *
+			     y, integer *incy, real *c__, integer *incc);
+
+/* Subroutine */ int clarnv_(integer *idist, integer *iseed, integer *n, 
+			     singlecomplex *x);
+
+/* Subroutine */ int clarrv_(integer *n, real *vl, real *vu, real *d__, real *
+			     l, real *pivmin, integer *isplit, integer *m, integer *dol, integer *
+			     dou, real *minrgp, real *rtol1, real *rtol2, real *w, real *werr, 
+			     real *wgap, integer *iblock, integer *indexw, real *gers, singlecomplex *
+			     z__, integer *ldz, integer *isuppz, real *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int clarscl2_(integer *m, integer *n, real *d__, singlecomplex *x, 
+			       integer *ldx);
+
+/* Subroutine */ int clartg_(singlecomplex *f, singlecomplex *g, real *cs, singlecomplex *sn, 
+			     singlecomplex *r__);
+
+/* Subroutine */ int clartv_(integer *n, singlecomplex *x, integer *incx, singlecomplex *
+			     y, integer *incy, real *c__, singlecomplex *s, integer *incc);
+
+/* Subroutine */ int clarz_(char *side, integer *m, integer *n, integer *l, 
+			    singlecomplex *v, integer *incv, singlecomplex *tau, singlecomplex *c__, integer *ldc, 
+			    singlecomplex *work);
+
+/* Subroutine */ int clarzb_(char *side, char *trans, char *direct, char *
+			     storev, integer *m, integer *n, integer *k, integer *l, singlecomplex *v, 
+			     integer *ldv, singlecomplex *t, integer *ldt, singlecomplex *c__, integer *ldc, 
+			     singlecomplex *work, integer *ldwork);
+
+/* Subroutine */ int clarzt_(char *direct, char *storev, integer *n, integer *
+			     k, singlecomplex *v, integer *ldv, singlecomplex *tau, singlecomplex *t, integer *ldt);
+
+/* Subroutine */ int clascl_(char *type__, integer *kl, integer *ku, real *
+			     cfrom, real *cto, integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     integer *info);
+
+/* Subroutine */ int clascl2_(integer *m, integer *n, real *d__, singlecomplex *x, 
+			      integer *ldx);
+
+/* Subroutine */ int claset_(char *uplo, integer *m, integer *n, singlecomplex *
+			     alpha, singlecomplex *beta, singlecomplex *a, integer *lda);
+
+/* Subroutine */ int clasr_(char *side, char *pivot, char *direct, integer *m, 
+			    integer *n, real *c__, real *s, singlecomplex *a, integer *lda);
+
+/* Subroutine */ int classq_(integer *n, singlecomplex *x, integer *incx, real *
+			     scale, real *sumsq);
+
+/* Subroutine */ int claswp_(integer *n, singlecomplex *a, integer *lda, integer *
+			     k1, integer *k2, integer *ipiv, integer *incx);
+
+/* Subroutine */ int clasyf_(char *uplo, integer *n, integer *nb, integer *kb, 
+			     singlecomplex *a, integer *lda, integer *ipiv, singlecomplex *w, integer *ldw, 
+			     integer *info);
+
+/* Subroutine */ int clatbs_(char *uplo, char *trans, char *diag, char *
+			     normin, integer *n, integer *kd, singlecomplex *ab, integer *ldab, singlecomplex *
+			     x, real *scale, real *cnorm, integer *info);
+
+/* Subroutine */ int clatdf_(integer *ijob, integer *n, singlecomplex *z__, integer 
+			     *ldz, singlecomplex *rhs, real *rdsum, real *rdscal, integer *ipiv, integer 
+			     *jpiv);
+
+/* Subroutine */ int clatps_(char *uplo, char *trans, char *diag, char *
+			     normin, integer *n, singlecomplex *ap, singlecomplex *x, real *scale, real *cnorm, 
+			     integer *info);
+
+/* Subroutine */ int clatrd_(char *uplo, integer *n, integer *nb, singlecomplex *a, 
+			     integer *lda, real *e, singlecomplex *tau, singlecomplex *w, integer *ldw);
+
+/* Subroutine */ int clatrs_(char *uplo, char *trans, char *diag, char *
+			     normin, integer *n, singlecomplex *a, integer *lda, singlecomplex *x, real *scale, 
+			     real *cnorm, integer *info);
+
+/* Subroutine */ int clatrz_(integer *m, integer *n, integer *l, singlecomplex *a, 
+			     integer *lda, singlecomplex *tau, singlecomplex *work);
+
+/* Subroutine */ int clatzm_(char *side, integer *m, integer *n, singlecomplex *v, 
+			     integer *incv, singlecomplex *tau, singlecomplex *c1, singlecomplex *c2, integer *ldc, 
+			     singlecomplex *work);
+
+/* Subroutine */ int clauu2_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     integer *info);
+
+/* Subroutine */ int clauum_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     integer *info);
+
+/* Subroutine */ int cpbcon_(char *uplo, integer *n, integer *kd, singlecomplex *ab, 
+			     integer *ldab, real *anorm, real *rcond, singlecomplex *work, real *rwork, 
+			     integer *info);
+
+/* Subroutine */ int cpbequ_(char *uplo, integer *n, integer *kd, singlecomplex *ab, 
+			     integer *ldab, real *s, real *scond, real *amax, integer *info);
+
+/* Subroutine */ int cpbrfs_(char *uplo, integer *n, integer *kd, integer *
+			     nrhs, singlecomplex *ab, integer *ldab, singlecomplex *afb, integer *ldafb, 
+			     singlecomplex *b, integer *ldb, singlecomplex *x, integer *ldx, real *ferr, real *
+			     berr, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cpbstf_(char *uplo, integer *n, integer *kd, singlecomplex *ab, 
+			     integer *ldab, integer *info);
+
+/* Subroutine */ int cpbsv_(char *uplo, integer *n, integer *kd, integer *
+			    nrhs, singlecomplex *ab, integer *ldab, singlecomplex *b, integer *ldb, integer *
+			    info);
+
+/* Subroutine */ int cpbsvx_(char *fact, char *uplo, integer *n, integer *kd, 
+			     integer *nrhs, singlecomplex *ab, integer *ldab, singlecomplex *afb, integer *
+			     ldafb, char *equed, real *s, singlecomplex *b, integer *ldb, singlecomplex *x, 
+			     integer *ldx, real *rcond, real *ferr, real *berr, singlecomplex *work, 
+			     real *rwork, integer *info);
+
+/* Subroutine */ int cpbtf2_(char *uplo, integer *n, integer *kd, singlecomplex *ab, 
+			     integer *ldab, integer *info);
+
+/* Subroutine */ int cpbtrf_(char *uplo, integer *n, integer *kd, singlecomplex *ab, 
+			     integer *ldab, integer *info);
+
+/* Subroutine */ int cpbtrs_(char *uplo, integer *n, integer *kd, integer *
+			     nrhs, singlecomplex *ab, integer *ldab, singlecomplex *b, integer *ldb, integer *
+			     info);
+
+/* Subroutine */ int cpftrf_(char *transr, char *uplo, integer *n, singlecomplex *a, 
+			     integer *info);
+
+/* Subroutine */ int cpftri_(char *transr, char *uplo, integer *n, singlecomplex *a, 
+			     integer *info);
+
+/* Subroutine */ int cpftrs_(char *transr, char *uplo, integer *n, integer *
+			     nrhs, singlecomplex *a, singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cpocon_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     real *anorm, real *rcond, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cpoequ_(integer *n, singlecomplex *a, integer *lda, real *s, 
+			     real *scond, real *amax, integer *info);
+
+/* Subroutine */ int cpoequb_(integer *n, singlecomplex *a, integer *lda, real *s, 
+			      real *scond, real *amax, integer *info);
+
+/* Subroutine */ int cporfs_(char *uplo, integer *n, integer *nrhs, singlecomplex *
+			     a, integer *lda, singlecomplex *af, integer *ldaf, singlecomplex *b, integer *ldb, 
+			     singlecomplex *x, integer *ldx, real *ferr, real *berr, singlecomplex *work, 
+			     real *rwork, integer *info);
+
+/* Subroutine */ int cporfsx_(char *uplo, char *equed, integer *n, integer *
+			      nrhs, singlecomplex *a, integer *lda, singlecomplex *af, integer *ldaf, real *s, 
+			      singlecomplex *b, integer *ldb, singlecomplex *x, integer *ldx, real *rcond, real 
+			      *berr, integer *n_err_bnds__, real *err_bnds_norm__, real *
+			      err_bnds_comp__, integer *nparams, real *params, singlecomplex *work, real *
+			      rwork, integer *info);
+
+/* Subroutine */ int cposv_(char *uplo, integer *n, integer *nrhs, singlecomplex *a, 
+			    integer *lda, singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cposvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, singlecomplex *a, integer *lda, singlecomplex *af, integer *ldaf, char *
+			     equed, real *s, singlecomplex *b, integer *ldb, singlecomplex *x, integer *ldx, 
+			     real *rcond, real *ferr, real *berr, singlecomplex *work, real *rwork, 
+			     integer *info);
+
+/* Subroutine */ int cposvxx_(char *fact, char *uplo, integer *n, integer *
+			      nrhs, singlecomplex *a, integer *lda, singlecomplex *af, integer *ldaf, char *
+			      equed, real *s, singlecomplex *b, integer *ldb, singlecomplex *x, integer *ldx, 
+			      real *rcond, real *rpvgrw, real *berr, integer *n_err_bnds__, real *
+			      err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real *
+			      params, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cpotf2_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     integer *info);
+
+/* Subroutine */ int cpotrf_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     integer *info);
+
+/* Subroutine */ int cpotri_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     integer *info);
+
+/* Subroutine */ int cpotrs_(char *uplo, integer *n, integer *nrhs, singlecomplex *
+			     a, integer *lda, singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cppcon_(char *uplo, integer *n, singlecomplex *ap, real *anorm, 
+			     real *rcond, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cppequ_(char *uplo, integer *n, singlecomplex *ap, real *s, 
+			     real *scond, real *amax, integer *info);
+
+/* Subroutine */ int cpprfs_(char *uplo, integer *n, integer *nrhs, singlecomplex *
+			     ap, singlecomplex *afp, singlecomplex *b, integer *ldb, singlecomplex *x, integer *ldx, 
+			     real *ferr, real *berr, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cppsv_(char *uplo, integer *n, integer *nrhs, singlecomplex *
+			    ap, singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cppsvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, singlecomplex *ap, singlecomplex *afp, char *equed, real *s, singlecomplex *b, 
+			     integer *ldb, singlecomplex *x, integer *ldx, real *rcond, real *ferr, real 
+			     *berr, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cpptrf_(char *uplo, integer *n, singlecomplex *ap, integer *
+			     info);
+
+/* Subroutine */ int cpptri_(char *uplo, integer *n, singlecomplex *ap, integer *
+			     info);
+
+/* Subroutine */ int cpptrs_(char *uplo, integer *n, integer *nrhs, singlecomplex *
+			     ap, singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cpstf2_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     integer *piv, integer *rank, real *tol, real *work, integer *info);
+
+/* Subroutine */ int cpstrf_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     integer *piv, integer *rank, real *tol, real *work, integer *info);
+
+/* Subroutine */ int cptcon_(integer *n, real *d__, singlecomplex *e, real *anorm, 
+			     real *rcond, real *rwork, integer *info);
+
+/* Subroutine */ int cpteqr_(char *compz, integer *n, real *d__, real *e, 
+			     singlecomplex *z__, integer *ldz, real *work, integer *info);
+
+/* Subroutine */ int cptrfs_(char *uplo, integer *n, integer *nrhs, real *d__, 
+			     singlecomplex *e, real *df, singlecomplex *ef, singlecomplex *b, integer *ldb, singlecomplex 
+			     *x, integer *ldx, real *ferr, real *berr, singlecomplex *work, real *rwork, 
+			     integer *info);
+
+/* Subroutine */ int cptsv_(integer *n, integer *nrhs, real *d__, singlecomplex *e, 
+			    singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cptsvx_(char *fact, integer *n, integer *nrhs, real *d__, 
+			     singlecomplex *e, real *df, singlecomplex *ef, singlecomplex *b, integer *ldb, singlecomplex 
+			     *x, integer *ldx, real *rcond, real *ferr, real *berr, singlecomplex *work, 
+			     real *rwork, integer *info);
+
+/* Subroutine */ int cpttrf_(integer *n, real *d__, singlecomplex *e, integer *info);
+
+/* Subroutine */ int cpttrs_(char *uplo, integer *n, integer *nrhs, real *d__, 
+			     singlecomplex *e, singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cptts2_(integer *iuplo, integer *n, integer *nrhs, real *
+			     d__, singlecomplex *e, singlecomplex *b, integer *ldb);
+
+/* Subroutine */ int crot_(integer *n, singlecomplex *cx, integer *incx, singlecomplex *
+			   cy, integer *incy, real *c__, singlecomplex *s);
+
+/* Subroutine */ int cspcon_(char *uplo, integer *n, singlecomplex *ap, integer *
+			     ipiv, real *anorm, real *rcond, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cspmv_(char *uplo, integer *n, singlecomplex *alpha, singlecomplex *
+			    ap, singlecomplex *x, integer *incx, singlecomplex *beta, singlecomplex *y, integer *
+			    incy);
+
+/* Subroutine */ int cspr_(char *uplo, integer *n, singlecomplex *alpha, singlecomplex *x, 
+			   integer *incx, singlecomplex *ap);
+
+/* Subroutine */ int csprfs_(char *uplo, integer *n, integer *nrhs, singlecomplex *
+			     ap, singlecomplex *afp, integer *ipiv, singlecomplex *b, integer *ldb, singlecomplex *x, 
+			     integer *ldx, real *ferr, real *berr, singlecomplex *work, real *rwork, 
+			     integer *info);
+
+/* Subroutine */ int cspsv_(char *uplo, integer *n, integer *nrhs, singlecomplex *
+			    ap, integer *ipiv, singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cspsvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, singlecomplex *ap, singlecomplex *afp, integer *ipiv, singlecomplex *b, integer *
+			     ldb, singlecomplex *x, integer *ldx, real *rcond, real *ferr, real *berr, 
+			     singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int csptrf_(char *uplo, integer *n, singlecomplex *ap, integer *
+			     ipiv, integer *info);
+
+/* Subroutine */ int csptri_(char *uplo, integer *n, singlecomplex *ap, integer *
+			     ipiv, singlecomplex *work, integer *info);
+
+/* Subroutine */ int csptrs_(char *uplo, integer *n, integer *nrhs, singlecomplex *
+			     ap, integer *ipiv, singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int csrscl_(integer *n, real *sa, singlecomplex *sx, integer *incx);
+
+/* Subroutine */ int cstedc_(char *compz, integer *n, real *d__, real *e, 
+			     singlecomplex *z__, integer *ldz, singlecomplex *work, integer *lwork, real *
+			     rwork, integer *lrwork, integer *iwork, integer *liwork, integer *
+			     info);
+
+/* Subroutine */ int cstegr_(char *jobz, char *range, integer *n, real *d__, 
+			     real *e, real *vl, real *vu, integer *il, integer *iu, real *abstol, 
+			     integer *m, real *w, singlecomplex *z__, integer *ldz, integer *isuppz, 
+			     real *work, integer *lwork, integer *iwork, integer *liwork, integer *
+			     info);
+
+/* Subroutine */ int cstein_(integer *n, real *d__, real *e, integer *m, real 
+			     *w, integer *iblock, integer *isplit, singlecomplex *z__, integer *ldz, 
+			     real *work, integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int cstemr_(char *jobz, char *range, integer *n, real *d__, 
+			     real *e, real *vl, real *vu, integer *il, integer *iu, integer *m, 
+			     real *w, singlecomplex *z__, integer *ldz, integer *nzc, integer *isuppz, 
+			     logical *tryrac, real *work, integer *lwork, integer *iwork, integer *
+			     liwork, integer *info);
+
+/* Subroutine */ int csteqr_(char *compz, integer *n, real *d__, real *e, 
+			     singlecomplex *z__, integer *ldz, real *work, integer *info);
+
+/* Subroutine */ int csycon_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     integer *ipiv, real *anorm, real *rcond, singlecomplex *work, integer *
+			     info);
+
+/* Subroutine */ int csyequb_(char *uplo, integer *n, singlecomplex *a, integer *
+			      lda, real *s, real *scond, real *amax, singlecomplex *work, integer *info);
+
+/* Subroutine */ int csymv_(char *uplo, integer *n, singlecomplex *alpha, singlecomplex *
+			    a, integer *lda, singlecomplex *x, integer *incx, singlecomplex *beta, singlecomplex *y, 
+			    integer *incy);
+
+/* Subroutine */ int csyr_(char *uplo, integer *n, singlecomplex *alpha, singlecomplex *x, 
+			   integer *incx, singlecomplex *a, integer *lda);
+
+/* Subroutine */ int csyrfs_(char *uplo, integer *n, integer *nrhs, singlecomplex *
+			     a, integer *lda, singlecomplex *af, integer *ldaf, integer *ipiv, singlecomplex *
+			     b, integer *ldb, singlecomplex *x, integer *ldx, real *ferr, real *berr, 
+			     singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int csyrfsx_(char *uplo, char *equed, integer *n, integer *
+			      nrhs, singlecomplex *a, integer *lda, singlecomplex *af, integer *ldaf, integer *
+			      ipiv, real *s, singlecomplex *b, integer *ldb, singlecomplex *x, integer *ldx, 
+			      real *rcond, real *berr, integer *n_err_bnds__, real *err_bnds_norm__, 
+			      real *err_bnds_comp__, integer *nparams, real *params, singlecomplex *work, 
+			      real *rwork, integer *info);
+
+/* Subroutine */ int csysv_(char *uplo, integer *n, integer *nrhs, singlecomplex *a, 
+			    integer *lda, integer *ipiv, singlecomplex *b, integer *ldb, singlecomplex *work, 
+			    integer *lwork, integer *info);
+
+/* Subroutine */ int csysvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, singlecomplex *a, integer *lda, singlecomplex *af, integer *ldaf, integer *
+			     ipiv, singlecomplex *b, integer *ldb, singlecomplex *x, integer *ldx, real *rcond, 
+			     real *ferr, real *berr, singlecomplex *work, integer *lwork, real *rwork, 
+			     integer *info);
+
+/* Subroutine */ int csysvxx_(char *fact, char *uplo, integer *n, integer *
+			      nrhs, singlecomplex *a, integer *lda, singlecomplex *af, integer *ldaf, integer *
+			      ipiv, char *equed, real *s, singlecomplex *b, integer *ldb, singlecomplex *x, 
+			      integer *ldx, real *rcond, real *rpvgrw, real *berr, integer *
+			      n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, integer *
+			      nparams, real *params, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int csytf2_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     integer *ipiv, integer *info);
+
+/* Subroutine */ int csytrf_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     integer *ipiv, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int csytri_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     integer *ipiv, singlecomplex *work, integer *info);
+
+/* Subroutine */ int csytrs_(char *uplo, integer *n, integer *nrhs, singlecomplex *
+			     a, integer *lda, integer *ipiv, singlecomplex *b, integer *ldb, integer *
+			     info);
+
+/* Subroutine */ int ctbcon_(char *norm, char *uplo, char *diag, integer *n, 
+			     integer *kd, singlecomplex *ab, integer *ldab, real *rcond, singlecomplex *work, 
+			     real *rwork, integer *info);
+
+/* Subroutine */ int ctbrfs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *kd, integer *nrhs, singlecomplex *ab, integer *ldab, singlecomplex *b, 
+			     integer *ldb, singlecomplex *x, integer *ldx, real *ferr, real *berr, 
+			     singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int ctbtrs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *kd, integer *nrhs, singlecomplex *ab, integer *ldab, singlecomplex *b, 
+			     integer *ldb, integer *info);
+
+/* Subroutine */ int ctfsm_(char *transr, char *side, char *uplo, char *trans, 
+			    char *diag, integer *m, integer *n, singlecomplex *alpha, singlecomplex *a, 
+			    singlecomplex *b, integer *ldb);
+
+/* Subroutine */ int ctftri_(char *transr, char *uplo, char *diag, integer *n, 
+			     singlecomplex *a, integer *info);
+
+/* Subroutine */ int ctfttp_(char *transr, char *uplo, integer *n, singlecomplex *
+			     arf, singlecomplex *ap, integer *info);
+
+/* Subroutine */ int ctfttr_(char *transr, char *uplo, integer *n, singlecomplex *
+			     arf, singlecomplex *a, integer *lda, integer *info);
+
+/* Subroutine */ int ctgevc_(char *side, char *howmny, logical *select, 
+			     integer *n, singlecomplex *s, integer *lds, singlecomplex *p, integer *ldp, 
+			     singlecomplex *vl, integer *ldvl, singlecomplex *vr, integer *ldvr, integer *mm, 
+			     integer *m, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int ctgex2_(logical *wantq, logical *wantz, integer *n, 
+			     singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, singlecomplex *q, 
+			     integer *ldq, singlecomplex *z__, integer *ldz, integer *j1, integer *info);
+
+/* Subroutine */ int ctgexc_(logical *wantq, logical *wantz, integer *n, 
+			     singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, singlecomplex *q, 
+			     integer *ldq, singlecomplex *z__, integer *ldz, integer *ifst, integer *
+			     ilst, integer *info);
+
+/* Subroutine */ int ctgsen_(integer *ijob, logical *wantq, logical *wantz, 
+			     logical *select, integer *n, singlecomplex *a, integer *lda, singlecomplex *b, 
+			     integer *ldb, singlecomplex *alpha, singlecomplex *beta, singlecomplex *q, integer *ldq, 
+			     singlecomplex *z__, integer *ldz, integer *m, real *pl, real *pr, real *
+			     dif, singlecomplex *work, integer *lwork, integer *iwork, integer *liwork, 
+			     integer *info);
+
+/* Subroutine */ int ctgsja_(char *jobu, char *jobv, char *jobq, integer *m, 
+			     integer *p, integer *n, integer *k, integer *l, singlecomplex *a, integer *
+			     lda, singlecomplex *b, integer *ldb, real *tola, real *tolb, real *alpha, 
+			     real *beta, singlecomplex *u, integer *ldu, singlecomplex *v, integer *ldv, 
+			     singlecomplex *q, integer *ldq, singlecomplex *work, integer *ncycle, integer *
+			     info);
+
+/* Subroutine */ int ctgsna_(char *job, char *howmny, logical *select, 
+			     integer *n, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, 
+			     singlecomplex *vl, integer *ldvl, singlecomplex *vr, integer *ldvr, real *s, real 
+			     *dif, integer *mm, integer *m, singlecomplex *work, integer *lwork, integer 
+			     *iwork, integer *info);
+
+/* Subroutine */ int ctgsy2_(char *trans, integer *ijob, integer *m, integer *
+			     n, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, singlecomplex *c__, 
+			     integer *ldc, singlecomplex *d__, integer *ldd, singlecomplex *e, integer *lde, 
+			     singlecomplex *f, integer *ldf, real *scale, real *rdsum, real *rdscal, 
+			     integer *info);
+
+/* Subroutine */ int ctgsyl_(char *trans, integer *ijob, integer *m, integer *
+			     n, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, singlecomplex *c__, 
+			     integer *ldc, singlecomplex *d__, integer *ldd, singlecomplex *e, integer *lde, 
+			     singlecomplex *f, integer *ldf, real *scale, real *dif, singlecomplex *work, 
+			     integer *lwork, integer *iwork, integer *info);
+
+/* Subroutine */ int ctpcon_(char *norm, char *uplo, char *diag, integer *n, 
+			     singlecomplex *ap, real *rcond, singlecomplex *work, real *rwork, integer *info);
+
+/* Subroutine */ int ctprfs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, singlecomplex *ap, singlecomplex *b, integer *ldb, singlecomplex *x, 
+			     integer *ldx, real *ferr, real *berr, singlecomplex *work, real *rwork, 
+			     integer *info);
+
+/* Subroutine */ int ctptri_(char *uplo, char *diag, integer *n, singlecomplex *ap, 
+			     integer *info);
+
+/* Subroutine */ int ctptrs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, singlecomplex *ap, singlecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int ctpttf_(char *transr, char *uplo, integer *n, singlecomplex *
+			     ap, singlecomplex *arf, integer *info);
+
+/* Subroutine */ int ctpttr_(char *uplo, integer *n, singlecomplex *ap, singlecomplex *a, 
+			     integer *lda, integer *info);
+
+/* Subroutine */ int ctrcon_(char *norm, char *uplo, char *diag, integer *n, 
+			     singlecomplex *a, integer *lda, real *rcond, singlecomplex *work, real *rwork, 
+			     integer *info);
+
+/* Subroutine */ int ctrevc_(char *side, char *howmny, logical *select, 
+			     integer *n, singlecomplex *t, integer *ldt, singlecomplex *vl, integer *ldvl, 
+			     singlecomplex *vr, integer *ldvr, integer *mm, integer *m, singlecomplex *work, 
+			     real *rwork, integer *info);
+
+/* Subroutine */ int ctrexc_(char *compq, integer *n, singlecomplex *t, integer *
+			     ldt, singlecomplex *q, integer *ldq, integer *ifst, integer *ilst, integer *
+			     info);
+
+/* Subroutine */ int ctrrfs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, 
+			     singlecomplex *x, integer *ldx, real *ferr, real *berr, singlecomplex *work, real 
+			     *rwork, integer *info);
+
+/* Subroutine */ int ctrsen_(char *job, char *compq, logical *select, integer 
+			     *n, singlecomplex *t, integer *ldt, singlecomplex *q, integer *ldq, singlecomplex *w, 
+			     integer *m, real *s, real *sep, singlecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int ctrsna_(char *job, char *howmny, logical *select, 
+			     integer *n, singlecomplex *t, integer *ldt, singlecomplex *vl, integer *ldvl, 
+			     singlecomplex *vr, integer *ldvr, real *s, real *sep, integer *mm, integer *
+			     m, singlecomplex *work, integer *ldwork, real *rwork, integer *info);
+
+/* Subroutine */ int ctrsyl_(char *trana, char *tranb, integer *isgn, integer 
+			     *m, integer *n, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, 
+			     singlecomplex *c__, integer *ldc, real *scale, integer *info);
+
+/* Subroutine */ int ctrti2_(char *uplo, char *diag, integer *n, singlecomplex *a, 
+			     integer *lda, integer *info);
+
+/* Subroutine */ int ctrtri_(char *uplo, char *diag, integer *n, singlecomplex *a, 
+			     integer *lda, integer *info);
+
+/* Subroutine */ int ctrtrs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, singlecomplex *a, integer *lda, singlecomplex *b, integer *ldb, 
+			     integer *info);
+
+/* Subroutine */ int ctrttf_(char *transr, char *uplo, integer *n, singlecomplex *a, 
+			     integer *lda, singlecomplex *arf, integer *info);
+
+/* Subroutine */ int ctrttp_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     singlecomplex *ap, integer *info);
+
+/* Subroutine */ int ctzrqf_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     singlecomplex *tau, integer *info);
+
+/* Subroutine */ int ctzrzf_(integer *m, integer *n, singlecomplex *a, integer *lda, 
+			     singlecomplex *tau, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cung2l_(integer *m, integer *n, integer *k, singlecomplex *a, 
+			     integer *lda, singlecomplex *tau, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cung2r_(integer *m, integer *n, integer *k, singlecomplex *a, 
+			     integer *lda, singlecomplex *tau, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cungbr_(char *vect, integer *m, integer *n, integer *k, 
+			     singlecomplex *a, integer *lda, singlecomplex *tau, singlecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int cunghr_(integer *n, integer *ilo, integer *ihi, singlecomplex *
+			     a, integer *lda, singlecomplex *tau, singlecomplex *work, integer *lwork, integer 
+			     *info);
+
+/* Subroutine */ int cungl2_(integer *m, integer *n, integer *k, singlecomplex *a, 
+			     integer *lda, singlecomplex *tau, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cunglq_(integer *m, integer *n, integer *k, singlecomplex *a, 
+			     integer *lda, singlecomplex *tau, singlecomplex *work, integer *lwork, integer *
+			     info);
+
+/* Subroutine */ int cungql_(integer *m, integer *n, integer *k, singlecomplex *a, 
+			     integer *lda, singlecomplex *tau, singlecomplex *work, integer *lwork, integer *
+			     info);
+
+/* Subroutine */ int cungqr_(integer *m, integer *n, integer *k, singlecomplex *a, 
+			     integer *lda, singlecomplex *tau, singlecomplex *work, integer *lwork, integer *
+			     info);
+
+/* Subroutine */ int cungr2_(integer *m, integer *n, integer *k, singlecomplex *a, 
+			     integer *lda, singlecomplex *tau, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cungrq_(integer *m, integer *n, integer *k, singlecomplex *a, 
+			     integer *lda, singlecomplex *tau, singlecomplex *work, integer *lwork, integer *
+			     info);
+
+/* Subroutine */ int cungtr_(char *uplo, integer *n, singlecomplex *a, integer *lda, 
+			     singlecomplex *tau, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cunm2l_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, singlecomplex *a, integer *lda, singlecomplex *tau, singlecomplex *c__, 
+			     integer *ldc, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cunm2r_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, singlecomplex *a, integer *lda, singlecomplex *tau, singlecomplex *c__, 
+			     integer *ldc, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cunmbr_(char *vect, char *side, char *trans, integer *m, 
+			     integer *n, integer *k, singlecomplex *a, integer *lda, singlecomplex *tau, 
+			     singlecomplex *c__, integer *ldc, singlecomplex *work, integer *lwork, integer *
+			     info);
+
+/* Subroutine */ int cunmhr_(char *side, char *trans, integer *m, integer *n, 
+			     integer *ilo, integer *ihi, singlecomplex *a, integer *lda, singlecomplex *tau, 
+			     singlecomplex *c__, integer *ldc, singlecomplex *work, integer *lwork, integer *
+			     info);
+
+/* Subroutine */ int cunml2_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, singlecomplex *a, integer *lda, singlecomplex *tau, singlecomplex *c__, 
+			     integer *ldc, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cunmlq_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, singlecomplex *a, integer *lda, singlecomplex *tau, singlecomplex *c__, 
+			     integer *ldc, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cunmql_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, singlecomplex *a, integer *lda, singlecomplex *tau, singlecomplex *c__, 
+			     integer *ldc, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cunmqr_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, singlecomplex *a, integer *lda, singlecomplex *tau, singlecomplex *c__, 
+			     integer *ldc, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cunmr2_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, singlecomplex *a, integer *lda, singlecomplex *tau, singlecomplex *c__, 
+			     integer *ldc, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cunmr3_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, integer *l, singlecomplex *a, integer *lda, singlecomplex *tau, 
+			     singlecomplex *c__, integer *ldc, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cunmrq_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, singlecomplex *a, integer *lda, singlecomplex *tau, singlecomplex *c__, 
+			     integer *ldc, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cunmrz_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, integer *l, singlecomplex *a, integer *lda, singlecomplex *tau, 
+			     singlecomplex *c__, integer *ldc, singlecomplex *work, integer *lwork, integer *
+			     info);
+
+/* Subroutine */ int cunmtr_(char *side, char *uplo, char *trans, integer *m, 
+			     integer *n, singlecomplex *a, integer *lda, singlecomplex *tau, singlecomplex *c__, 
+			     integer *ldc, singlecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cupgtr_(char *uplo, integer *n, singlecomplex *ap, singlecomplex *
+			     tau, singlecomplex *q, integer *ldq, singlecomplex *work, integer *info);
+
+/* Subroutine */ int cupmtr_(char *side, char *uplo, char *trans, integer *m, 
+			     integer *n, singlecomplex *ap, singlecomplex *tau, singlecomplex *c__, integer *ldc, 
+			     singlecomplex *work, integer *info);
+
+/* Subroutine */ int dbdsdc_(char *uplo, char *compq, integer *n, doublereal *
+			     d__, doublereal *e, doublereal *u, integer *ldu, doublereal *vt, 
+			     integer *ldvt, doublereal *q, integer *iq, doublereal *work, integer *
+			     iwork, integer *info);
+
+/* Subroutine */ int dbdsqr_(char *uplo, integer *n, integer *ncvt, integer *
+			     nru, integer *ncc, doublereal *d__, doublereal *e, doublereal *vt, 
+			     integer *ldvt, doublereal *u, integer *ldu, doublereal *c__, integer *
+			     ldc, doublereal *work, integer *info);
+
+/* Subroutine */ int ddisna_(char *job, integer *m, integer *n, doublereal *
+			     d__, doublereal *sep, integer *info);
+
+/* Subroutine */ int dgbbrd_(char *vect, integer *m, integer *n, integer *ncc, 
+			     integer *kl, integer *ku, doublereal *ab, integer *ldab, doublereal *
+			     d__, doublereal *e, doublereal *q, integer *ldq, doublereal *pt, 
+			     integer *ldpt, doublereal *c__, integer *ldc, doublereal *work, 
+			     integer *info);
+
+/* Subroutine */ int dgbcon_(char *norm, integer *n, integer *kl, integer *ku, 
+			     doublereal *ab, integer *ldab, integer *ipiv, doublereal *anorm, 
+			     doublereal *rcond, doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dgbequ_(integer *m, integer *n, integer *kl, integer *ku, 
+			     doublereal *ab, integer *ldab, doublereal *r__, doublereal *c__, 
+			     doublereal *rowcnd, doublereal *colcnd, doublereal *amax, integer *
+			     info);
+
+/* Subroutine */ int dgbequb_(integer *m, integer *n, integer *kl, integer *
+			      ku, doublereal *ab, integer *ldab, doublereal *r__, doublereal *c__, 
+			      doublereal *rowcnd, doublereal *colcnd, doublereal *amax, integer *
+			      info);
+
+/* Subroutine */ int dgbrfs_(char *trans, integer *n, integer *kl, integer *
+			     ku, integer *nrhs, doublereal *ab, integer *ldab, doublereal *afb, 
+			     integer *ldafb, integer *ipiv, doublereal *b, integer *ldb, 
+			     doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, 
+			     doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dgbrfsx_(char *trans, char *equed, integer *n, integer *
+			      kl, integer *ku, integer *nrhs, doublereal *ab, integer *ldab, 
+			      doublereal *afb, integer *ldafb, integer *ipiv, doublereal *r__, 
+			      doublereal *c__, doublereal *b, integer *ldb, doublereal *x, integer *
+			      ldx, doublereal *rcond, doublereal *berr, integer *n_err_bnds__, 
+			      doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer *
+			      nparams, doublereal *params, doublereal *work, integer *iwork, 
+			      integer *info);
+
+/* Subroutine */ int dgbsv_(integer *n, integer *kl, integer *ku, integer *
+			    nrhs, doublereal *ab, integer *ldab, integer *ipiv, doublereal *b, 
+			    integer *ldb, integer *info);
+
+/* Subroutine */ int dgbsvx_(char *fact, char *trans, integer *n, integer *kl, 
+			     integer *ku, integer *nrhs, doublereal *ab, integer *ldab, 
+			     doublereal *afb, integer *ldafb, integer *ipiv, char *equed, 
+			     doublereal *r__, doublereal *c__, doublereal *b, integer *ldb, 
+			     doublereal *x, integer *ldx, doublereal *rcond, doublereal *ferr, 
+			     doublereal *berr, doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dgbsvxx_(char *fact, char *trans, integer *n, integer *
+			      kl, integer *ku, integer *nrhs, doublereal *ab, integer *ldab, 
+			      doublereal *afb, integer *ldafb, integer *ipiv, char *equed, 
+			      doublereal *r__, doublereal *c__, doublereal *b, integer *ldb, 
+			      doublereal *x, integer *ldx, doublereal *rcond, doublereal *rpvgrw, 
+			      doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, 
+			      doublereal *err_bnds_comp__, integer *nparams, doublereal *params, 
+			      doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dgbtf2_(integer *m, integer *n, integer *kl, integer *ku, 
+			     doublereal *ab, integer *ldab, integer *ipiv, integer *info);
+
+/* Subroutine */ int dgbtrf_(integer *m, integer *n, integer *kl, integer *ku, 
+			     doublereal *ab, integer *ldab, integer *ipiv, integer *info);
+
+/* Subroutine */ int dgbtrs_(char *trans, integer *n, integer *kl, integer *
+			     ku, integer *nrhs, doublereal *ab, integer *ldab, integer *ipiv, 
+			     doublereal *b, integer *ldb, integer *info);
+
+/* Subroutine */ int dgebak_(char *job, char *side, integer *n, integer *ilo, 
+			     integer *ihi, doublereal *scale, integer *m, doublereal *v, integer *
+			     ldv, integer *info);
+
+/* Subroutine */ int dgebal_(char *job, integer *n, doublereal *a, integer *
+			     lda, integer *ilo, integer *ihi, doublereal *scale, integer *info);
+
+/* Subroutine */ int dgebd2_(integer *m, integer *n, doublereal *a, integer *
+			     lda, doublereal *d__, doublereal *e, doublereal *tauq, doublereal *
+			     taup, doublereal *work, integer *info);
+
+/* Subroutine */ int dgebrd_(integer *m, integer *n, doublereal *a, integer *
+			     lda, doublereal *d__, doublereal *e, doublereal *tauq, doublereal *
+			     taup, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dgecon_(char *norm, integer *n, doublereal *a, integer *
+			     lda, doublereal *anorm, doublereal *rcond, doublereal *work, integer *
+			     iwork, integer *info);
+
+/* Subroutine */ int dgeequ_(integer *m, integer *n, doublereal *a, integer *
+			     lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal 
+			     *colcnd, doublereal *amax, integer *info);
+
+/* Subroutine */ int dgeequb_(integer *m, integer *n, doublereal *a, integer *
+			      lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal 
+			      *colcnd, doublereal *amax, integer *info);
+
+/* Subroutine */ int dgees_(char *jobvs, char *sort, L_fp select, integer *n, 
+			    doublereal *a, integer *lda, integer *sdim, doublereal *wr, 
+			    doublereal *wi, doublereal *vs, integer *ldvs, doublereal *work, 
+			    integer *lwork, logical *bwork, integer *info);
+
+/* Subroutine */ int dgeesx_(char *jobvs, char *sort, L_fp select, char *
+			     sense, integer *n, doublereal *a, integer *lda, integer *sdim, 
+			     doublereal *wr, doublereal *wi, doublereal *vs, integer *ldvs, 
+			     doublereal *rconde, doublereal *rcondv, doublereal *work, integer *
+			     lwork, integer *iwork, integer *liwork, logical *bwork, integer *info);
+
+/* Subroutine */ int dgeev_(char *jobvl, char *jobvr, integer *n, doublereal *
+			    a, integer *lda, doublereal *wr, doublereal *wi, doublereal *vl, 
+			    integer *ldvl, doublereal *vr, integer *ldvr, doublereal *work, 
+			    integer *lwork, integer *info);
+
+/* Subroutine */ int dgeevx_(char *balanc, char *jobvl, char *jobvr, char *
+			     sense, integer *n, doublereal *a, integer *lda, doublereal *wr, 
+			     doublereal *wi, doublereal *vl, integer *ldvl, doublereal *vr, 
+			     integer *ldvr, integer *ilo, integer *ihi, doublereal *scale, 
+			     doublereal *abnrm, doublereal *rconde, doublereal *rcondv, doublereal 
+			     *work, integer *lwork, integer *iwork, integer *info);
+
+/* Subroutine */ int dgegs_(char *jobvsl, char *jobvsr, integer *n, 
+			    doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *
+			    alphar, doublereal *alphai, doublereal *beta, doublereal *vsl, 
+			    integer *ldvsl, doublereal *vsr, integer *ldvsr, doublereal *work, 
+			    integer *lwork, integer *info);
+
+/* Subroutine */ int dgegv_(char *jobvl, char *jobvr, integer *n, doublereal *
+			    a, integer *lda, doublereal *b, integer *ldb, doublereal *alphar, 
+			    doublereal *alphai, doublereal *beta, doublereal *vl, integer *ldvl, 
+			    doublereal *vr, integer *ldvr, doublereal *work, integer *lwork, 
+			    integer *info);
+
+/* Subroutine */ int dgehd2_(integer *n, integer *ilo, integer *ihi, 
+			     doublereal *a, integer *lda, doublereal *tau, doublereal *work, 
+			     integer *info);
+
+/* Subroutine */ int dgehrd_(integer *n, integer *ilo, integer *ihi, 
+			     doublereal *a, integer *lda, doublereal *tau, doublereal *work, 
+			     integer *lwork, integer *info);
+
+/* Subroutine */ int dgejsv_(char *joba, char *jobu, char *jobv, char *jobr, 
+			     char *jobt, char *jobp, integer *m, integer *n, doublereal *a, 
+			     integer *lda, doublereal *sva, doublereal *u, integer *ldu, 
+			     doublereal *v, integer *ldv, doublereal *work, integer *lwork, 
+			     integer *iwork, integer *info);
+
+/* Subroutine */ int dgelq2_(integer *m, integer *n, doublereal *a, integer *
+			     lda, doublereal *tau, doublereal *work, integer *info);
+
+/* Subroutine */ int dgelqf_(integer *m, integer *n, doublereal *a, integer *
+			     lda, doublereal *tau, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dgels_(char *trans, integer *m, integer *n, integer *
+			    nrhs, doublereal *a, integer *lda, doublereal *b, integer *ldb, 
+			    doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dgelsd_(integer *m, integer *n, integer *nrhs, 
+			     doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *
+			     s, doublereal *rcond, integer *rank, doublereal *work, integer *lwork, 
+			     integer *iwork, integer *info);
+
+/* Subroutine */ int dgelss_(integer *m, integer *n, integer *nrhs, 
+			     doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *
+			     s, doublereal *rcond, integer *rank, doublereal *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int dgelsx_(integer *m, integer *n, integer *nrhs, 
+			     doublereal *a, integer *lda, doublereal *b, integer *ldb, integer *
+			     jpvt, doublereal *rcond, integer *rank, doublereal *work, integer *
+			     info);
+
+/* Subroutine */ int dgelsy_(integer *m, integer *n, integer *nrhs, 
+			     doublereal *a, integer *lda, doublereal *b, integer *ldb, integer *
+			     jpvt, doublereal *rcond, integer *rank, doublereal *work, integer *
+			     lwork, integer *info);
+
+/* Subroutine */ int dgeql2_(integer *m, integer *n, doublereal *a, integer *
+			     lda, doublereal *tau, doublereal *work, integer *info);
+
+/* Subroutine */ int dgeqlf_(integer *m, integer *n, doublereal *a, integer *
+			     lda, doublereal *tau, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dgeqp3_(integer *m, integer *n, doublereal *a, integer *
+			     lda, integer *jpvt, doublereal *tau, doublereal *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int dgeqpf_(integer *m, integer *n, doublereal *a, integer *
+			     lda, integer *jpvt, doublereal *tau, doublereal *work, integer *info);
+
+/* Subroutine */ int dgeqr2_(integer *m, integer *n, doublereal *a, integer *
+			     lda, doublereal *tau, doublereal *work, integer *info);
+
+/* Subroutine */ int dgeqrf_(integer *m, integer *n, doublereal *a, integer *
+			     lda, doublereal *tau, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dgerfs_(char *trans, integer *n, integer *nrhs, 
+			     doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer *
+			     ipiv, doublereal *b, integer *ldb, doublereal *x, integer *ldx, 
+			     doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int dgerfsx_(char *trans, char *equed, integer *n, integer *
+			      nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, 
+			      integer *ipiv, doublereal *r__, doublereal *c__, doublereal *b, 
+			      integer *ldb, doublereal *x, integer *ldx, doublereal *rcond, 
+			      doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, 
+			      doublereal *err_bnds_comp__, integer *nparams, doublereal *params, 
+			      doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dgerq2_(integer *m, integer *n, doublereal *a, integer *
+			     lda, doublereal *tau, doublereal *work, integer *info);
+
+/* Subroutine */ int dgerqf_(integer *m, integer *n, doublereal *a, integer *
+			     lda, doublereal *tau, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dgesc2_(integer *n, doublereal *a, integer *lda, 
+			     doublereal *rhs, integer *ipiv, integer *jpiv, doublereal *scale);
+
+/* Subroutine */ int dgesdd_(char *jobz, integer *m, integer *n, doublereal *
+			     a, integer *lda, doublereal *s, doublereal *u, integer *ldu, 
+			     doublereal *vt, integer *ldvt, doublereal *work, integer *lwork, 
+			     integer *iwork, integer *info);
+
+/* Subroutine */ int dgesv_(integer *n, integer *nrhs, doublereal *a, integer 
+			    *lda, integer *ipiv, doublereal *b, integer *ldb, integer *info);
+
+/* Subroutine */ int dgesvd_(char *jobu, char *jobvt, integer *m, integer *n, 
+			     doublereal *a, integer *lda, doublereal *s, doublereal *u, integer *
+			     ldu, doublereal *vt, integer *ldvt, doublereal *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int dgesvj_(char *joba, char *jobu, char *jobv, integer *m, 
+			     integer *n, doublereal *a, integer *lda, doublereal *sva, integer *mv, 
+			     doublereal *v, integer *ldv, doublereal *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int dgesvx_(char *fact, char *trans, integer *n, integer *
+			     nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, 
+			     integer *ipiv, char *equed, doublereal *r__, doublereal *c__, 
+			     doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *
+			     rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer *
+			     iwork, integer *info);
+
+/* Subroutine */ int dgesvxx_(char *fact, char *trans, integer *n, integer *
+			      nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, 
+			      integer *ipiv, char *equed, doublereal *r__, doublereal *c__, 
+			      doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *
+			      rcond, doublereal *rpvgrw, doublereal *berr, integer *n_err_bnds__, 
+			      doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer *
+			      nparams, doublereal *params, doublereal *work, integer *iwork, 
+			      integer *info);
+
+/* Subroutine */ int dgetc2_(integer *n, doublereal *a, integer *lda, integer 
+			     *ipiv, integer *jpiv, integer *info);
+
+/* Subroutine */ int dgetf2_(integer *m, integer *n, doublereal *a, integer *
+			     lda, integer *ipiv, integer *info);
+
+/* Subroutine */ int dgetrf_(integer *m, integer *n, doublereal *a, integer *
+			     lda, integer *ipiv, integer *info);
+
+/* Subroutine */ int dgetri_(integer *n, doublereal *a, integer *lda, integer 
+			     *ipiv, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dgetrs_(char *trans, integer *n, integer *nrhs, 
+			     doublereal *a, integer *lda, integer *ipiv, doublereal *b, integer *
+			     ldb, integer *info);
+
+/* Subroutine */ int dggbak_(char *job, char *side, integer *n, integer *ilo, 
+			     integer *ihi, doublereal *lscale, doublereal *rscale, integer *m, 
+			     doublereal *v, integer *ldv, integer *info);
+
+/* Subroutine */ int dggbal_(char *job, integer *n, doublereal *a, integer *
+			     lda, doublereal *b, integer *ldb, integer *ilo, integer *ihi, 
+			     doublereal *lscale, doublereal *rscale, doublereal *work, integer *
+			     info);
+
+/* Subroutine */ int dgges_(char *jobvsl, char *jobvsr, char *sort, L_fp 
+			    selctg, integer *n, doublereal *a, integer *lda, doublereal *b, 
+			    integer *ldb, integer *sdim, doublereal *alphar, doublereal *alphai, 
+			    doublereal *beta, doublereal *vsl, integer *ldvsl, doublereal *vsr, 
+			    integer *ldvsr, doublereal *work, integer *lwork, logical *bwork, 
+			    integer *info);
+
+/* Subroutine */ int dggesx_(char *jobvsl, char *jobvsr, char *sort, L_fp 
+			     selctg, char *sense, integer *n, doublereal *a, integer *lda, 
+			     doublereal *b, integer *ldb, integer *sdim, doublereal *alphar, 
+			     doublereal *alphai, doublereal *beta, doublereal *vsl, integer *ldvsl, 
+			     doublereal *vsr, integer *ldvsr, doublereal *rconde, doublereal *
+			     rcondv, doublereal *work, integer *lwork, integer *iwork, integer *
+			     liwork, logical *bwork, integer *info);
+
+/* Subroutine */ int dggev_(char *jobvl, char *jobvr, integer *n, doublereal *
+			    a, integer *lda, doublereal *b, integer *ldb, doublereal *alphar, 
+			    doublereal *alphai, doublereal *beta, doublereal *vl, integer *ldvl, 
+			    doublereal *vr, integer *ldvr, doublereal *work, integer *lwork, 
+			    integer *info);
+
+/* Subroutine */ int dggevx_(char *balanc, char *jobvl, char *jobvr, char *
+			     sense, integer *n, doublereal *a, integer *lda, doublereal *b, 
+			     integer *ldb, doublereal *alphar, doublereal *alphai, doublereal *
+			     beta, doublereal *vl, integer *ldvl, doublereal *vr, integer *ldvr, 
+			     integer *ilo, integer *ihi, doublereal *lscale, doublereal *rscale, 
+			     doublereal *abnrm, doublereal *bbnrm, doublereal *rconde, doublereal *
+			     rcondv, doublereal *work, integer *lwork, integer *iwork, logical *
+			     bwork, integer *info);
+
+/* Subroutine */ int dggglm_(integer *n, integer *m, integer *p, doublereal *
+			     a, integer *lda, doublereal *b, integer *ldb, doublereal *d__, 
+			     doublereal *x, doublereal *y, doublereal *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int dgghrd_(char *compq, char *compz, integer *n, integer *
+			     ilo, integer *ihi, doublereal *a, integer *lda, doublereal *b, 
+			     integer *ldb, doublereal *q, integer *ldq, doublereal *z__, integer *
+			     ldz, integer *info);
+
+/* Subroutine */ int dgglse_(integer *m, integer *n, integer *p, doublereal *
+			     a, integer *lda, doublereal *b, integer *ldb, doublereal *c__, 
+			     doublereal *d__, doublereal *x, doublereal *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int dggqrf_(integer *n, integer *m, integer *p, doublereal *
+			     a, integer *lda, doublereal *taua, doublereal *b, integer *ldb, 
+			     doublereal *taub, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dggrqf_(integer *m, integer *p, integer *n, doublereal *
+			     a, integer *lda, doublereal *taua, doublereal *b, integer *ldb, 
+			     doublereal *taub, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dggsvd_(char *jobu, char *jobv, char *jobq, integer *m, 
+			     integer *n, integer *p, integer *k, integer *l, doublereal *a, 
+			     integer *lda, doublereal *b, integer *ldb, doublereal *alpha, 
+			     doublereal *beta, doublereal *u, integer *ldu, doublereal *v, integer 
+			     *ldv, doublereal *q, integer *ldq, doublereal *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int dggsvp_(char *jobu, char *jobv, char *jobq, integer *m, 
+			     integer *p, integer *n, doublereal *a, integer *lda, doublereal *b, 
+			     integer *ldb, doublereal *tola, doublereal *tolb, integer *k, integer 
+			     *l, doublereal *u, integer *ldu, doublereal *v, integer *ldv, 
+			     doublereal *q, integer *ldq, integer *iwork, doublereal *tau, 
+			     doublereal *work, integer *info);
+
+/* Subroutine */ int dgsvj0_(char *jobv, integer *m, integer *n, doublereal *
+			     a, integer *lda, doublereal *d__, doublereal *sva, integer *mv, 
+			     doublereal *v, integer *ldv, doublereal *eps, doublereal *sfmin, 
+			     doublereal *tol, integer *nsweep, doublereal *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int dgsvj1_(char *jobv, integer *m, integer *n, integer *n1, 
+			     doublereal *a, integer *lda, doublereal *d__, doublereal *sva, 
+			     integer *mv, doublereal *v, integer *ldv, doublereal *eps, doublereal 
+			     *sfmin, doublereal *tol, integer *nsweep, doublereal *work, integer *
+			     lwork, integer *info);
+
+/* Subroutine */ int dgtcon_(char *norm, integer *n, doublereal *dl, 
+			     doublereal *d__, doublereal *du, doublereal *du2, integer *ipiv, 
+			     doublereal *anorm, doublereal *rcond, doublereal *work, integer *
+			     iwork, integer *info);
+
+/* Subroutine */ int dgtrfs_(char *trans, integer *n, integer *nrhs, 
+			     doublereal *dl, doublereal *d__, doublereal *du, doublereal *dlf, 
+			     doublereal *df, doublereal *duf, doublereal *du2, integer *ipiv, 
+			     doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *
+			     ferr, doublereal *berr, doublereal *work, integer *iwork, integer *
+			     info);
+
+/* Subroutine */ int dgtsv_(integer *n, integer *nrhs, doublereal *dl, 
+			    doublereal *d__, doublereal *du, doublereal *b, integer *ldb, integer 
+			    *info);
+
+/* Subroutine */ int dgtsvx_(char *fact, char *trans, integer *n, integer *
+			     nrhs, doublereal *dl, doublereal *d__, doublereal *du, doublereal *
+			     dlf, doublereal *df, doublereal *duf, doublereal *du2, integer *ipiv, 
+			     doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *
+			     rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer *
+			     iwork, integer *info);
+
+/* Subroutine */ int dgttrf_(integer *n, doublereal *dl, doublereal *d__, 
+			     doublereal *du, doublereal *du2, integer *ipiv, integer *info);
+
+/* Subroutine */ int dgttrs_(char *trans, integer *n, integer *nrhs, 
+			     doublereal *dl, doublereal *d__, doublereal *du, doublereal *du2, 
+			     integer *ipiv, doublereal *b, integer *ldb, integer *info);
+
+/* Subroutine */ int dgtts2_(integer *itrans, integer *n, integer *nrhs, 
+			     doublereal *dl, doublereal *d__, doublereal *du, doublereal *du2, 
+			     integer *ipiv, doublereal *b, integer *ldb);
+
+/* Subroutine */ int dhgeqz_(char *job, char *compq, char *compz, integer *n, 
+			     integer *ilo, integer *ihi, doublereal *h__, integer *ldh, doublereal 
+			     *t, integer *ldt, doublereal *alphar, doublereal *alphai, doublereal *
+			     beta, doublereal *q, integer *ldq, doublereal *z__, integer *ldz, 
+			     doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dhsein_(char *side, char *eigsrc, char *initv, logical *
+			     select, integer *n, doublereal *h__, integer *ldh, doublereal *wr, 
+			     doublereal *wi, doublereal *vl, integer *ldvl, doublereal *vr, 
+			     integer *ldvr, integer *mm, integer *m, doublereal *work, integer *
+			     ifaill, integer *ifailr, integer *info);
+
+/* Subroutine */ int dhseqr_(char *job, char *compz, integer *n, integer *ilo, 
+			     integer *ihi, doublereal *h__, integer *ldh, doublereal *wr, 
+			     doublereal *wi, doublereal *z__, integer *ldz, doublereal *work, 
+			     integer *lwork, integer *info);
+
+logical disnan_(doublereal *din);
+
+/* Subroutine */ int dla_gbamv__(integer *trans, integer *m, integer *n, 
+				 integer *kl, integer *ku, doublereal *alpha, doublereal *ab, integer *
+				 ldab, doublereal *x, integer *incx, doublereal *beta, doublereal *y, 
+				 integer *incy);
+
+doublereal dla_gbrcond__(char *trans, integer *n, integer *kl, integer *ku, 
+			 doublereal *ab, integer *ldab, doublereal *afb, integer *ldafb, 
+			 integer *ipiv, integer *cmode, doublereal *c__, integer *info, 
+			 doublereal *work, integer *iwork, ftnlen trans_len);
+
+/* Subroutine */ int dla_gbrfsx_extended__(integer *prec_type__, integer *
+					   trans_type__, integer *n, integer *kl, integer *ku, integer *nrhs, 
+					   doublereal *ab, integer *ldab, doublereal *afb, integer *ldafb, 
+					   integer *ipiv, logical *colequ, doublereal *c__, doublereal *b, 
+					   integer *ldb, doublereal *y, integer *ldy, doublereal *berr_out__, 
+					   integer *n_norms__, doublereal *errs_n__, doublereal *errs_c__, 
+					   doublereal *res, doublereal *ayb, doublereal *dy, doublereal *
+					   y_tail__, doublereal *rcond, integer *ithresh, doublereal *rthresh, 
+					   doublereal *dz_ub__, logical *ignore_cwise__, integer *info);
+
+doublereal dla_gbrpvgrw__(integer *n, integer *kl, integer *ku, integer *
+			  ncols, doublereal *ab, integer *ldab, doublereal *afb, integer *ldafb);
+
+/* Subroutine */ int dla_geamv__(integer *trans, integer *m, integer *n, 
+				 doublereal *alpha, doublereal *a, integer *lda, doublereal *x, 
+				 integer *incx, doublereal *beta, doublereal *y, integer *incy);
+
+doublereal dla_gercond__(char *trans, integer *n, doublereal *a, integer *lda,
+			 doublereal *af, integer *ldaf, integer *ipiv, integer *cmode, 
+			 doublereal *c__, integer *info, doublereal *work, integer *iwork, 
+			 ftnlen trans_len);
+
+/* Subroutine */ int dla_gerfsx_extended__(integer *prec_type__, integer *
+					   trans_type__, integer *n, integer *nrhs, doublereal *a, integer *lda, 
+					   doublereal *af, integer *ldaf, integer *ipiv, logical *colequ, 
+					   doublereal *c__, doublereal *b, integer *ldb, doublereal *y, integer *
+					   ldy, doublereal *berr_out__, integer *n_norms__, doublereal *errs_n__,
+					   doublereal *errs_c__, doublereal *res, doublereal *ayb, doublereal *
+					   dy, doublereal *y_tail__, doublereal *rcond, integer *ithresh, 
+					   doublereal *rthresh, doublereal *dz_ub__, logical *ignore_cwise__, 
+					   integer *info);
+
+/* Subroutine */ int dla_lin_berr__(integer *n, integer *nz, integer *nrhs, 
+				    doublereal *res, doublereal *ayb, doublereal *berr);
+
+doublereal dla_porcond__(char *uplo, integer *n, doublereal *a, integer *lda, 
+			 doublereal *af, integer *ldaf, integer *cmode, doublereal *c__, 
+			 integer *info, doublereal *work, integer *iwork, ftnlen uplo_len);
+
+/* Subroutine */ int dla_porfsx_extended__(integer *prec_type__, char *uplo, 
+					   integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal *
+					   af, integer *ldaf, logical *colequ, doublereal *c__, doublereal *b, 
+					   integer *ldb, doublereal *y, integer *ldy, doublereal *berr_out__, 
+					   integer *n_norms__, doublereal *errs_n__, doublereal *errs_c__, 
+					   doublereal *res, doublereal *ayb, doublereal *dy, doublereal *
+					   y_tail__, doublereal *rcond, integer *ithresh, doublereal *rthresh, 
+					   doublereal *dz_ub__, logical *ignore_cwise__, integer *info, ftnlen 
+					   uplo_len);
+
+doublereal dla_porpvgrw__(char *uplo, integer *ncols, doublereal *a, integer *
+			  lda, doublereal *af, integer *ldaf, doublereal *work, ftnlen uplo_len);
+
+doublereal dla_rpvgrw__(integer *n, integer *ncols, doublereal *a, integer *
+			lda, doublereal *af, integer *ldaf);
+
+/* Subroutine */ int dla_syamv__(integer *uplo, integer *n, doublereal *alpha,
+				 doublereal *a, integer *lda, doublereal *x, integer *incx, 
+				 doublereal *beta, doublereal *y, integer *incy);
+
+doublereal dla_syrcond__(char *uplo, integer *n, doublereal *a, integer *lda, 
+			 doublereal *af, integer *ldaf, integer *ipiv, integer *cmode, 
+			 doublereal *c__, integer *info, doublereal *work, integer *iwork, 
+			 ftnlen uplo_len);
+
+/* Subroutine */ int dla_syrfsx_extended__(integer *prec_type__, char *uplo, 
+					   integer *n, integer *nrhs, doublereal *a, integer *lda, doublereal *
+					   af, integer *ldaf, integer *ipiv, logical *colequ, doublereal *c__, 
+					   doublereal *b, integer *ldb, doublereal *y, integer *ldy, doublereal *
+					   berr_out__, integer *n_norms__, doublereal *errs_n__, doublereal *
+					   errs_c__, doublereal *res, doublereal *ayb, doublereal *dy, 
+					   doublereal *y_tail__, doublereal *rcond, integer *ithresh, doublereal 
+					   *rthresh, doublereal *dz_ub__, logical *ignore_cwise__, integer *info,
+					   ftnlen uplo_len);
+
+doublereal dla_syrpvgrw__(char *uplo, integer *n, integer *info, doublereal *
+			  a, integer *lda, doublereal *af, integer *ldaf, integer *ipiv, 
+			  doublereal *work, ftnlen uplo_len);
+
+/* Subroutine */ int dla_wwaddw__(integer *n, doublereal *x, doublereal *y, 
+				  doublereal *w);
+
+/* Subroutine */ int dlabad_(doublereal *smallxx, doublereal *large);
+
+/* Subroutine */ int dlabrd_(integer *m, integer *n, integer *nb, doublereal *
+			     a, integer *lda, doublereal *d__, doublereal *e, doublereal *tauq, 
+			     doublereal *taup, doublereal *x, integer *ldx, doublereal *y, integer 
+			     *ldy);
+
+/* Subroutine */ int dlacn2_(integer *n, doublereal *v, doublereal *x, 
+			     integer *isgn, doublereal *est, integer *kase, integer *isave);
+
+/* Subroutine */ int dlacon_(integer *n, doublereal *v, doublereal *x, 
+			     integer *isgn, doublereal *est, integer *kase);
+
+/* Subroutine */ int dlacpy_(char *uplo, integer *m, integer *n, doublereal *
+			     a, integer *lda, doublereal *b, integer *ldb);
+
+/* Subroutine */ int dladiv_(doublereal *a, doublereal *b, doublereal *c__, 
+			     doublereal *d__, doublereal *p, doublereal *q);
+
+/* Subroutine */ int dlae2_(doublereal *a, doublereal *b, doublereal *c__, 
+			    doublereal *rt1, doublereal *rt2);
+
+/* Subroutine */ int dlaebz_(integer *ijob, integer *nitmax, integer *n, 
+			     integer *mmax, integer *minp, integer *nbmin, doublereal *abstol, 
+			     doublereal *reltol, doublereal *pivmin, doublereal *d__, doublereal *
+			     e, doublereal *e2, integer *nval, doublereal *ab, doublereal *c__, 
+			     integer *mout, integer *nab, doublereal *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int dlaed0_(integer *icompq, integer *qsiz, integer *n, 
+			     doublereal *d__, doublereal *e, doublereal *q, integer *ldq, 
+			     doublereal *qstore, integer *ldqs, doublereal *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int dlaed1_(integer *n, doublereal *d__, doublereal *q, 
+			     integer *ldq, integer *indxq, doublereal *rho, integer *cutpnt, 
+			     doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dlaed2_(integer *k, integer *n, integer *n1, doublereal *
+			     d__, doublereal *q, integer *ldq, integer *indxq, doublereal *rho, 
+			     doublereal *z__, doublereal *dlamda, doublereal *w, doublereal *q2, 
+			     integer *indx, integer *indxc, integer *indxp, integer *coltyp, 
+			     integer *info);
+
+/* Subroutine */ int dlaed3_(integer *k, integer *n, integer *n1, doublereal *
+			     d__, doublereal *q, integer *ldq, doublereal *rho, doublereal *dlamda, 
+			     doublereal *q2, integer *indx, integer *ctot, doublereal *w, 
+			     doublereal *s, integer *info);
+
+/* Subroutine */ int dlaed4_(integer *n, integer *i__, doublereal *d__, 
+			     doublereal *z__, doublereal *delta, doublereal *rho, doublereal *dlam, 
+			     integer *info);
+
+/* Subroutine */ int dlaed5_(integer *i__, doublereal *d__, doublereal *z__, 
+			     doublereal *delta, doublereal *rho, doublereal *dlam);
+
+/* Subroutine */ int dlaed6_(integer *kniter, logical *orgati, doublereal *
+			     rho, doublereal *d__, doublereal *z__, doublereal *finit, doublereal *
+			     tau, integer *info);
+
+/* Subroutine */ int dlaed7_(integer *icompq, integer *n, integer *qsiz, 
+			     integer *tlvls, integer *curlvl, integer *curpbm, doublereal *d__, 
+			     doublereal *q, integer *ldq, integer *indxq, doublereal *rho, integer 
+			     *cutpnt, doublereal *qstore, integer *qptr, integer *prmptr, integer *
+			     perm, integer *givptr, integer *givcol, doublereal *givnum, 
+			     doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dlaed8_(integer *icompq, integer *k, integer *n, integer 
+			     *qsiz, doublereal *d__, doublereal *q, integer *ldq, integer *indxq, 
+			     doublereal *rho, integer *cutpnt, doublereal *z__, doublereal *dlamda, 
+			     doublereal *q2, integer *ldq2, doublereal *w, integer *perm, integer 
+			     *givptr, integer *givcol, doublereal *givnum, integer *indxp, integer 
+			     *indx, integer *info);
+
+/* Subroutine */ int dlaed9_(integer *k, integer *kstart, integer *kstop, 
+			     integer *n, doublereal *d__, doublereal *q, integer *ldq, doublereal *
+			     rho, doublereal *dlamda, doublereal *w, doublereal *s, integer *lds, 
+			     integer *info);
+
+/* Subroutine */ int dlaeda_(integer *n, integer *tlvls, integer *curlvl, 
+			     integer *curpbm, integer *prmptr, integer *perm, integer *givptr, 
+			     integer *givcol, doublereal *givnum, doublereal *q, integer *qptr, 
+			     doublereal *z__, doublereal *ztemp, integer *info);
+
+/* Subroutine */ int dlaein_(logical *rightv, logical *noinit, integer *n, 
+			     doublereal *h__, integer *ldh, doublereal *wr, doublereal *wi, 
+			     doublereal *vr, doublereal *vi, doublereal *b, integer *ldb, 
+			     doublereal *work, doublereal *eps3, doublereal *smlnum, doublereal *
+			     bignum, integer *info);
+
+/* Subroutine */ int dlaev2_(doublereal *a, doublereal *b, doublereal *c__, 
+			     doublereal *rt1, doublereal *rt2, doublereal *cs1, doublereal *sn1);
+
+/* Subroutine */ int dlaexc_(logical *wantq, integer *n, doublereal *t, 
+			     integer *ldt, doublereal *q, integer *ldq, integer *j1, integer *n1, 
+			     integer *n2, doublereal *work, integer *info);
+
+/* Subroutine */ int dlag2_(doublereal *a, integer *lda, doublereal *b, 
+			    integer *ldb, doublereal *safmin, doublereal *scale1, doublereal *
+			    scale2, doublereal *wr1, doublereal *wr2, doublereal *wi);
+
+/* Subroutine */ int dlag2s_(integer *m, integer *n, doublereal *a, integer *
+			     lda, real *sa, integer *ldsa, integer *info);
+
+/* Subroutine */ int dlags2_(logical *upper, doublereal *a1, doublereal *a2, 
+			     doublereal *a3, doublereal *b1, doublereal *b2, doublereal *b3, 
+			     doublereal *csu, doublereal *snu, doublereal *csv, doublereal *snv, 
+			     doublereal *csq, doublereal *snq);
+
+/* Subroutine */ int dlagtf_(integer *n, doublereal *a, doublereal *lambda, 
+			     doublereal *b, doublereal *c__, doublereal *tol, doublereal *d__, 
+			     integer *in, integer *info);
+
+/* Subroutine */ int dlagtm_(char *trans, integer *n, integer *nrhs, 
+			     doublereal *alpha, doublereal *dl, doublereal *d__, doublereal *du, 
+			     doublereal *x, integer *ldx, doublereal *beta, doublereal *b, integer 
+			     *ldb);
+
+/* Subroutine */ int dlagts_(integer *job, integer *n, doublereal *a, 
+			     doublereal *b, doublereal *c__, doublereal *d__, integer *in, 
+			     doublereal *y, doublereal *tol, integer *info);
+
+/* Subroutine */ int dlagv2_(doublereal *a, integer *lda, doublereal *b, 
+			     integer *ldb, doublereal *alphar, doublereal *alphai, doublereal *
+			     beta, doublereal *csl, doublereal *snl, doublereal *csr, doublereal *
+			     snr);
+
+/* Subroutine */ int dlahqr_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ilo, integer *ihi, doublereal *h__, integer *ldh, doublereal 
+			     *wr, doublereal *wi, integer *iloz, integer *ihiz, doublereal *z__, 
+			     integer *ldz, integer *info);
+
+/* Subroutine */ int dlahr2_(integer *n, integer *k, integer *nb, doublereal *
+			     a, integer *lda, doublereal *tau, doublereal *t, integer *ldt, 
+			     doublereal *y, integer *ldy);
+
+/* Subroutine */ int dlahrd_(integer *n, integer *k, integer *nb, doublereal *
+			     a, integer *lda, doublereal *tau, doublereal *t, integer *ldt, 
+			     doublereal *y, integer *ldy);
+
+/* Subroutine */ int dlaic1_(integer *job, integer *j, doublereal *x, 
+			     doublereal *sest, doublereal *w, doublereal *gamma, doublereal *
+			     sestpr, doublereal *s, doublereal *c__);
+
+logical dlaisnan_(doublereal *din1, doublereal *din2);
+
+/* Subroutine */ int dlaln2_(logical *ltrans, integer *na, integer *nw, 
+			     doublereal *smin, doublereal *ca, doublereal *a, integer *lda, 
+			     doublereal *d1, doublereal *d2, doublereal *b, integer *ldb, 
+			     doublereal *wr, doublereal *wi, doublereal *x, integer *ldx, 
+			     doublereal *scale, doublereal *xnorm, integer *info);
+
+/* Subroutine */ int dlals0_(integer *icompq, integer *nl, integer *nr, 
+			     integer *sqre, integer *nrhs, doublereal *b, integer *ldb, doublereal 
+			     *bx, integer *ldbx, integer *perm, integer *givptr, integer *givcol, 
+			     integer *ldgcol, doublereal *givnum, integer *ldgnum, doublereal *
+			     poles, doublereal *difl, doublereal *difr, doublereal *z__, integer *
+			     k, doublereal *c__, doublereal *s, doublereal *work, integer *info);
+
+/* Subroutine */ int dlalsa_(integer *icompq, integer *smlsiz, integer *n, 
+			     integer *nrhs, doublereal *b, integer *ldb, doublereal *bx, integer *
+			     ldbx, doublereal *u, integer *ldu, doublereal *vt, integer *k, 
+			     doublereal *difl, doublereal *difr, doublereal *z__, doublereal *
+			     poles, integer *givptr, integer *givcol, integer *ldgcol, integer *
+			     perm, doublereal *givnum, doublereal *c__, doublereal *s, doublereal *
+			     work, integer *iwork, integer *info);
+
+/* Subroutine */ int dlalsd_(char *uplo, integer *smlsiz, integer *n, integer 
+			     *nrhs, doublereal *d__, doublereal *e, doublereal *b, integer *ldb, 
+			     doublereal *rcond, integer *rank, doublereal *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int dlamrg_(integer *n1, integer *n2, doublereal *a, integer 
+			     *dtrd1, integer *dtrd2, integer *index);
+
+integer dlaneg_(integer *n, doublereal *d__, doublereal *lld, doublereal *
+		sigma, doublereal *pivmin, integer *r__);
+
+doublereal dlangb_(char *norm, integer *n, integer *kl, integer *ku, 
+		   doublereal *ab, integer *ldab, doublereal *work);
+
+doublereal dlange_(char *norm, integer *m, integer *n, doublereal *a, integer 
+		   *lda, doublereal *work);
+
+doublereal dlangt_(char *norm, integer *n, doublereal *dl, doublereal *d__, 
+		   doublereal *du);
+
+doublereal dlanhs_(char *norm, integer *n, doublereal *a, integer *lda, 
+		   doublereal *work);
+
+doublereal dlansb_(char *norm, char *uplo, integer *n, integer *k, doublereal 
+		   *ab, integer *ldab, doublereal *work);
+
+doublereal dlansf_(char *norm, char *transr, char *uplo, integer *n, 
+		   doublereal *a, doublereal *work);
+
+doublereal dlansp_(char *norm, char *uplo, integer *n, doublereal *ap, 
+		   doublereal *work);
+
+doublereal dlanst_(char *norm, integer *n, doublereal *d__, doublereal *e);
+
+doublereal dlansy_(char *norm, char *uplo, integer *n, doublereal *a, integer 
+		   *lda, doublereal *work);
+
+doublereal dlantb_(char *norm, char *uplo, char *diag, integer *n, integer *k, 
+		   doublereal *ab, integer *ldab, doublereal *work);
+
+doublereal dlantp_(char *norm, char *uplo, char *diag, integer *n, doublereal 
+		   *ap, doublereal *work);
+
+doublereal dlantr_(char *norm, char *uplo, char *diag, integer *m, integer *n, 
+		   doublereal *a, integer *lda, doublereal *work);
+
+/* Subroutine */ int dlanv2_(doublereal *a, doublereal *b, doublereal *c__, 
+			     doublereal *d__, doublereal *rt1r, doublereal *rt1i, doublereal *rt2r, 
+			     doublereal *rt2i, doublereal *cs, doublereal *sn);
+
+/* Subroutine */ int dlapll_(integer *n, doublereal *x, integer *incx, 
+			     doublereal *y, integer *incy, doublereal *ssmin);
+
+/* Subroutine */ int dlapmt_(logical *forwrd, integer *m, integer *n, 
+			     doublereal *x, integer *ldx, integer *k);
+
+doublereal dlapy2_(doublereal *x, doublereal *y);
+
+doublereal dlapy3_(doublereal *x, doublereal *y, doublereal *z__);
+
+/* Subroutine */ int dlaqgb_(integer *m, integer *n, integer *kl, integer *ku, 
+			     doublereal *ab, integer *ldab, doublereal *r__, doublereal *c__, 
+			     doublereal *rowcnd, doublereal *colcnd, doublereal *amax, char *equed);
+
+/* Subroutine */ int dlaqge_(integer *m, integer *n, doublereal *a, integer *
+			     lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, doublereal 
+			     *colcnd, doublereal *amax, char *equed);
+
+/* Subroutine */ int dlaqp2_(integer *m, integer *n, integer *offset, 
+			     doublereal *a, integer *lda, integer *jpvt, doublereal *tau, 
+			     doublereal *vn1, doublereal *vn2, doublereal *work);
+
+/* Subroutine */ int dlaqps_(integer *m, integer *n, integer *offset, integer 
+			     *nb, integer *kb, doublereal *a, integer *lda, integer *jpvt, 
+			     doublereal *tau, doublereal *vn1, doublereal *vn2, doublereal *auxv, 
+			     doublereal *f, integer *ldf);
+
+/* Subroutine */ int dlaqr0_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ilo, integer *ihi, doublereal *h__, integer *ldh, doublereal 
+			     *wr, doublereal *wi, integer *iloz, integer *ihiz, doublereal *z__, 
+			     integer *ldz, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dlaqr1_(integer *n, doublereal *h__, integer *ldh, 
+			     doublereal *sr1, doublereal *si1, doublereal *sr2, doublereal *si2, 
+			     doublereal *v);
+
+/* Subroutine */ int dlaqr2_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ktop, integer *kbot, integer *nw, doublereal *h__, integer *
+			     ldh, integer *iloz, integer *ihiz, doublereal *z__, integer *ldz, 
+			     integer *ns, integer *nd, doublereal *sr, doublereal *si, doublereal *
+			     v, integer *ldv, integer *nh, doublereal *t, integer *ldt, integer *
+			     nv, doublereal *wv, integer *ldwv, doublereal *work, integer *lwork);
+
+/* Subroutine */ int dlaqr3_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ktop, integer *kbot, integer *nw, doublereal *h__, integer *
+			     ldh, integer *iloz, integer *ihiz, doublereal *z__, integer *ldz, 
+			     integer *ns, integer *nd, doublereal *sr, doublereal *si, doublereal *
+			     v, integer *ldv, integer *nh, doublereal *t, integer *ldt, integer *
+			     nv, doublereal *wv, integer *ldwv, doublereal *work, integer *lwork);
+
+/* Subroutine */ int dlaqr4_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ilo, integer *ihi, doublereal *h__, integer *ldh, doublereal 
+			     *wr, doublereal *wi, integer *iloz, integer *ihiz, doublereal *z__, 
+			     integer *ldz, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dlaqr5_(logical *wantt, logical *wantz, integer *kacc22, 
+			     integer *n, integer *ktop, integer *kbot, integer *nshfts, doublereal 
+			     *sr, doublereal *si, doublereal *h__, integer *ldh, integer *iloz, 
+			     integer *ihiz, doublereal *z__, integer *ldz, doublereal *v, integer *
+			     ldv, doublereal *u, integer *ldu, integer *nv, doublereal *wv, 
+			     integer *ldwv, integer *nh, doublereal *wh, integer *ldwh);
+
+/* Subroutine */ int dlaqsb_(char *uplo, integer *n, integer *kd, doublereal *
+			     ab, integer *ldab, doublereal *s, doublereal *scond, doublereal *amax, 
+			     char *equed);
+
+/* Subroutine */ int dlaqsp_(char *uplo, integer *n, doublereal *ap, 
+			     doublereal *s, doublereal *scond, doublereal *amax, char *equed);
+
+/* Subroutine */ int dlaqsy_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, doublereal *s, doublereal *scond, doublereal *amax, char *equed);
+
+/* Subroutine */ int dlaqtr_(logical *ltran, logical *lreal, integer *n, 
+			     doublereal *t, integer *ldt, doublereal *b, doublereal *w, doublereal 
+			     *scale, doublereal *x, doublereal *work, integer *info);
+
+/* Subroutine */ int dlar1v_(integer *n, integer *b1, integer *bn, doublereal 
+			     *lambda, doublereal *d__, doublereal *l, doublereal *ld, doublereal *
+			     lld, doublereal *pivmin, doublereal *gaptol, doublereal *z__, logical 
+			     *wantnc, integer *negcnt, doublereal *ztz, doublereal *mingma, 
+			     integer *r__, integer *isuppz, doublereal *nrminv, doublereal *resid, 
+			     doublereal *rqcorr, doublereal *work);
+
+/* Subroutine */ int dlar2v_(integer *n, doublereal *x, doublereal *y, 
+			     doublereal *z__, integer *incx, doublereal *c__, doublereal *s, 
+			     integer *incc);
+
+/* Subroutine */ int dlarf_(char *side, integer *m, integer *n, doublereal *v, 
+			    integer *incv, doublereal *tau, doublereal *c__, integer *ldc, 
+			    doublereal *work);
+
+/* Subroutine */ int dlarfb_(char *side, char *trans, char *direct, char *
+			     storev, integer *m, integer *n, integer *k, doublereal *v, integer *
+			     ldv, doublereal *t, integer *ldt, doublereal *c__, integer *ldc, 
+			     doublereal *work, integer *ldwork);
+
+/* Subroutine */ int dlarfg_(integer *n, doublereal *alpha, doublereal *x, 
+			     integer *incx, doublereal *tau);
+
+/* Subroutine */ int dlarfp_(integer *n, doublereal *alpha, doublereal *x, 
+			     integer *incx, doublereal *tau);
+
+/* Subroutine */ int dlarft_(char *direct, char *storev, integer *n, integer *
+			     k, doublereal *v, integer *ldv, doublereal *tau, doublereal *t, 
+			     integer *ldt);
+
+/* Subroutine */ int dlarfx_(char *side, integer *m, integer *n, doublereal *
+			     v, doublereal *tau, doublereal *c__, integer *ldc, doublereal *work);
+
+/* Subroutine */ int dlargv_(integer *n, doublereal *x, integer *incx, 
+			     doublereal *y, integer *incy, doublereal *c__, integer *incc);
+
+/* Subroutine */ int dlarnv_(integer *idist, integer *iseed, integer *n, 
+			     doublereal *x);
+
+/* Subroutine */ int dlarra_(integer *n, doublereal *d__, doublereal *e, 
+			     doublereal *e2, doublereal *spltol, doublereal *tnrm, integer *nsplit, 
+			     integer *isplit, integer *info);
+
+/* Subroutine */ int dlarrb_(integer *n, doublereal *d__, doublereal *lld, 
+			     integer *ifirst, integer *ilast, doublereal *rtol1, doublereal *rtol2, 
+			     integer *offset, doublereal *w, doublereal *wgap, doublereal *werr, 
+			     doublereal *work, integer *iwork, doublereal *pivmin, doublereal *
+			     spdiam, integer *twist, integer *info);
+
+/* Subroutine */ int dlarrc_(char *jobt, integer *n, doublereal *vl, 
+			     doublereal *vu, doublereal *d__, doublereal *e, doublereal *pivmin, 
+			     integer *eigcnt, integer *lcnt, integer *rcnt, integer *info);
+
+/* Subroutine */ int dlarrd_(char *range, char *order, integer *n, doublereal 
+			     *vl, doublereal *vu, integer *il, integer *iu, doublereal *gers, 
+			     doublereal *reltol, doublereal *d__, doublereal *e, doublereal *e2, 
+			     doublereal *pivmin, integer *nsplit, integer *isplit, integer *m, 
+			     doublereal *w, doublereal *werr, doublereal *wl, doublereal *wu, 
+			     integer *iblock, integer *indexw, doublereal *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int dlarre_(char *range, integer *n, doublereal *vl, 
+			     doublereal *vu, integer *il, integer *iu, doublereal *d__, doublereal 
+			     *e, doublereal *e2, doublereal *rtol1, doublereal *rtol2, doublereal *
+			     spltol, integer *nsplit, integer *isplit, integer *m, doublereal *w, 
+			     doublereal *werr, doublereal *wgap, integer *iblock, integer *indexw, 
+			     doublereal *gers, doublereal *pivmin, doublereal *work, integer *
+			     iwork, integer *info);
+
+/* Subroutine */ int dlarrf_(integer *n, doublereal *d__, doublereal *l, 
+			     doublereal *ld, integer *clstrt, integer *clend, doublereal *w, 
+			     doublereal *wgap, doublereal *werr, doublereal *spdiam, doublereal *
+			     clgapl, doublereal *clgapr, doublereal *pivmin, doublereal *sigma, 
+			     doublereal *dplus, doublereal *lplus, doublereal *work, integer *info);
+
+/* Subroutine */ int dlarrj_(integer *n, doublereal *d__, doublereal *e2, 
+			     integer *ifirst, integer *ilast, doublereal *rtol, integer *offset, 
+			     doublereal *w, doublereal *werr, doublereal *work, integer *iwork, 
+			     doublereal *pivmin, doublereal *spdiam, integer *info);
+
+/* Subroutine */ int dlarrk_(integer *n, integer *iw, doublereal *gl, 
+			     doublereal *gu, doublereal *d__, doublereal *e2, doublereal *pivmin, 
+			     doublereal *reltol, doublereal *w, doublereal *werr, integer *info);
+
+/* Subroutine */ int dlarrr_(integer *n, doublereal *d__, doublereal *e, 
+			     integer *info);
+
+/* Subroutine */ int dlarrv_(integer *n, doublereal *vl, doublereal *vu, 
+			     doublereal *d__, doublereal *l, doublereal *pivmin, integer *isplit, 
+			     integer *m, integer *dol, integer *dou, doublereal *minrgp, 
+			     doublereal *rtol1, doublereal *rtol2, doublereal *w, doublereal *werr, 
+			     doublereal *wgap, integer *iblock, integer *indexw, doublereal *gers, 
+			     doublereal *z__, integer *ldz, integer *isuppz, doublereal *work, 
+			     integer *iwork, integer *info);
+
+/* Subroutine */ int dlarscl2_(integer *m, integer *n, doublereal *d__, 
+			       doublereal *x, integer *ldx);
+
+/* Subroutine */ int dlartg_(doublereal *f, doublereal *g, doublereal *cs, 
+			     doublereal *sn, doublereal *r__);
+
+/* Subroutine */ int dlartv_(integer *n, doublereal *x, integer *incx, 
+			     doublereal *y, integer *incy, doublereal *c__, doublereal *s, integer 
+			     *incc);
+
+/* Subroutine */ int dlaruv_(integer *iseed, integer *n, doublereal *x);
+
+/* Subroutine */ int dlarz_(char *side, integer *m, integer *n, integer *l, 
+			    doublereal *v, integer *incv, doublereal *tau, doublereal *c__, 
+			    integer *ldc, doublereal *work);
+
+/* Subroutine */ int dlarzb_(char *side, char *trans, char *direct, char *
+			     storev, integer *m, integer *n, integer *k, integer *l, doublereal *v, 
+			     integer *ldv, doublereal *t, integer *ldt, doublereal *c__, integer *
+			     ldc, doublereal *work, integer *ldwork);
+
+/* Subroutine */ int dlarzt_(char *direct, char *storev, integer *n, integer *
+			     k, doublereal *v, integer *ldv, doublereal *tau, doublereal *t, 
+			     integer *ldt);
+
+/* Subroutine */ int dlas2_(doublereal *f, doublereal *g, doublereal *h__, 
+			    doublereal *ssmin, doublereal *ssmax);
+
+/* Subroutine */ int dlascl_(char *type__, integer *kl, integer *ku, 
+			     doublereal *cfrom, doublereal *cto, integer *m, integer *n, 
+			     doublereal *a, integer *lda, integer *info);
+
+/* Subroutine */ int dlascl2_(integer *m, integer *n, doublereal *d__, 
+			      doublereal *x, integer *ldx);
+
+/* Subroutine */ int dlasd0_(integer *n, integer *sqre, doublereal *d__, 
+			     doublereal *e, doublereal *u, integer *ldu, doublereal *vt, integer *
+			     ldvt, integer *smlsiz, integer *iwork, doublereal *work, integer *
+			     info);
+
+/* Subroutine */ int dlasd1_(integer *nl, integer *nr, integer *sqre, 
+			     doublereal *d__, doublereal *alpha, doublereal *beta, doublereal *u, 
+			     integer *ldu, doublereal *vt, integer *ldvt, integer *idxq, integer *
+			     iwork, doublereal *work, integer *info);
+
+/* Subroutine */ int dlasd2_(integer *nl, integer *nr, integer *sqre, integer 
+			     *k, doublereal *d__, doublereal *z__, doublereal *alpha, doublereal *
+			     beta, doublereal *u, integer *ldu, doublereal *vt, integer *ldvt, 
+			     doublereal *dsigma, doublereal *u2, integer *ldu2, doublereal *vt2, 
+			     integer *ldvt2, integer *idxp, integer *idx, integer *idxc, integer *
+			     idxq, integer *coltyp, integer *info);
+
+/* Subroutine */ int dlasd3_(integer *nl, integer *nr, integer *sqre, integer 
+			     *k, doublereal *d__, doublereal *q, integer *ldq, doublereal *dsigma, 
+			     doublereal *u, integer *ldu, doublereal *u2, integer *ldu2, 
+			     doublereal *vt, integer *ldvt, doublereal *vt2, integer *ldvt2, 
+			     integer *idxc, integer *ctot, doublereal *z__, integer *info);
+
+/* Subroutine */ int dlasd4_(integer *n, integer *i__, doublereal *d__, 
+			     doublereal *z__, doublereal *delta, doublereal *rho, doublereal *
+			     sigma, doublereal *work, integer *info);
+
+/* Subroutine */ int dlasd5_(integer *i__, doublereal *d__, doublereal *z__, 
+			     doublereal *delta, doublereal *rho, doublereal *dsigma, doublereal *
+			     work);
+
+/* Subroutine */ int dlasd6_(integer *icompq, integer *nl, integer *nr, 
+			     integer *sqre, doublereal *d__, doublereal *vf, doublereal *vl, 
+			     doublereal *alpha, doublereal *beta, integer *idxq, integer *perm, 
+			     integer *givptr, integer *givcol, integer *ldgcol, doublereal *givnum, 
+			     integer *ldgnum, doublereal *poles, doublereal *difl, doublereal *
+			     difr, doublereal *z__, integer *k, doublereal *c__, doublereal *s, 
+			     doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dlasd7_(integer *icompq, integer *nl, integer *nr, 
+			     integer *sqre, integer *k, doublereal *d__, doublereal *z__, 
+			     doublereal *zw, doublereal *vf, doublereal *vfw, doublereal *vl, 
+			     doublereal *vlw, doublereal *alpha, doublereal *beta, doublereal *
+			     dsigma, integer *idx, integer *idxp, integer *idxq, integer *perm, 
+			     integer *givptr, integer *givcol, integer *ldgcol, doublereal *givnum, 
+			     integer *ldgnum, doublereal *c__, doublereal *s, integer *info);
+
+/* Subroutine */ int dlasd8_(integer *icompq, integer *k, doublereal *d__, 
+			     doublereal *z__, doublereal *vf, doublereal *vl, doublereal *difl, 
+			     doublereal *difr, integer *lddifr, doublereal *dsigma, doublereal *
+			     work, integer *info);
+
+/* Subroutine */ int dlasda_(integer *icompq, integer *smlsiz, integer *n, 
+			     integer *sqre, doublereal *d__, doublereal *e, doublereal *u, integer 
+			     *ldu, doublereal *vt, integer *k, doublereal *difl, doublereal *difr, 
+			     doublereal *z__, doublereal *poles, integer *givptr, integer *givcol, 
+			     integer *ldgcol, integer *perm, doublereal *givnum, doublereal *c__, 
+			     doublereal *s, doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dlasdq_(char *uplo, integer *sqre, integer *n, integer *
+			     ncvt, integer *nru, integer *ncc, doublereal *d__, doublereal *e, 
+			     doublereal *vt, integer *ldvt, doublereal *u, integer *ldu, 
+			     doublereal *c__, integer *ldc, doublereal *work, integer *info);
+
+/* Subroutine */ int dlasdt_(integer *n, integer *lvl, integer *nd, integer *
+			     inode, integer *ndiml, integer *ndimr, integer *msub);
+
+/* Subroutine */ int dlaset_(char *uplo, integer *m, integer *n, doublereal *
+			     alpha, doublereal *beta, doublereal *a, integer *lda);
+
+/* Subroutine */ int dlasq1_(integer *n, doublereal *d__, doublereal *e, 
+			     doublereal *work, integer *info);
+
+/* Subroutine */ int dlasq2_(integer *n, doublereal *z__, integer *info);
+
+/* Subroutine */ int dlasq3_(integer *i0, integer *n0, doublereal *z__, 
+			     integer *pp, doublereal *dmin__, doublereal *sigma, doublereal *desig, 
+			     doublereal *qmax, integer *nfail, integer *iter, integer *ndiv, 
+			     logical *ieee, integer *ttype, doublereal *dmin1, doublereal *dmin2, 
+			     doublereal *dn, doublereal *dn1, doublereal *dn2, doublereal *g, 
+			     doublereal *tau);
+
+/* Subroutine */ int dlasq4_(integer *i0, integer *n0, doublereal *z__, 
+			     integer *pp, integer *n0in, doublereal *dmin__, doublereal *dmin1, 
+			     doublereal *dmin2, doublereal *dn, doublereal *dn1, doublereal *dn2, 
+			     doublereal *tau, integer *ttype, doublereal *g);
+
+/* Subroutine */ int dlasq5_(integer *i0, integer *n0, doublereal *z__, 
+			     integer *pp, doublereal *tau, doublereal *dmin__, doublereal *dmin1, 
+			     doublereal *dmin2, doublereal *dn, doublereal *dnm1, doublereal *dnm2, 
+			     logical *ieee);
+
+/* Subroutine */ int dlasq6_(integer *i0, integer *n0, doublereal *z__, 
+			     integer *pp, doublereal *dmin__, doublereal *dmin1, doublereal *dmin2, 
+			     doublereal *dn, doublereal *dnm1, doublereal *dnm2);
+
+/* Subroutine */ int dlasr_(char *side, char *pivot, char *direct, integer *m, 
+			    integer *n, doublereal *c__, doublereal *s, doublereal *a, integer *
+			    lda);
+
+/* Subroutine */ int dlasrt_(char *id, integer *n, doublereal *d__, integer *
+			     info);
+
+/* Subroutine */ int dlassq_(integer *n, doublereal *x, integer *incx, 
+			     doublereal *scale, doublereal *sumsq);
+
+/* Subroutine */ int dlasv2_(doublereal *f, doublereal *g, doublereal *h__, 
+			     doublereal *ssmin, doublereal *ssmax, doublereal *snr, doublereal *
+			     csr, doublereal *snl, doublereal *csl);
+
+/* Subroutine */ int dlaswp_(integer *n, doublereal *a, integer *lda, integer 
+			     *k1, integer *k2, integer *ipiv, integer *incx);
+
+/* Subroutine */ int dlasy2_(logical *ltranl, logical *ltranr, integer *isgn, 
+			     integer *n1, integer *n2, doublereal *tl, integer *ldtl, doublereal *
+			     tr, integer *ldtr, doublereal *b, integer *ldb, doublereal *scale, 
+			     doublereal *x, integer *ldx, doublereal *xnorm, integer *info);
+
+/* Subroutine */ int dlasyf_(char *uplo, integer *n, integer *nb, integer *kb, 
+			     doublereal *a, integer *lda, integer *ipiv, doublereal *w, integer *
+			     ldw, integer *info);
+
+/* Subroutine */ int dlat2s_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, real *sa, integer *ldsa, integer *info);
+
+/* Subroutine */ int dlatbs_(char *uplo, char *trans, char *diag, char *
+			     normin, integer *n, integer *kd, doublereal *ab, integer *ldab, 
+			     doublereal *x, doublereal *scale, doublereal *cnorm, integer *info);
+
+/* Subroutine */ int dlatdf_(integer *ijob, integer *n, doublereal *z__, 
+			     integer *ldz, doublereal *rhs, doublereal *rdsum, doublereal *rdscal, 
+			     integer *ipiv, integer *jpiv);
+
+/* Subroutine */ int dlatps_(char *uplo, char *trans, char *diag, char *
+			     normin, integer *n, doublereal *ap, doublereal *x, doublereal *scale, 
+			     doublereal *cnorm, integer *info);
+
+/* Subroutine */ int dlatrd_(char *uplo, integer *n, integer *nb, doublereal *
+			     a, integer *lda, doublereal *e, doublereal *tau, doublereal *w, 
+			     integer *ldw);
+
+/* Subroutine */ int dlatrs_(char *uplo, char *trans, char *diag, char *
+			     normin, integer *n, doublereal *a, integer *lda, doublereal *x, 
+			     doublereal *scale, doublereal *cnorm, integer *info);
+
+/* Subroutine */ int dlatrz_(integer *m, integer *n, integer *l, doublereal *
+			     a, integer *lda, doublereal *tau, doublereal *work);
+
+/* Subroutine */ int dlatzm_(char *side, integer *m, integer *n, doublereal *
+			     v, integer *incv, doublereal *tau, doublereal *c1, doublereal *c2, 
+			     integer *ldc, doublereal *work);
+
+/* Subroutine */ int dlauu2_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, integer *info);
+
+/* Subroutine */ int dlauum_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, integer *info);
+
+/* Subroutine */ int dopgtr_(char *uplo, integer *n, doublereal *ap, 
+			     doublereal *tau, doublereal *q, integer *ldq, doublereal *work, 
+			     integer *info);
+
+/* Subroutine */ int dopmtr_(char *side, char *uplo, char *trans, integer *m, 
+			     integer *n, doublereal *ap, doublereal *tau, doublereal *c__, integer 
+			     *ldc, doublereal *work, integer *info);
+
+/* Subroutine */ int dorg2l_(integer *m, integer *n, integer *k, doublereal *
+			     a, integer *lda, doublereal *tau, doublereal *work, integer *info);
+
+/* Subroutine */ int dorg2r_(integer *m, integer *n, integer *k, doublereal *
+			     a, integer *lda, doublereal *tau, doublereal *work, integer *info);
+
+/* Subroutine */ int dorgbr_(char *vect, integer *m, integer *n, integer *k, 
+			     doublereal *a, integer *lda, doublereal *tau, doublereal *work, 
+			     integer *lwork, integer *info);
+
+/* Subroutine */ int dorghr_(integer *n, integer *ilo, integer *ihi, 
+			     doublereal *a, integer *lda, doublereal *tau, doublereal *work, 
+			     integer *lwork, integer *info);
+
+/* Subroutine */ int dorgl2_(integer *m, integer *n, integer *k, doublereal *
+			     a, integer *lda, doublereal *tau, doublereal *work, integer *info);
+
+/* Subroutine */ int dorglq_(integer *m, integer *n, integer *k, doublereal *
+			     a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int dorgql_(integer *m, integer *n, integer *k, doublereal *
+			     a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int dorgqr_(integer *m, integer *n, integer *k, doublereal *
+			     a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int dorgr2_(integer *m, integer *n, integer *k, doublereal *
+			     a, integer *lda, doublereal *tau, doublereal *work, integer *info);
+
+/* Subroutine */ int dorgrq_(integer *m, integer *n, integer *k, doublereal *
+			     a, integer *lda, doublereal *tau, doublereal *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int dorgtr_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, doublereal *tau, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dorm2l_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *
+			     c__, integer *ldc, doublereal *work, integer *info);
+
+/* Subroutine */ int dorm2r_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *
+			     c__, integer *ldc, doublereal *work, integer *info);
+
+/* Subroutine */ int dormbr_(char *vect, char *side, char *trans, integer *m, 
+			     integer *n, integer *k, doublereal *a, integer *lda, doublereal *tau, 
+			     doublereal *c__, integer *ldc, doublereal *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int dormhr_(char *side, char *trans, integer *m, integer *n, 
+			     integer *ilo, integer *ihi, doublereal *a, integer *lda, doublereal *
+			     tau, doublereal *c__, integer *ldc, doublereal *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int dorml2_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *
+			     c__, integer *ldc, doublereal *work, integer *info);
+
+/* Subroutine */ int dormlq_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *
+			     c__, integer *ldc, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dormql_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *
+			     c__, integer *ldc, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dormqr_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *
+			     c__, integer *ldc, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dormr2_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *
+			     c__, integer *ldc, doublereal *work, integer *info);
+
+/* Subroutine */ int dormr3_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, integer *l, doublereal *a, integer *lda, doublereal *tau, 
+			     doublereal *c__, integer *ldc, doublereal *work, integer *info);
+
+/* Subroutine */ int dormrq_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublereal *a, integer *lda, doublereal *tau, doublereal *
+			     c__, integer *ldc, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dormrz_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, integer *l, doublereal *a, integer *lda, doublereal *tau, 
+			     doublereal *c__, integer *ldc, doublereal *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int dormtr_(char *side, char *uplo, char *trans, integer *m, 
+			     integer *n, doublereal *a, integer *lda, doublereal *tau, doublereal *
+			     c__, integer *ldc, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dpbcon_(char *uplo, integer *n, integer *kd, doublereal *
+			     ab, integer *ldab, doublereal *anorm, doublereal *rcond, doublereal *
+			     work, integer *iwork, integer *info);
+
+/* Subroutine */ int dpbequ_(char *uplo, integer *n, integer *kd, doublereal *
+			     ab, integer *ldab, doublereal *s, doublereal *scond, doublereal *amax, 
+			     integer *info);
+
+/* Subroutine */ int dpbrfs_(char *uplo, integer *n, integer *kd, integer *
+			     nrhs, doublereal *ab, integer *ldab, doublereal *afb, integer *ldafb, 
+			     doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *
+			     ferr, doublereal *berr, doublereal *work, integer *iwork, integer *
+			     info);
+
+/* Subroutine */ int dpbstf_(char *uplo, integer *n, integer *kd, doublereal *
+			     ab, integer *ldab, integer *info);
+
+/* Subroutine */ int dpbsv_(char *uplo, integer *n, integer *kd, integer *
+			    nrhs, doublereal *ab, integer *ldab, doublereal *b, integer *ldb, 
+			    integer *info);
+
+/* Subroutine */ int dpbsvx_(char *fact, char *uplo, integer *n, integer *kd, 
+			     integer *nrhs, doublereal *ab, integer *ldab, doublereal *afb, 
+			     integer *ldafb, char *equed, doublereal *s, doublereal *b, integer *
+			     ldb, doublereal *x, integer *ldx, doublereal *rcond, doublereal *ferr, 
+			     doublereal *berr, doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dpbtf2_(char *uplo, integer *n, integer *kd, doublereal *
+			     ab, integer *ldab, integer *info);
+
+/* Subroutine */ int dpbtrf_(char *uplo, integer *n, integer *kd, doublereal *
+			     ab, integer *ldab, integer *info);
+
+/* Subroutine */ int dpbtrs_(char *uplo, integer *n, integer *kd, integer *
+			     nrhs, doublereal *ab, integer *ldab, doublereal *b, integer *ldb, 
+			     integer *info);
+
+/* Subroutine */ int dpftrf_(char *transr, char *uplo, integer *n, doublereal 
+			     *a, integer *info);
+
+/* Subroutine */ int dpftri_(char *transr, char *uplo, integer *n, doublereal 
+			     *a, integer *info);
+
+/* Subroutine */ int dpftrs_(char *transr, char *uplo, integer *n, integer *
+			     nrhs, doublereal *a, doublereal *b, integer *ldb, integer *info);
+
+/* Subroutine */ int dpocon_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, doublereal *anorm, doublereal *rcond, doublereal *work, integer *
+			     iwork, integer *info);
+
+/* Subroutine */ int dpoequ_(integer *n, doublereal *a, integer *lda, 
+			     doublereal *s, doublereal *scond, doublereal *amax, integer *info);
+
+/* Subroutine */ int dpoequb_(integer *n, doublereal *a, integer *lda, 
+			      doublereal *s, doublereal *scond, doublereal *amax, integer *info);
+
+/* Subroutine */ int dporfs_(char *uplo, integer *n, integer *nrhs, 
+			     doublereal *a, integer *lda, doublereal *af, integer *ldaf, 
+			     doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *
+			     ferr, doublereal *berr, doublereal *work, integer *iwork, integer *
+			     info);
+
+/* Subroutine */ int dporfsx_(char *uplo, char *equed, integer *n, integer *
+			      nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, 
+			      doublereal *s, doublereal *b, integer *ldb, doublereal *x, integer *
+			      ldx, doublereal *rcond, doublereal *berr, integer *n_err_bnds__, 
+			      doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer *
+			      nparams, doublereal *params, doublereal *work, integer *iwork, 
+			      integer *info);
+
+/* Subroutine */ int dposv_(char *uplo, integer *n, integer *nrhs, doublereal 
+			    *a, integer *lda, doublereal *b, integer *ldb, integer *info);
+
+/* Subroutine */ int dposvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, 
+			     char *equed, doublereal *s, doublereal *b, integer *ldb, doublereal *
+			     x, integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *
+			     berr, doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dposvxx_(char *fact, char *uplo, integer *n, integer *
+			      nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, 
+			      char *equed, doublereal *s, doublereal *b, integer *ldb, doublereal *
+			      x, integer *ldx, doublereal *rcond, doublereal *rpvgrw, doublereal *
+			      berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal *
+			      err_bnds_comp__, integer *nparams, doublereal *params, doublereal *
+			      work, integer *iwork, integer *info);
+
+/* Subroutine */ int dpotf2_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, integer *info);
+
+/* Subroutine */ int dpotrf_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, integer *info);
+
+/* Subroutine */ int dpotri_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, integer *info);
+
+/* Subroutine */ int dpotrs_(char *uplo, integer *n, integer *nrhs, 
+			     doublereal *a, integer *lda, doublereal *b, integer *ldb, integer *
+			     info);
+
+/* Subroutine */ int dppcon_(char *uplo, integer *n, doublereal *ap, 
+			     doublereal *anorm, doublereal *rcond, doublereal *work, integer *
+			     iwork, integer *info);
+
+/* Subroutine */ int dppequ_(char *uplo, integer *n, doublereal *ap, 
+			     doublereal *s, doublereal *scond, doublereal *amax, integer *info);
+
+/* Subroutine */ int dpprfs_(char *uplo, integer *n, integer *nrhs, 
+			     doublereal *ap, doublereal *afp, doublereal *b, integer *ldb, 
+			     doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, 
+			     doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dppsv_(char *uplo, integer *n, integer *nrhs, doublereal 
+			    *ap, doublereal *b, integer *ldb, integer *info);
+
+/* Subroutine */ int dppsvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, doublereal *ap, doublereal *afp, char *equed, doublereal *s, 
+			     doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *
+			     rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer *
+			     iwork, integer *info);
+
+/* Subroutine */ int dpptrf_(char *uplo, integer *n, doublereal *ap, integer *
+			     info);
+
+/* Subroutine */ int dpptri_(char *uplo, integer *n, doublereal *ap, integer *
+			     info);
+
+/* Subroutine */ int dpptrs_(char *uplo, integer *n, integer *nrhs, 
+			     doublereal *ap, doublereal *b, integer *ldb, integer *info);
+
+/* Subroutine */ int dpstf2_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, integer *piv, integer *rank, doublereal *tol, doublereal *work, 
+			     integer *info);
+
+/* Subroutine */ int dpstrf_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, integer *piv, integer *rank, doublereal *tol, doublereal *work, 
+			     integer *info);
+
+/* Subroutine */ int dptcon_(integer *n, doublereal *d__, doublereal *e, 
+			     doublereal *anorm, doublereal *rcond, doublereal *work, integer *info);
+
+/* Subroutine */ int dpteqr_(char *compz, integer *n, doublereal *d__, 
+			     doublereal *e, doublereal *z__, integer *ldz, doublereal *work, 
+			     integer *info);
+
+/* Subroutine */ int dptrfs_(integer *n, integer *nrhs, doublereal *d__, 
+			     doublereal *e, doublereal *df, doublereal *ef, doublereal *b, integer 
+			     *ldb, doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, 
+			     doublereal *work, integer *info);
+
+/* Subroutine */ int dptsv_(integer *n, integer *nrhs, doublereal *d__, 
+			    doublereal *e, doublereal *b, integer *ldb, integer *info);
+
+/* Subroutine */ int dptsvx_(char *fact, integer *n, integer *nrhs, 
+			     doublereal *d__, doublereal *e, doublereal *df, doublereal *ef, 
+			     doublereal *b, integer *ldb, doublereal *x, integer *ldx, doublereal *
+			     rcond, doublereal *ferr, doublereal *berr, doublereal *work, integer *
+			     info);
+
+/* Subroutine */ int dpttrf_(integer *n, doublereal *d__, doublereal *e, 
+			     integer *info);
+
+/* Subroutine */ int dpttrs_(integer *n, integer *nrhs, doublereal *d__, 
+			     doublereal *e, doublereal *b, integer *ldb, integer *info);
+
+/* Subroutine */ int dptts2_(integer *n, integer *nrhs, doublereal *d__, 
+			     doublereal *e, doublereal *b, integer *ldb);
+
+/* Subroutine */ int drscl_(integer *n, doublereal *sa, doublereal *sx, 
+			    integer *incx);
+
+/* Subroutine */ int dsbev_(char *jobz, char *uplo, integer *n, integer *kd, 
+			    doublereal *ab, integer *ldab, doublereal *w, doublereal *z__, 
+			    integer *ldz, doublereal *work, integer *info);
+
+/* Subroutine */ int dsbevd_(char *jobz, char *uplo, integer *n, integer *kd, 
+			     doublereal *ab, integer *ldab, doublereal *w, doublereal *z__, 
+			     integer *ldz, doublereal *work, integer *lwork, integer *iwork, 
+			     integer *liwork, integer *info);
+
+/* Subroutine */ int dsbevx_(char *jobz, char *range, char *uplo, integer *n, 
+			     integer *kd, doublereal *ab, integer *ldab, doublereal *q, integer *
+			     ldq, doublereal *vl, doublereal *vu, integer *il, integer *iu, 
+			     doublereal *abstol, integer *m, doublereal *w, doublereal *z__, 
+			     integer *ldz, doublereal *work, integer *iwork, integer *ifail, 
+			     integer *info);
+
+/* Subroutine */ int dsbgst_(char *vect, char *uplo, integer *n, integer *ka, 
+			     integer *kb, doublereal *ab, integer *ldab, doublereal *bb, integer *
+			     ldbb, doublereal *x, integer *ldx, doublereal *work, integer *info);
+
+/* Subroutine */ int dsbgv_(char *jobz, char *uplo, integer *n, integer *ka, 
+			    integer *kb, doublereal *ab, integer *ldab, doublereal *bb, integer *
+			    ldbb, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, 
+			    integer *info);
+
+/* Subroutine */ int dsbgvd_(char *jobz, char *uplo, integer *n, integer *ka, 
+			     integer *kb, doublereal *ab, integer *ldab, doublereal *bb, integer *
+			     ldbb, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, 
+			     integer *lwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int dsbgvx_(char *jobz, char *range, char *uplo, integer *n, 
+			     integer *ka, integer *kb, doublereal *ab, integer *ldab, doublereal *
+			     bb, integer *ldbb, doublereal *q, integer *ldq, doublereal *vl, 
+			     doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer 
+			     *m, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, 
+			     integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int dsbtrd_(char *vect, char *uplo, integer *n, integer *kd, 
+			     doublereal *ab, integer *ldab, doublereal *d__, doublereal *e, 
+			     doublereal *q, integer *ldq, doublereal *work, integer *info);
+
+/* Subroutine */ int dsfrk_(char *transr, char *uplo, char *trans, integer *n, 
+			    integer *k, doublereal *alpha, doublereal *a, integer *lda, 
+			    doublereal *beta, doublereal *c__);
+
+/* Subroutine */ int dsgesv_(integer *n, integer *nrhs, doublereal *a, 
+			     integer *lda, integer *ipiv, doublereal *b, integer *ldb, doublereal *
+			     x, integer *ldx, doublereal *work, real *swork, integer *iter, 
+			     integer *info);
+
+/* Subroutine */ int dspcon_(char *uplo, integer *n, doublereal *ap, integer *
+			     ipiv, doublereal *anorm, doublereal *rcond, doublereal *work, integer 
+			     *iwork, integer *info);
+
+/* Subroutine */ int dspev_(char *jobz, char *uplo, integer *n, doublereal *
+			    ap, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, 
+			    integer *info);
+
+/* Subroutine */ int dspevd_(char *jobz, char *uplo, integer *n, doublereal *
+			     ap, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, 
+			     integer *lwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int dspevx_(char *jobz, char *range, char *uplo, integer *n, 
+			     doublereal *ap, doublereal *vl, doublereal *vu, integer *il, integer *
+			     iu, doublereal *abstol, integer *m, doublereal *w, doublereal *z__, 
+			     integer *ldz, doublereal *work, integer *iwork, integer *ifail, 
+			     integer *info);
+
+/* Subroutine */ int dspgst_(integer *itype, char *uplo, integer *n, 
+			     doublereal *ap, doublereal *bp, integer *info);
+
+/* Subroutine */ int dspgv_(integer *itype, char *jobz, char *uplo, integer *
+			    n, doublereal *ap, doublereal *bp, doublereal *w, doublereal *z__, 
+			    integer *ldz, doublereal *work, integer *info);
+
+/* Subroutine */ int dspgvd_(integer *itype, char *jobz, char *uplo, integer *
+			     n, doublereal *ap, doublereal *bp, doublereal *w, doublereal *z__, 
+			     integer *ldz, doublereal *work, integer *lwork, integer *iwork, 
+			     integer *liwork, integer *info);
+
+/* Subroutine */ int dspgvx_(integer *itype, char *jobz, char *range, char *
+			     uplo, integer *n, doublereal *ap, doublereal *bp, doublereal *vl, 
+			     doublereal *vu, integer *il, integer *iu, doublereal *abstol, integer 
+			     *m, doublereal *w, doublereal *z__, integer *ldz, doublereal *work, 
+			     integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int dsposv_(char *uplo, integer *n, integer *nrhs, 
+			     doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *
+			     x, integer *ldx, doublereal *work, real *swork, integer *iter, 
+			     integer *info);
+
+/* Subroutine */ int dsprfs_(char *uplo, integer *n, integer *nrhs, 
+			     doublereal *ap, doublereal *afp, integer *ipiv, doublereal *b, 
+			     integer *ldb, doublereal *x, integer *ldx, doublereal *ferr, 
+			     doublereal *berr, doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dspsv_(char *uplo, integer *n, integer *nrhs, doublereal 
+			    *ap, integer *ipiv, doublereal *b, integer *ldb, integer *info);
+
+/* Subroutine */ int dspsvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, doublereal *ap, doublereal *afp, integer *ipiv, doublereal *b, 
+			     integer *ldb, doublereal *x, integer *ldx, doublereal *rcond, 
+			     doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int dsptrd_(char *uplo, integer *n, doublereal *ap, 
+			     doublereal *d__, doublereal *e, doublereal *tau, integer *info);
+
+/* Subroutine */ int dsptrf_(char *uplo, integer *n, doublereal *ap, integer *
+			     ipiv, integer *info);
+
+/* Subroutine */ int dsptri_(char *uplo, integer *n, doublereal *ap, integer *
+			     ipiv, doublereal *work, integer *info);
+
+/* Subroutine */ int dsptrs_(char *uplo, integer *n, integer *nrhs, 
+			     doublereal *ap, integer *ipiv, doublereal *b, integer *ldb, integer *
+			     info);
+
+/* Subroutine */ int dstebz_(char *range, char *order, integer *n, doublereal 
+			     *vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, 
+			     doublereal *d__, doublereal *e, integer *m, integer *nsplit, 
+			     doublereal *w, integer *iblock, integer *isplit, doublereal *work, 
+			     integer *iwork, integer *info);
+
+/* Subroutine */ int dstedc_(char *compz, integer *n, doublereal *d__, 
+			     doublereal *e, doublereal *z__, integer *ldz, doublereal *work, 
+			     integer *lwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int dstegr_(char *jobz, char *range, integer *n, doublereal *
+			     d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, 
+			     integer *iu, doublereal *abstol, integer *m, doublereal *w, 
+			     doublereal *z__, integer *ldz, integer *isuppz, doublereal *work, 
+			     integer *lwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int dstein_(integer *n, doublereal *d__, doublereal *e, 
+			     integer *m, doublereal *w, integer *iblock, integer *isplit, 
+			     doublereal *z__, integer *ldz, doublereal *work, integer *iwork, 
+			     integer *ifail, integer *info);
+
+/* Subroutine */ int dstemr_(char *jobz, char *range, integer *n, doublereal *
+			     d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, 
+			     integer *iu, integer *m, doublereal *w, doublereal *z__, integer *ldz, 
+			     integer *nzc, integer *isuppz, logical *tryrac, doublereal *work, 
+			     integer *lwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int dsteqr_(char *compz, integer *n, doublereal *d__, 
+			     doublereal *e, doublereal *z__, integer *ldz, doublereal *work, 
+			     integer *info);
+
+/* Subroutine */ int dsterf_(integer *n, doublereal *d__, doublereal *e, 
+			     integer *info);
+
+/* Subroutine */ int dstev_(char *jobz, integer *n, doublereal *d__, 
+			    doublereal *e, doublereal *z__, integer *ldz, doublereal *work, 
+			    integer *info);
+
+/* Subroutine */ int dstevd_(char *jobz, integer *n, doublereal *d__, 
+			     doublereal *e, doublereal *z__, integer *ldz, doublereal *work, 
+			     integer *lwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int dstevr_(char *jobz, char *range, integer *n, doublereal *
+			     d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, 
+			     integer *iu, doublereal *abstol, integer *m, doublereal *w, 
+			     doublereal *z__, integer *ldz, integer *isuppz, doublereal *work, 
+			     integer *lwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int dstevx_(char *jobz, char *range, integer *n, doublereal *
+			     d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, 
+			     integer *iu, doublereal *abstol, integer *m, doublereal *w, 
+			     doublereal *z__, integer *ldz, doublereal *work, integer *iwork, 
+			     integer *ifail, integer *info);
+
+/* Subroutine */ int dsycon_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, integer *ipiv, doublereal *anorm, doublereal *rcond, doublereal *
+			     work, integer *iwork, integer *info);
+
+/* Subroutine */ int dsyequb_(char *uplo, integer *n, doublereal *a, integer *
+			      lda, doublereal *s, doublereal *scond, doublereal *amax, doublereal *
+			      work, integer *info);
+
+/* Subroutine */ int dsyev_(char *jobz, char *uplo, integer *n, doublereal *a, 
+			    integer *lda, doublereal *w, doublereal *work, integer *lwork, 
+			    integer *info);
+
+/* Subroutine */ int dsyevd_(char *jobz, char *uplo, integer *n, doublereal *
+			     a, integer *lda, doublereal *w, doublereal *work, integer *lwork, 
+			     integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int dsyevr_(char *jobz, char *range, char *uplo, integer *n, 
+			     doublereal *a, integer *lda, doublereal *vl, doublereal *vu, integer *
+			     il, integer *iu, doublereal *abstol, integer *m, doublereal *w, 
+			     doublereal *z__, integer *ldz, integer *isuppz, doublereal *work, 
+			     integer *lwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int dsyevx_(char *jobz, char *range, char *uplo, integer *n, 
+			     doublereal *a, integer *lda, doublereal *vl, doublereal *vu, integer *
+			     il, integer *iu, doublereal *abstol, integer *m, doublereal *w, 
+			     doublereal *z__, integer *ldz, doublereal *work, integer *lwork, 
+			     integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int dsygs2_(integer *itype, char *uplo, integer *n, 
+			     doublereal *a, integer *lda, doublereal *b, integer *ldb, integer *
+			     info);
+
+/* Subroutine */ int dsygst_(integer *itype, char *uplo, integer *n, 
+			     doublereal *a, integer *lda, doublereal *b, integer *ldb, integer *
+			     info);
+
+/* Subroutine */ int dsygv_(integer *itype, char *jobz, char *uplo, integer *
+			    n, doublereal *a, integer *lda, doublereal *b, integer *ldb, 
+			    doublereal *w, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dsygvd_(integer *itype, char *jobz, char *uplo, integer *
+			     n, doublereal *a, integer *lda, doublereal *b, integer *ldb, 
+			     doublereal *w, doublereal *work, integer *lwork, integer *iwork, 
+			     integer *liwork, integer *info);
+
+/* Subroutine */ int dsygvx_(integer *itype, char *jobz, char *range, char *
+			     uplo, integer *n, doublereal *a, integer *lda, doublereal *b, integer 
+			     *ldb, doublereal *vl, doublereal *vu, integer *il, integer *iu, 
+			     doublereal *abstol, integer *m, doublereal *w, doublereal *z__, 
+			     integer *ldz, doublereal *work, integer *lwork, integer *iwork, 
+			     integer *ifail, integer *info);
+
+/* Subroutine */ int dsyrfs_(char *uplo, integer *n, integer *nrhs, 
+			     doublereal *a, integer *lda, doublereal *af, integer *ldaf, integer *
+			     ipiv, doublereal *b, integer *ldb, doublereal *x, integer *ldx, 
+			     doublereal *ferr, doublereal *berr, doublereal *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int dsyrfsx_(char *uplo, char *equed, integer *n, integer *
+			      nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, 
+			      integer *ipiv, doublereal *s, doublereal *b, integer *ldb, doublereal 
+			      *x, integer *ldx, doublereal *rcond, doublereal *berr, integer *
+			      n_err_bnds__, doublereal *err_bnds_norm__, doublereal *
+			      err_bnds_comp__, integer *nparams, doublereal *params, doublereal *
+			      work, integer *iwork, integer *info);
+
+/* Subroutine */ int dsysv_(char *uplo, integer *n, integer *nrhs, doublereal 
+			    *a, integer *lda, integer *ipiv, doublereal *b, integer *ldb, 
+			    doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dsysvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, 
+			     integer *ipiv, doublereal *b, integer *ldb, doublereal *x, integer *
+			     ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, 
+			     doublereal *work, integer *lwork, integer *iwork, integer *info);
+
+/* Subroutine */ int dsysvxx_(char *fact, char *uplo, integer *n, integer *
+			      nrhs, doublereal *a, integer *lda, doublereal *af, integer *ldaf, 
+			      integer *ipiv, char *equed, doublereal *s, doublereal *b, integer *
+			      ldb, doublereal *x, integer *ldx, doublereal *rcond, doublereal *
+			      rpvgrw, doublereal *berr, integer *n_err_bnds__, doublereal *
+			      err_bnds_norm__, doublereal *err_bnds_comp__, integer *nparams, 
+			      doublereal *params, doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dsytd2_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, doublereal *d__, doublereal *e, doublereal *tau, integer *info);
+
+/* Subroutine */ int dsytf2_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, integer *ipiv, integer *info);
+
+/* Subroutine */ int dsytrd_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, doublereal *d__, doublereal *e, doublereal *tau, doublereal *
+			     work, integer *lwork, integer *info);
+
+/* Subroutine */ int dsytrf_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, integer *ipiv, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dsytri_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, integer *ipiv, doublereal *work, integer *info);
+
+/* Subroutine */ int dsytrs_(char *uplo, integer *n, integer *nrhs, 
+			     doublereal *a, integer *lda, integer *ipiv, doublereal *b, integer *
+			     ldb, integer *info);
+
+/* Subroutine */ int dtbcon_(char *norm, char *uplo, char *diag, integer *n, 
+			     integer *kd, doublereal *ab, integer *ldab, doublereal *rcond, 
+			     doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dtbrfs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *kd, integer *nrhs, doublereal *ab, integer *ldab, doublereal 
+			     *b, integer *ldb, doublereal *x, integer *ldx, doublereal *ferr, 
+			     doublereal *berr, doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dtbtrs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *kd, integer *nrhs, doublereal *ab, integer *ldab, doublereal 
+			     *b, integer *ldb, integer *info);
+
+/* Subroutine */ int dtfsm_(char *transr, char *side, char *uplo, char *trans, 
+			    char *diag, integer *m, integer *n, doublereal *alpha, doublereal *a, 
+			    doublereal *b, integer *ldb);
+
+/* Subroutine */ int dtftri_(char *transr, char *uplo, char *diag, integer *n, 
+			     doublereal *a, integer *info);
+
+/* Subroutine */ int dtfttp_(char *transr, char *uplo, integer *n, doublereal 
+			     *arf, doublereal *ap, integer *info);
+
+/* Subroutine */ int dtfttr_(char *transr, char *uplo, integer *n, doublereal 
+			     *arf, doublereal *a, integer *lda, integer *info);
+
+/* Subroutine */ int dtgevc_(char *side, char *howmny, logical *select, 
+			     integer *n, doublereal *s, integer *lds, doublereal *p, integer *ldp, 
+			     doublereal *vl, integer *ldvl, doublereal *vr, integer *ldvr, integer 
+			     *mm, integer *m, doublereal *work, integer *info);
+
+/* Subroutine */ int dtgex2_(logical *wantq, logical *wantz, integer *n, 
+			     doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *
+			     q, integer *ldq, doublereal *z__, integer *ldz, integer *j1, integer *
+			     n1, integer *n2, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dtgexc_(logical *wantq, logical *wantz, integer *n, 
+			     doublereal *a, integer *lda, doublereal *b, integer *ldb, doublereal *
+			     q, integer *ldq, doublereal *z__, integer *ldz, integer *ifst, 
+			     integer *ilst, doublereal *work, integer *lwork, integer *info);
+
+/* Subroutine */ int dtgsen_(integer *ijob, logical *wantq, logical *wantz, 
+			     logical *select, integer *n, doublereal *a, integer *lda, doublereal *
+			     b, integer *ldb, doublereal *alphar, doublereal *alphai, doublereal *
+			     beta, doublereal *q, integer *ldq, doublereal *z__, integer *ldz, 
+			     integer *m, doublereal *pl, doublereal *pr, doublereal *dif, 
+			     doublereal *work, integer *lwork, integer *iwork, integer *liwork, 
+			     integer *info);
+
+/* Subroutine */ int dtgsja_(char *jobu, char *jobv, char *jobq, integer *m, 
+			     integer *p, integer *n, integer *k, integer *l, doublereal *a, 
+			     integer *lda, doublereal *b, integer *ldb, doublereal *tola, 
+			     doublereal *tolb, doublereal *alpha, doublereal *beta, doublereal *u, 
+			     integer *ldu, doublereal *v, integer *ldv, doublereal *q, integer *
+			     ldq, doublereal *work, integer *ncycle, integer *info);
+
+/* Subroutine */ int dtgsna_(char *job, char *howmny, logical *select, 
+			     integer *n, doublereal *a, integer *lda, doublereal *b, integer *ldb, 
+			     doublereal *vl, integer *ldvl, doublereal *vr, integer *ldvr, 
+			     doublereal *s, doublereal *dif, integer *mm, integer *m, doublereal *
+			     work, integer *lwork, integer *iwork, integer *info);
+
+/* Subroutine */ int dtgsy2_(char *trans, integer *ijob, integer *m, integer *
+			     n, doublereal *a, integer *lda, doublereal *b, integer *ldb, 
+			     doublereal *c__, integer *ldc, doublereal *d__, integer *ldd, 
+			     doublereal *e, integer *lde, doublereal *f, integer *ldf, doublereal *
+			     scale, doublereal *rdsum, doublereal *rdscal, integer *iwork, integer 
+			     *pq, integer *info);
+
+/* Subroutine */ int dtgsyl_(char *trans, integer *ijob, integer *m, integer *
+			     n, doublereal *a, integer *lda, doublereal *b, integer *ldb, 
+			     doublereal *c__, integer *ldc, doublereal *d__, integer *ldd, 
+			     doublereal *e, integer *lde, doublereal *f, integer *ldf, doublereal *
+			     scale, doublereal *dif, doublereal *work, integer *lwork, integer *
+			     iwork, integer *info);
+
+/* Subroutine */ int dtpcon_(char *norm, char *uplo, char *diag, integer *n, 
+			     doublereal *ap, doublereal *rcond, doublereal *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int dtprfs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, doublereal *ap, doublereal *b, integer *ldb, 
+			     doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, 
+			     doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dtptri_(char *uplo, char *diag, integer *n, doublereal *
+			     ap, integer *info);
+
+/* Subroutine */ int dtptrs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, doublereal *ap, doublereal *b, integer *ldb, integer *
+			     info);
+
+/* Subroutine */ int dtpttf_(char *transr, char *uplo, integer *n, doublereal 
+			     *ap, doublereal *arf, integer *info);
+
+/* Subroutine */ int dtpttr_(char *uplo, integer *n, doublereal *ap, 
+			     doublereal *a, integer *lda, integer *info);
+
+/* Subroutine */ int dtrcon_(char *norm, char *uplo, char *diag, integer *n, 
+			     doublereal *a, integer *lda, doublereal *rcond, doublereal *work, 
+			     integer *iwork, integer *info);
+
+/* Subroutine */ int dtrevc_(char *side, char *howmny, logical *select, 
+			     integer *n, doublereal *t, integer *ldt, doublereal *vl, integer *
+			     ldvl, doublereal *vr, integer *ldvr, integer *mm, integer *m, 
+			     doublereal *work, integer *info);
+
+/* Subroutine */ int dtrexc_(char *compq, integer *n, doublereal *t, integer *
+			     ldt, doublereal *q, integer *ldq, integer *ifst, integer *ilst, 
+			     doublereal *work, integer *info);
+
+/* Subroutine */ int dtrrfs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, doublereal *a, integer *lda, doublereal *b, integer *
+			     ldb, doublereal *x, integer *ldx, doublereal *ferr, doublereal *berr, 
+			     doublereal *work, integer *iwork, integer *info);
+
+/* Subroutine */ int dtrsen_(char *job, char *compq, logical *select, integer 
+			     *n, doublereal *t, integer *ldt, doublereal *q, integer *ldq, 
+			     doublereal *wr, doublereal *wi, integer *m, doublereal *s, doublereal 
+			     *sep, doublereal *work, integer *lwork, integer *iwork, integer *
+			     liwork, integer *info);
+
+/* Subroutine */ int dtrsna_(char *job, char *howmny, logical *select, 
+			     integer *n, doublereal *t, integer *ldt, doublereal *vl, integer *
+			     ldvl, doublereal *vr, integer *ldvr, doublereal *s, doublereal *sep, 
+			     integer *mm, integer *m, doublereal *work, integer *ldwork, integer *
+			     iwork, integer *info);
+
+/* Subroutine */ int dtrsyl_(char *trana, char *tranb, integer *isgn, integer 
+			     *m, integer *n, doublereal *a, integer *lda, doublereal *b, integer *
+			     ldb, doublereal *c__, integer *ldc, doublereal *scale, integer *info);
+
+/* Subroutine */ int dtrti2_(char *uplo, char *diag, integer *n, doublereal *
+			     a, integer *lda, integer *info);
+
+/* Subroutine */ int dtrtri_(char *uplo, char *diag, integer *n, doublereal *
+			     a, integer *lda, integer *info);
+
+/* Subroutine */ int dtrtrs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, doublereal *a, integer *lda, doublereal *b, integer *
+			     ldb, integer *info);
+
+/* Subroutine */ int dtrttf_(char *transr, char *uplo, integer *n, doublereal 
+			     *a, integer *lda, doublereal *arf, integer *info);
+
+/* Subroutine */ int dtrttp_(char *uplo, integer *n, doublereal *a, integer *
+			     lda, doublereal *ap, integer *info);
+
+/* Subroutine */ int dtzrqf_(integer *m, integer *n, doublereal *a, integer *
+			     lda, doublereal *tau, integer *info);
+
+/* Subroutine */ int dtzrzf_(integer *m, integer *n, doublereal *a, integer *
+			     lda, doublereal *tau, doublereal *work, integer *lwork, integer *info);
+
+doublereal dzsum1_(integer *n, doublecomplex *cx, integer *incx);
+
+integer icmax1_(integer *n, singlecomplex *cx, integer *incx);
+
+integer ieeeck_(integer *ispec, real *zero, real *one);
+
+integer ilaclc_(integer *m, integer *n, singlecomplex *a, integer *lda);
+
+integer ilaclr_(integer *m, integer *n, singlecomplex *a, integer *lda);
+
+integer iladiag_(char *diag);
+
+integer iladlc_(integer *m, integer *n, doublereal *a, integer *lda);
+
+integer iladlr_(integer *m, integer *n, doublereal *a, integer *lda);
+
+integer ilaenv_(integer *ispec, char *name__, char *opts, integer *n1, 
+		integer *n2, integer *n3, integer *n4);
+
+integer ilaprec_(char *prec);
+
+integer ilaslc_(integer *m, integer *n, real *a, integer *lda);
+
+integer ilaslr_(integer *m, integer *n, real *a, integer *lda);
+
+integer ilatrans_(char *trans);
+
+integer ilauplo_(char *uplo);
+
+/* Subroutine */ int ilaver_(integer *vers_major__, integer *vers_minor__, 
+			     integer *vers_patch__);
+
+integer ilazlc_(integer *m, integer *n, doublecomplex *a, integer *lda);
+
+integer ilazlr_(integer *m, integer *n, doublecomplex *a, integer *lda);
+
+integer iparmq_(integer *ispec, char *name__, char *opts, integer *n, integer 
+		*ilo, integer *ihi, integer *lwork);
+
+integer izmax1_(integer *n, doublecomplex *cx, integer *incx);
+
+logical lsamen_(integer *n, char *ca, char *cb);
+
+integer smaxloc_(real *a, integer *dimm);
+
+/* Subroutine */ int sbdsdc_(char *uplo, char *compq, integer *n, real *d__, 
+			     real *e, real *u, integer *ldu, real *vt, integer *ldvt, real *q, 
+			     integer *iq, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int sbdsqr_(char *uplo, integer *n, integer *ncvt, integer *
+			     nru, integer *ncc, real *d__, real *e, real *vt, integer *ldvt, real *
+			     u, integer *ldu, real *c__, integer *ldc, real *work, integer *info);
+
+doublereal scsum1_(integer *n, singlecomplex *cx, integer *incx);
+
+/* Subroutine */ int sdisna_(char *job, integer *m, integer *n, real *d__, 
+			     real *sep, integer *info);
+
+/* Subroutine */ int sgbbrd_(char *vect, integer *m, integer *n, integer *ncc, 
+			     integer *kl, integer *ku, real *ab, integer *ldab, real *d__, real *
+			     e, real *q, integer *ldq, real *pt, integer *ldpt, real *c__, integer 
+			     *ldc, real *work, integer *info);
+
+/* Subroutine */ int sgbcon_(char *norm, integer *n, integer *kl, integer *ku, 
+			     real *ab, integer *ldab, integer *ipiv, real *anorm, real *rcond, 
+			     real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int sgbequ_(integer *m, integer *n, integer *kl, integer *ku, 
+			     real *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real *
+			     colcnd, real *amax, integer *info);
+
+/* Subroutine */ int sgbequb_(integer *m, integer *n, integer *kl, integer *
+			      ku, real *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real 
+			      *colcnd, real *amax, integer *info);
+
+/* Subroutine */ int sgbrfs_(char *trans, integer *n, integer *kl, integer *
+			     ku, integer *nrhs, real *ab, integer *ldab, real *afb, integer *ldafb, 
+			     integer *ipiv, real *b, integer *ldb, real *x, integer *ldx, real *
+			     ferr, real *berr, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int sgbrfsx_(char *trans, char *equed, integer *n, integer *
+			      kl, integer *ku, integer *nrhs, real *ab, integer *ldab, real *afb, 
+			      integer *ldafb, integer *ipiv, real *r__, real *c__, real *b, integer 
+			      *ldb, real *x, integer *ldx, real *rcond, real *berr, integer *
+			      n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, integer *
+			      nparams, real *params, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int sgbsv_(integer *n, integer *kl, integer *ku, integer *
+			    nrhs, real *ab, integer *ldab, integer *ipiv, real *b, integer *ldb, 
+			    integer *info);
+
+/* Subroutine */ int sgbsvx_(char *fact, char *trans, integer *n, integer *kl, 
+			     integer *ku, integer *nrhs, real *ab, integer *ldab, real *afb, 
+			     integer *ldafb, integer *ipiv, char *equed, real *r__, real *c__, 
+			     real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *ferr, 
+			     real *berr, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int sgbsvxx_(char *fact, char *trans, integer *n, integer *
+			      kl, integer *ku, integer *nrhs, real *ab, integer *ldab, real *afb, 
+			      integer *ldafb, integer *ipiv, char *equed, real *r__, real *c__, 
+			      real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *
+			      rpvgrw, real *berr, integer *n_err_bnds__, real *err_bnds_norm__, 
+			      real *err_bnds_comp__, integer *nparams, real *params, real *work, 
+			      integer *iwork, integer *info);
+
+/* Subroutine */ int sgbtf2_(integer *m, integer *n, integer *kl, integer *ku, 
+			     real *ab, integer *ldab, integer *ipiv, integer *info);
+
+/* Subroutine */ int sgbtrf_(integer *m, integer *n, integer *kl, integer *ku, 
+			     real *ab, integer *ldab, integer *ipiv, integer *info);
+
+/* Subroutine */ int sgbtrs_(char *trans, integer *n, integer *kl, integer *
+			     ku, integer *nrhs, real *ab, integer *ldab, integer *ipiv, real *b, 
+			     integer *ldb, integer *info);
+
+/* Subroutine */ int sgebak_(char *job, char *side, integer *n, integer *ilo, 
+			     integer *ihi, real *scale, integer *m, real *v, integer *ldv, integer 
+			     *info);
+
+/* Subroutine */ int sgebal_(char *job, integer *n, real *a, integer *lda, 
+			     integer *ilo, integer *ihi, real *scale, integer *info);
+
+/* Subroutine */ int sgebd2_(integer *m, integer *n, real *a, integer *lda, 
+			     real *d__, real *e, real *tauq, real *taup, real *work, integer *info);
+
+/* Subroutine */ int sgebrd_(integer *m, integer *n, real *a, integer *lda, 
+			     real *d__, real *e, real *tauq, real *taup, real *work, integer *
+			     lwork, integer *info);
+
+/* Subroutine */ int sgecon_(char *norm, integer *n, real *a, integer *lda, 
+			     real *anorm, real *rcond, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int sgeequ_(integer *m, integer *n, real *a, integer *lda, 
+			     real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, integer 
+			     *info);
+
+/* Subroutine */ int sgeequb_(integer *m, integer *n, real *a, integer *lda, 
+			      real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, integer 
+			      *info);
+
+/* Subroutine */ int sgees_(char *jobvs, char *sort, L_fp select, integer *n, 
+			    real *a, integer *lda, integer *sdim, real *wr, real *wi, real *vs, 
+			    integer *ldvs, real *work, integer *lwork, logical *bwork, integer *
+			    info);
+
+/* Subroutine */ int sgeesx_(char *jobvs, char *sort, L_fp select, char *
+			     sense, integer *n, real *a, integer *lda, integer *sdim, real *wr, 
+			     real *wi, real *vs, integer *ldvs, real *rconde, real *rcondv, real *
+			     work, integer *lwork, integer *iwork, integer *liwork, logical *bwork, 
+			     integer *info);
+
+/* Subroutine */ int sgeev_(char *jobvl, char *jobvr, integer *n, real *a, 
+			    integer *lda, real *wr, real *wi, real *vl, integer *ldvl, real *vr, 
+			    integer *ldvr, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sgeevx_(char *balanc, char *jobvl, char *jobvr, char *
+			     sense, integer *n, real *a, integer *lda, real *wr, real *wi, real *
+			     vl, integer *ldvl, real *vr, integer *ldvr, integer *ilo, integer *
+			     ihi, real *scale, real *abnrm, real *rconde, real *rcondv, real *work, 
+			     integer *lwork, integer *iwork, integer *info);
+
+/* Subroutine */ int sgegs_(char *jobvsl, char *jobvsr, integer *n, real *a, 
+			    integer *lda, real *b, integer *ldb, real *alphar, real *alphai, real 
+			    *beta, real *vsl, integer *ldvsl, real *vsr, integer *ldvsr, real *
+			    work, integer *lwork, integer *info);
+
+/* Subroutine */ int sgegv_(char *jobvl, char *jobvr, integer *n, real *a, 
+			    integer *lda, real *b, integer *ldb, real *alphar, real *alphai, real 
+			    *beta, real *vl, integer *ldvl, real *vr, integer *ldvr, real *work, 
+			    integer *lwork, integer *info);
+
+/* Subroutine */ int sgehd2_(integer *n, integer *ilo, integer *ihi, real *a, 
+			     integer *lda, real *tau, real *work, integer *info);
+
+/* Subroutine */ int sgehrd_(integer *n, integer *ilo, integer *ihi, real *a, 
+			     integer *lda, real *tau, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sgejsv_(char *joba, char *jobu, char *jobv, char *jobr, 
+			     char *jobt, char *jobp, integer *m, integer *n, real *a, integer *lda, 
+			     real *sva, real *u, integer *ldu, real *v, integer *ldv, real *work, 
+			     integer *lwork, integer *iwork, integer *info);
+
+/* Subroutine */ int sgelq2_(integer *m, integer *n, real *a, integer *lda, 
+			     real *tau, real *work, integer *info);
+
+/* Subroutine */ int sgelqf_(integer *m, integer *n, real *a, integer *lda, 
+			     real *tau, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sgels_(char *trans, integer *m, integer *n, integer *
+			    nrhs, real *a, integer *lda, real *b, integer *ldb, real *work, 
+			    integer *lwork, integer *info);
+
+/* Subroutine */ int sgelsd_(integer *m, integer *n, integer *nrhs, real *a, 
+			     integer *lda, real *b, integer *ldb, real *s, real *rcond, integer *
+			     rank, real *work, integer *lwork, integer *iwork, integer *info);
+
+/* Subroutine */ int sgelss_(integer *m, integer *n, integer *nrhs, real *a, 
+			     integer *lda, real *b, integer *ldb, real *s, real *rcond, integer *
+			     rank, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sgelsx_(integer *m, integer *n, integer *nrhs, real *a, 
+			     integer *lda, real *b, integer *ldb, integer *jpvt, real *rcond, 
+			     integer *rank, real *work, integer *info);
+
+/* Subroutine */ int sgelsy_(integer *m, integer *n, integer *nrhs, real *a, 
+			     integer *lda, real *b, integer *ldb, integer *jpvt, real *rcond, 
+			     integer *rank, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sgeql2_(integer *m, integer *n, real *a, integer *lda, 
+			     real *tau, real *work, integer *info);
+
+/* Subroutine */ int sgeqlf_(integer *m, integer *n, real *a, integer *lda, 
+			     real *tau, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sgeqp3_(integer *m, integer *n, real *a, integer *lda, 
+			     integer *jpvt, real *tau, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sgeqpf_(integer *m, integer *n, real *a, integer *lda, 
+			     integer *jpvt, real *tau, real *work, integer *info);
+
+/* Subroutine */ int sgeqr2_(integer *m, integer *n, real *a, integer *lda, 
+			     real *tau, real *work, integer *info);
+
+/* Subroutine */ int sgeqrf_(integer *m, integer *n, real *a, integer *lda, 
+			     real *tau, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sgerfs_(char *trans, integer *n, integer *nrhs, real *a, 
+			     integer *lda, real *af, integer *ldaf, integer *ipiv, real *b, 
+			     integer *ldb, real *x, integer *ldx, real *ferr, real *berr, real *
+			     work, integer *iwork, integer *info);
+
+/* Subroutine */ int sgerfsx_(char *trans, char *equed, integer *n, integer *
+			      nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, 
+			      real *r__, real *c__, real *b, integer *ldb, real *x, integer *ldx, 
+			      real *rcond, real *berr, integer *n_err_bnds__, real *err_bnds_norm__, 
+			      real *err_bnds_comp__, integer *nparams, real *params, real *work, 
+			      integer *iwork, integer *info);
+
+/* Subroutine */ int sgerq2_(integer *m, integer *n, real *a, integer *lda, 
+			     real *tau, real *work, integer *info);
+
+/* Subroutine */ int sgerqf_(integer *m, integer *n, real *a, integer *lda, 
+			     real *tau, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sgesc2_(integer *n, real *a, integer *lda, real *rhs, 
+			     integer *ipiv, integer *jpiv, real *scale);
+
+/* Subroutine */ int sgesdd_(char *jobz, integer *m, integer *n, real *a, 
+			     integer *lda, real *s, real *u, integer *ldu, real *vt, integer *ldvt, 
+			     real *work, integer *lwork, integer *iwork, integer *info);
+
+/* Subroutine */ int sgesv_(integer *n, integer *nrhs, real *a, integer *lda, 
+			    integer *ipiv, real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int sgesvd_(char *jobu, char *jobvt, integer *m, integer *n, 
+			     real *a, integer *lda, real *s, real *u, integer *ldu, real *vt, 
+			     integer *ldvt, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sgesvj_(char *joba, char *jobu, char *jobv, integer *m, 
+			     integer *n, real *a, integer *lda, real *sva, integer *mv, real *v, 
+			     integer *ldv, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sgesvx_(char *fact, char *trans, integer *n, integer *
+			     nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, 
+			     char *equed, real *r__, real *c__, real *b, integer *ldb, real *x, 
+			     integer *ldx, real *rcond, real *ferr, real *berr, real *work, 
+			     integer *iwork, integer *info);
+
+/* Subroutine */ int sgesvxx_(char *fact, char *trans, integer *n, integer *
+			      nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, 
+			      char *equed, real *r__, real *c__, real *b, integer *ldb, real *x, 
+			      integer *ldx, real *rcond, real *rpvgrw, real *berr, integer *
+			      n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, integer *
+			      nparams, real *params, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int sgetc2_(integer *n, real *a, integer *lda, integer *ipiv, 
+			     integer *jpiv, integer *info);
+
+/* Subroutine */ int sgetf2_(integer *m, integer *n, real *a, integer *lda, 
+			     integer *ipiv, integer *info);
+
+/* Subroutine */ int sgetrf_(integer *m, integer *n, real *a, integer *lda, 
+			     integer *ipiv, integer *info);
+
+/* Subroutine */ int sgetri_(integer *n, real *a, integer *lda, integer *ipiv, 
+			     real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sgetrs_(char *trans, integer *n, integer *nrhs, real *a, 
+			     integer *lda, integer *ipiv, real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int sggbak_(char *job, char *side, integer *n, integer *ilo, 
+			     integer *ihi, real *lscale, real *rscale, integer *m, real *v, 
+			     integer *ldv, integer *info);
+
+/* Subroutine */ int sggbal_(char *job, integer *n, real *a, integer *lda, 
+			     real *b, integer *ldb, integer *ilo, integer *ihi, real *lscale, real 
+			     *rscale, real *work, integer *info);
+
+/* Subroutine */ int sgges_(char *jobvsl, char *jobvsr, char *sort, L_fp 
+			    selctg, integer *n, real *a, integer *lda, real *b, integer *ldb, 
+			    integer *sdim, real *alphar, real *alphai, real *beta, real *vsl, 
+			    integer *ldvsl, real *vsr, integer *ldvsr, real *work, integer *lwork, 
+			    logical *bwork, integer *info);
+
+/* Subroutine */ int sggesx_(char *jobvsl, char *jobvsr, char *sort, L_fp 
+			     selctg, char *sense, integer *n, real *a, integer *lda, real *b, 
+			     integer *ldb, integer *sdim, real *alphar, real *alphai, real *beta, 
+			     real *vsl, integer *ldvsl, real *vsr, integer *ldvsr, real *rconde, 
+			     real *rcondv, real *work, integer *lwork, integer *iwork, integer *
+			     liwork, logical *bwork, integer *info);
+
+/* Subroutine */ int sggev_(char *jobvl, char *jobvr, integer *n, real *a, 
+			    integer *lda, real *b, integer *ldb, real *alphar, real *alphai, real 
+			    *beta, real *vl, integer *ldvl, real *vr, integer *ldvr, real *work, 
+			    integer *lwork, integer *info);
+
+/* Subroutine */ int sggevx_(char *balanc, char *jobvl, char *jobvr, char *
+			     sense, integer *n, real *a, integer *lda, real *b, integer *ldb, real 
+			     *alphar, real *alphai, real *beta, real *vl, integer *ldvl, real *vr, 
+			     integer *ldvr, integer *ilo, integer *ihi, real *lscale, real *rscale, 
+			     real *abnrm, real *bbnrm, real *rconde, real *rcondv, real *work, 
+			     integer *lwork, integer *iwork, logical *bwork, integer *info);
+
+/* Subroutine */ int sggglm_(integer *n, integer *m, integer *p, real *a, 
+			     integer *lda, real *b, integer *ldb, real *d__, real *x, real *y, 
+			     real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sgghrd_(char *compq, char *compz, integer *n, integer *
+			     ilo, integer *ihi, real *a, integer *lda, real *b, integer *ldb, real 
+			     *q, integer *ldq, real *z__, integer *ldz, integer *info);
+
+/* Subroutine */ int sgglse_(integer *m, integer *n, integer *p, real *a, 
+			     integer *lda, real *b, integer *ldb, real *c__, real *d__, real *x, 
+			     real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sggqrf_(integer *n, integer *m, integer *p, real *a, 
+			     integer *lda, real *taua, real *b, integer *ldb, real *taub, real *
+			     work, integer *lwork, integer *info);
+
+/* Subroutine */ int sggrqf_(integer *m, integer *p, integer *n, real *a, 
+			     integer *lda, real *taua, real *b, integer *ldb, real *taub, real *
+			     work, integer *lwork, integer *info);
+
+/* Subroutine */ int sggsvd_(char *jobu, char *jobv, char *jobq, integer *m, 
+			     integer *n, integer *p, integer *k, integer *l, real *a, integer *lda, 
+			     real *b, integer *ldb, real *alpha, real *beta, real *u, integer *
+			     ldu, real *v, integer *ldv, real *q, integer *ldq, real *work, 
+			     integer *iwork, integer *info);
+
+/* Subroutine */ int sggsvp_(char *jobu, char *jobv, char *jobq, integer *m, 
+			     integer *p, integer *n, real *a, integer *lda, real *b, integer *ldb, 
+			     real *tola, real *tolb, integer *k, integer *l, real *u, integer *ldu, 
+			     real *v, integer *ldv, real *q, integer *ldq, integer *iwork, real *
+			     tau, real *work, integer *info);
+
+/* Subroutine */ int sgsvj0_(char *jobv, integer *m, integer *n, real *a, 
+			     integer *lda, real *d__, real *sva, integer *mv, real *v, integer *
+			     ldv, real *eps, real *sfmin, real *tol, integer *nsweep, real *work, 
+			     integer *lwork, integer *info);
+
+/* Subroutine */ int sgsvj1_(char *jobv, integer *m, integer *n, integer *n1, 
+			     real *a, integer *lda, real *d__, real *sva, integer *mv, real *v, 
+			     integer *ldv, real *eps, real *sfmin, real *tol, integer *nsweep, 
+			     real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sgtcon_(char *norm, integer *n, real *dl, real *d__, 
+			     real *du, real *du2, integer *ipiv, real *anorm, real *rcond, real *
+			     work, integer *iwork, integer *info);
+
+/* Subroutine */ int sgtrfs_(char *trans, integer *n, integer *nrhs, real *dl, 
+			     real *d__, real *du, real *dlf, real *df, real *duf, real *du2, 
+			     integer *ipiv, real *b, integer *ldb, real *x, integer *ldx, real *
+			     ferr, real *berr, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int sgtsv_(integer *n, integer *nrhs, real *dl, real *d__, 
+			    real *du, real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int sgtsvx_(char *fact, char *trans, integer *n, integer *
+			     nrhs, real *dl, real *d__, real *du, real *dlf, real *df, real *duf, 
+			     real *du2, integer *ipiv, real *b, integer *ldb, real *x, integer *
+			     ldx, real *rcond, real *ferr, real *berr, real *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int sgttrf_(integer *n, real *dl, real *d__, real *du, real *
+			     du2, integer *ipiv, integer *info);
+
+/* Subroutine */ int sgttrs_(char *trans, integer *n, integer *nrhs, real *dl, 
+			     real *d__, real *du, real *du2, integer *ipiv, real *b, integer *ldb, 
+			     integer *info);
+
+/* Subroutine */ int sgtts2_(integer *itrans, integer *n, integer *nrhs, real 
+			     *dl, real *d__, real *du, real *du2, integer *ipiv, real *b, integer *
+			     ldb);
+
+/* Subroutine */ int shgeqz_(char *job, char *compq, char *compz, integer *n, 
+			     integer *ilo, integer *ihi, real *h__, integer *ldh, real *t, integer 
+			     *ldt, real *alphar, real *alphai, real *beta, real *q, integer *ldq, 
+			     real *z__, integer *ldz, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int shsein_(char *side, char *eigsrc, char *initv, logical *
+			     select, integer *n, real *h__, integer *ldh, real *wr, real *wi, real 
+			     *vl, integer *ldvl, real *vr, integer *ldvr, integer *mm, integer *m, 
+			     real *work, integer *ifaill, integer *ifailr, integer *info);
+
+/* Subroutine */ int shseqr_(char *job, char *compz, integer *n, integer *ilo, 
+			     integer *ihi, real *h__, integer *ldh, real *wr, real *wi, real *z__, 
+			     integer *ldz, real *work, integer *lwork, integer *info);
+
+logical sisnan_(real *sin__);
+
+/* Subroutine */ int sla_gbamv__(integer *trans, integer *m, integer *n, 
+				 integer *kl, integer *ku, real *alpha, real *ab, integer *ldab, real *
+				 x, integer *incx, real *beta, real *y, integer *incy);
+
+doublereal sla_gbrcond__(char *trans, integer *n, integer *kl, integer *ku, 
+			 real *ab, integer *ldab, real *afb, integer *ldafb, integer *ipiv, 
+			 integer *cmode, real *c__, integer *info, real *work, integer *iwork, 
+			 ftnlen trans_len);
+
+/* Subroutine */ int sla_gbrfsx_extended__(integer *prec_type__, integer *
+					   trans_type__, integer *n, integer *kl, integer *ku, integer *nrhs, 
+					   real *ab, integer *ldab, real *afb, integer *ldafb, integer *ipiv, 
+					   logical *colequ, real *c__, real *b, integer *ldb, real *y, integer *
+					   ldy, real *berr_out__, integer *n_norms__, real *errs_n__, real *
+					   errs_c__, real *res, real *ayb, real *dy, real *y_tail__, real *rcond,
+					   integer *ithresh, real *rthresh, real *dz_ub__, logical *
+					   ignore_cwise__, integer *info);
+
+doublereal sla_gbrpvgrw__(integer *n, integer *kl, integer *ku, integer *
+			  ncols, real *ab, integer *ldab, real *afb, integer *ldafb);
+
+/* Subroutine */ int sla_geamv__(integer *trans, integer *m, integer *n, real 
+				 *alpha, real *a, integer *lda, real *x, integer *incx, real *beta, 
+				 real *y, integer *incy);
+
+doublereal sla_gercond__(char *trans, integer *n, real *a, integer *lda, real 
+			 *af, integer *ldaf, integer *ipiv, integer *cmode, real *c__, integer 
+			 *info, real *work, integer *iwork, ftnlen trans_len);
+
+/* Subroutine */ int sla_gerfsx_extended__(integer *prec_type__, integer *
+					   trans_type__, integer *n, integer *nrhs, real *a, integer *lda, real *
+					   af, integer *ldaf, integer *ipiv, logical *colequ, real *c__, real *b,
+					   integer *ldb, real *y, integer *ldy, real *berr_out__, integer *
+					   n_norms__, real *errs_n__, real *errs_c__, real *res, real *ayb, real 
+					   *dy, real *y_tail__, real *rcond, integer *ithresh, real *rthresh, 
+					   real *dz_ub__, logical *ignore_cwise__, integer *info);
+
+/* Subroutine */ int sla_lin_berr__(integer *n, integer *nz, integer *nrhs, 
+				    real *res, real *ayb, real *berr);
+
+doublereal sla_porcond__(char *uplo, integer *n, real *a, integer *lda, real *
+			 af, integer *ldaf, integer *cmode, real *c__, integer *info, real *
+			 work, integer *iwork, ftnlen uplo_len);
+
+/* Subroutine */ int sla_porfsx_extended__(integer *prec_type__, char *uplo, 
+					   integer *n, integer *nrhs, real *a, integer *lda, real *af, integer *
+					   ldaf, logical *colequ, real *c__, real *b, integer *ldb, real *y, 
+					   integer *ldy, real *berr_out__, integer *n_norms__, real *errs_n__, 
+					   real *errs_c__, real *res, real *ayb, real *dy, real *y_tail__, real *
+					   rcond, integer *ithresh, real *rthresh, real *dz_ub__, logical *
+					   ignore_cwise__, integer *info, ftnlen uplo_len);
+
+doublereal sla_porpvgrw__(char *uplo, integer *ncols, real *a, integer *lda, 
+			  real *af, integer *ldaf, real *work, ftnlen uplo_len);
+
+doublereal sla_rpvgrw__(integer *n, integer *ncols, real *a, integer *lda, 
+			real *af, integer *ldaf);
+
+/* Subroutine */ int sla_syamv__(integer *uplo, integer *n, real *alpha, real 
+				 *a, integer *lda, real *x, integer *incx, real *beta, real *y, 
+				 integer *incy);
+
+doublereal sla_syrcond__(char *uplo, integer *n, real *a, integer *lda, real *
+			 af, integer *ldaf, integer *ipiv, integer *cmode, real *c__, integer *
+			 info, real *work, integer *iwork, ftnlen uplo_len);
+
+/* Subroutine */ int sla_syrfsx_extended__(integer *prec_type__, char *uplo, 
+					   integer *n, integer *nrhs, real *a, integer *lda, real *af, integer *
+					   ldaf, integer *ipiv, logical *colequ, real *c__, real *b, integer *
+					   ldb, real *y, integer *ldy, real *berr_out__, integer *n_norms__, 
+					   real *errs_n__, real *errs_c__, real *res, real *ayb, real *dy, real *
+					   y_tail__, real *rcond, integer *ithresh, real *rthresh, real *dz_ub__,
+					   logical *ignore_cwise__, integer *info, ftnlen uplo_len);
+
+doublereal sla_syrpvgrw__(char *uplo, integer *n, integer *info, real *a, 
+			  integer *lda, real *af, integer *ldaf, integer *ipiv, real *work, 
+			  ftnlen uplo_len);
+
+/* Subroutine */ int sla_wwaddw__(integer *n, real *x, real *y, real *w);
+
+/* Subroutine */ int slabad_(real *smallxx, real *large);
+
+/* Subroutine */ int slabrd_(integer *m, integer *n, integer *nb, real *a, 
+			     integer *lda, real *d__, real *e, real *tauq, real *taup, real *x, 
+			     integer *ldx, real *y, integer *ldy);
+
+/* Subroutine */ int slacn2_(integer *n, real *v, real *x, integer *isgn, 
+			     real *est, integer *kase, integer *isave);
+
+/* Subroutine */ int slacon_(integer *n, real *v, real *x, integer *isgn, 
+			     real *est, integer *kase);
+
+/* Subroutine */ int slacpy_(char *uplo, integer *m, integer *n, real *a, 
+			     integer *lda, real *b, integer *ldb);
+
+/* Subroutine */ int sladiv_(real *a, real *b, real *c__, real *d__, real *p, 
+			     real *q);
+
+/* Subroutine */ int slae2_(real *a, real *b, real *c__, real *rt1, real *rt2);
+
+/* Subroutine */ int slaebz_(integer *ijob, integer *nitmax, integer *n, 
+			     integer *mmax, integer *minp, integer *nbmin, real *abstol, real *
+			     reltol, real *pivmin, real *d__, real *e, real *e2, integer *nval, 
+			     real *ab, real *c__, integer *mout, integer *nab, real *work, integer 
+			     *iwork, integer *info);
+
+/* Subroutine */ int slaed0_(integer *icompq, integer *qsiz, integer *n, real 
+			     *d__, real *e, real *q, integer *ldq, real *qstore, integer *ldqs, 
+			     real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int slaed1_(integer *n, real *d__, real *q, integer *ldq, 
+			     integer *indxq, real *rho, integer *cutpnt, real *work, integer *
+			     iwork, integer *info);
+
+/* Subroutine */ int slaed2_(integer *k, integer *n, integer *n1, real *d__, 
+			     real *q, integer *ldq, integer *indxq, real *rho, real *z__, real *
+			     dlamda, real *w, real *q2, integer *indx, integer *indxc, integer *
+			     indxp, integer *coltyp, integer *info);
+
+/* Subroutine */ int slaed3_(integer *k, integer *n, integer *n1, real *d__, 
+			     real *q, integer *ldq, real *rho, real *dlamda, real *q2, integer *
+			     indx, integer *ctot, real *w, real *s, integer *info);
+
+/* Subroutine */ int slaed4_(integer *n, integer *i__, real *d__, real *z__, 
+			     real *delta, real *rho, real *dlam, integer *info);
+
+/* Subroutine */ int slaed5_(integer *i__, real *d__, real *z__, real *delta, 
+			     real *rho, real *dlam);
+
+/* Subroutine */ int slaed6_(integer *kniter, logical *orgati, real *rho, 
+			     real *d__, real *z__, real *finit, real *tau, integer *info);
+
+/* Subroutine */ int slaed7_(integer *icompq, integer *n, integer *qsiz, 
+			     integer *tlvls, integer *curlvl, integer *curpbm, real *d__, real *q, 
+			     integer *ldq, integer *indxq, real *rho, integer *cutpnt, real *
+			     qstore, integer *qptr, integer *prmptr, integer *perm, integer *
+			     givptr, integer *givcol, real *givnum, real *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int slaed8_(integer *icompq, integer *k, integer *n, integer 
+			     *qsiz, real *d__, real *q, integer *ldq, integer *indxq, real *rho, 
+			     integer *cutpnt, real *z__, real *dlamda, real *q2, integer *ldq2, 
+			     real *w, integer *perm, integer *givptr, integer *givcol, real *
+			     givnum, integer *indxp, integer *indx, integer *info);
+
+/* Subroutine */ int slaed9_(integer *k, integer *kstart, integer *kstop, 
+			     integer *n, real *d__, real *q, integer *ldq, real *rho, real *dlamda, 
+			     real *w, real *s, integer *lds, integer *info);
+
+/* Subroutine */ int slaeda_(integer *n, integer *tlvls, integer *curlvl, 
+			     integer *curpbm, integer *prmptr, integer *perm, integer *givptr, 
+			     integer *givcol, real *givnum, real *q, integer *qptr, real *z__, 
+			     real *ztemp, integer *info);
+
+/* Subroutine */ int slaein_(logical *rightv, logical *noinit, integer *n, 
+			     real *h__, integer *ldh, real *wr, real *wi, real *vr, real *vi, real 
+			     *b, integer *ldb, real *work, real *eps3, real *smlnum, real *bignum, 
+			     integer *info);
+
+/* Subroutine */ int slaev2_(real *a, real *b, real *c__, real *rt1, real *
+			     rt2, real *cs1, real *sn1);
+
+/* Subroutine */ int slaexc_(logical *wantq, integer *n, real *t, integer *
+			     ldt, real *q, integer *ldq, integer *j1, integer *n1, integer *n2, 
+			     real *work, integer *info);
+
+/* Subroutine */ int slag2_(real *a, integer *lda, real *b, integer *ldb, 
+			    real *safmin, real *scale1, real *scale2, real *wr1, real *wr2, real *
+			    wi);
+
+/* Subroutine */ int slag2d_(integer *m, integer *n, real *sa, integer *ldsa, 
+			     doublereal *a, integer *lda, integer *info);
+
+/* Subroutine */ int slags2_(logical *upper, real *a1, real *a2, real *a3, 
+			     real *b1, real *b2, real *b3, real *csu, real *snu, real *csv, real *
+			     snv, real *csq, real *snq);
+
+/* Subroutine */ int slagtf_(integer *n, real *a, real *lambda, real *b, real 
+			     *c__, real *tol, real *d__, integer *in, integer *info);
+
+/* Subroutine */ int slagtm_(char *trans, integer *n, integer *nrhs, real *
+			     alpha, real *dl, real *d__, real *du, real *x, integer *ldx, real *
+			     beta, real *b, integer *ldb);
+
+/* Subroutine */ int slagts_(integer *job, integer *n, real *a, real *b, real 
+			     *c__, real *d__, integer *in, real *y, real *tol, integer *info);
+
+/* Subroutine */ int slagv2_(real *a, integer *lda, real *b, integer *ldb, 
+			     real *alphar, real *alphai, real *beta, real *csl, real *snl, real *
+			     csr, real *snr);
+
+/* Subroutine */ int slahqr_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ilo, integer *ihi, real *h__, integer *ldh, real *wr, real *
+			     wi, integer *iloz, integer *ihiz, real *z__, integer *ldz, integer *
+			     info);
+
+/* Subroutine */ int slahr2_(integer *n, integer *k, integer *nb, real *a, 
+			     integer *lda, real *tau, real *t, integer *ldt, real *y, integer *ldy);
+
+/* Subroutine */ int slahrd_(integer *n, integer *k, integer *nb, real *a, 
+			     integer *lda, real *tau, real *t, integer *ldt, real *y, integer *ldy);
+
+/* Subroutine */ int slaic1_(integer *job, integer *j, real *x, real *sest, 
+			     real *w, real *gamma, real *sestpr, real *s, real *c__);
+
+logical slaisnan_(real *sin1, real *sin2);
+
+/* Subroutine */ int slaln2_(logical *ltrans, integer *na, integer *nw, real *
+			     smin, real *ca, real *a, integer *lda, real *d1, real *d2, real *b, 
+			     integer *ldb, real *wr, real *wi, real *x, integer *ldx, real *scale, 
+			     real *xnorm, integer *info);
+
+/* Subroutine */ int slals0_(integer *icompq, integer *nl, integer *nr, 
+			     integer *sqre, integer *nrhs, real *b, integer *ldb, real *bx, 
+			     integer *ldbx, integer *perm, integer *givptr, integer *givcol, 
+			     integer *ldgcol, real *givnum, integer *ldgnum, real *poles, real *
+			     difl, real *difr, real *z__, integer *k, real *c__, real *s, real *
+			     work, integer *info);
+
+/* Subroutine */ int slalsa_(integer *icompq, integer *smlsiz, integer *n, 
+			     integer *nrhs, real *b, integer *ldb, real *bx, integer *ldbx, real *
+			     u, integer *ldu, real *vt, integer *k, real *difl, real *difr, real *
+			     z__, real *poles, integer *givptr, integer *givcol, integer *ldgcol, 
+			     integer *perm, real *givnum, real *c__, real *s, real *work, integer *
+			     iwork, integer *info);
+
+/* Subroutine */ int slalsd_(char *uplo, integer *smlsiz, integer *n, integer 
+			     *nrhs, real *d__, real *e, real *b, integer *ldb, real *rcond, 
+			     integer *rank, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int slamrg_(integer *n1, integer *n2, real *a, integer *
+			     strd1, integer *strd2, integer *index);
+
+integer slaneg_(integer *n, real *d__, real *lld, real *sigma, real *pivmin, 
+		integer *r__);
+
+doublereal slangb_(char *norm, integer *n, integer *kl, integer *ku, real *ab, 
+		   integer *ldab, real *work);
+
+doublereal slange_(char *norm, integer *m, integer *n, real *a, integer *lda, 
+		   real *work);
+
+doublereal slangt_(char *norm, integer *n, real *dl, real *d__, real *du);
+
+doublereal slanhs_(char *norm, integer *n, real *a, integer *lda, real *work);
+
+doublereal slansb_(char *norm, char *uplo, integer *n, integer *k, real *ab, 
+		   integer *ldab, real *work);
+
+doublereal slansf_(char *norm, char *transr, char *uplo, integer *n, real *a, 
+		   real *work);
+
+doublereal slansp_(char *norm, char *uplo, integer *n, real *ap, real *work);
+
+doublereal slanst_(char *norm, integer *n, real *d__, real *e);
+
+doublereal slansy_(char *norm, char *uplo, integer *n, real *a, integer *lda, 
+		   real *work);
+
+doublereal slantb_(char *norm, char *uplo, char *diag, integer *n, integer *k, 
+		   real *ab, integer *ldab, real *work);
+
+doublereal slantp_(char *norm, char *uplo, char *diag, integer *n, real *ap, 
+		   real *work);
+
+doublereal slantr_(char *norm, char *uplo, char *diag, integer *m, integer *n, 
+		   real *a, integer *lda, real *work);
+
+/* Subroutine */ int slanv2_(real *a, real *b, real *c__, real *d__, real *
+			     rt1r, real *rt1i, real *rt2r, real *rt2i, real *cs, real *sn);
+
+/* Subroutine */ int slapll_(integer *n, real *x, integer *incx, real *y, 
+			     integer *incy, real *ssmin);
+
+/* Subroutine */ int slapmt_(logical *forwrd, integer *m, integer *n, real *x, 
+			     integer *ldx, integer *k);
+
+doublereal slapy2_(real *x, real *y);
+
+doublereal slapy3_(real *x, real *y, real *z__);
+
+/* Subroutine */ int slaqgb_(integer *m, integer *n, integer *kl, integer *ku, 
+			     real *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real *
+			     colcnd, real *amax, char *equed);
+
+/* Subroutine */ int slaqge_(integer *m, integer *n, real *a, integer *lda, 
+			     real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, char *
+			     equed);
+
+/* Subroutine */ int slaqp2_(integer *m, integer *n, integer *offset, real *a, 
+			     integer *lda, integer *jpvt, real *tau, real *vn1, real *vn2, real *
+			     work);
+
+/* Subroutine */ int slaqps_(integer *m, integer *n, integer *offset, integer 
+			     *nb, integer *kb, real *a, integer *lda, integer *jpvt, real *tau, 
+			     real *vn1, real *vn2, real *auxv, real *f, integer *ldf);
+
+/* Subroutine */ int slaqr0_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ilo, integer *ihi, real *h__, integer *ldh, real *wr, real *
+			     wi, integer *iloz, integer *ihiz, real *z__, integer *ldz, real *work, 
+			     integer *lwork, integer *info);
+
+/* Subroutine */ int slaqr1_(integer *n, real *h__, integer *ldh, real *sr1, 
+			     real *si1, real *sr2, real *si2, real *v);
+
+/* Subroutine */ int slaqr2_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ktop, integer *kbot, integer *nw, real *h__, integer *ldh, 
+			     integer *iloz, integer *ihiz, real *z__, integer *ldz, integer *ns, 
+			     integer *nd, real *sr, real *si, real *v, integer *ldv, integer *nh, 
+			     real *t, integer *ldt, integer *nv, real *wv, integer *ldwv, real *
+			     work, integer *lwork);
+
+/* Subroutine */ int slaqr3_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ktop, integer *kbot, integer *nw, real *h__, integer *ldh, 
+			     integer *iloz, integer *ihiz, real *z__, integer *ldz, integer *ns, 
+			     integer *nd, real *sr, real *si, real *v, integer *ldv, integer *nh, 
+			     real *t, integer *ldt, integer *nv, real *wv, integer *ldwv, real *
+			     work, integer *lwork);
+
+/* Subroutine */ int slaqr4_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ilo, integer *ihi, real *h__, integer *ldh, real *wr, real *
+			     wi, integer *iloz, integer *ihiz, real *z__, integer *ldz, real *work, 
+			     integer *lwork, integer *info);
+
+/* Subroutine */ int slaqr5_(logical *wantt, logical *wantz, integer *kacc22, 
+			     integer *n, integer *ktop, integer *kbot, integer *nshfts, real *sr, 
+			     real *si, real *h__, integer *ldh, integer *iloz, integer *ihiz, real 
+			     *z__, integer *ldz, real *v, integer *ldv, real *u, integer *ldu, 
+			     integer *nv, real *wv, integer *ldwv, integer *nh, real *wh, integer *
+			     ldwh);
+
+/* Subroutine */ int slaqsb_(char *uplo, integer *n, integer *kd, real *ab, 
+			     integer *ldab, real *s, real *scond, real *amax, char *equed);
+
+/* Subroutine */ int slaqsp_(char *uplo, integer *n, real *ap, real *s, real *
+			     scond, real *amax, char *equed);
+
+/* Subroutine */ int slaqsy_(char *uplo, integer *n, real *a, integer *lda, 
+			     real *s, real *scond, real *amax, char *equed);
+
+/* Subroutine */ int slaqtr_(logical *ltran, logical *lreal, integer *n, real 
+			     *t, integer *ldt, real *b, real *w, real *scale, real *x, real *work, 
+			     integer *info);
+
+/* Subroutine */ int slar1v_(integer *n, integer *b1, integer *bn, real *
+			     lambda, real *d__, real *l, real *ld, real *lld, real *pivmin, real *
+			     gaptol, real *z__, logical *wantnc, integer *negcnt, real *ztz, real *
+			     mingma, integer *r__, integer *isuppz, real *nrminv, real *resid, 
+			     real *rqcorr, real *work);
+
+/* Subroutine */ int slar2v_(integer *n, real *x, real *y, real *z__, integer 
+			     *incx, real *c__, real *s, integer *incc);
+
+/* Subroutine */ int slarf_(char *side, integer *m, integer *n, real *v, 
+			    integer *incv, real *tau, real *c__, integer *ldc, real *work);
+
+/* Subroutine */ int slarfb_(char *side, char *trans, char *direct, char *
+			     storev, integer *m, integer *n, integer *k, real *v, integer *ldv, 
+			     real *t, integer *ldt, real *c__, integer *ldc, real *work, integer *
+			     ldwork);
+
+/* Subroutine */ int slarfg_(integer *n, real *alpha, real *x, integer *incx, 
+			     real *tau);
+
+/* Subroutine */ int slarfp_(integer *n, real *alpha, real *x, integer *incx, 
+			     real *tau);
+
+/* Subroutine */ int slarft_(char *direct, char *storev, integer *n, integer *
+			     k, real *v, integer *ldv, real *tau, real *t, integer *ldt);
+
+/* Subroutine */ int slarfx_(char *side, integer *m, integer *n, real *v, 
+			     real *tau, real *c__, integer *ldc, real *work);
+
+/* Subroutine */ int slargv_(integer *n, real *x, integer *incx, real *y, 
+			     integer *incy, real *c__, integer *incc);
+
+/* Subroutine */ int slarnv_(integer *idist, integer *iseed, integer *n, real 
+			     *x);
+
+/* Subroutine */ int slarra_(integer *n, real *d__, real *e, real *e2, real *
+			     spltol, real *tnrm, integer *nsplit, integer *isplit, integer *info);
+
+/* Subroutine */ int slarrb_(integer *n, real *d__, real *lld, integer *
+			     ifirst, integer *ilast, real *rtol1, real *rtol2, integer *offset, 
+			     real *w, real *wgap, real *werr, real *work, integer *iwork, real *
+			     pivmin, real *spdiam, integer *twist, integer *info);
+
+/* Subroutine */ int slarrc_(char *jobt, integer *n, real *vl, real *vu, real 
+			     *d__, real *e, real *pivmin, integer *eigcnt, integer *lcnt, integer *
+			     rcnt, integer *info);
+
+/* Subroutine */ int slarrd_(char *range, char *order, integer *n, real *vl, 
+			     real *vu, integer *il, integer *iu, real *gers, real *reltol, real *
+			     d__, real *e, real *e2, real *pivmin, integer *nsplit, integer *
+			     isplit, integer *m, real *w, real *werr, real *wl, real *wu, integer *
+			     iblock, integer *indexw, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int slarre_(char *range, integer *n, real *vl, real *vu, 
+			     integer *il, integer *iu, real *d__, real *e, real *e2, real *rtol1, 
+			     real *rtol2, real *spltol, integer *nsplit, integer *isplit, integer *
+			     m, real *w, real *werr, real *wgap, integer *iblock, integer *indexw, 
+			     real *gers, real *pivmin, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int slarrf_(integer *n, real *d__, real *l, real *ld, 
+			     integer *clstrt, integer *clend, real *w, real *wgap, real *werr, 
+			     real *spdiam, real *clgapl, real *clgapr, real *pivmin, real *sigma, 
+			     real *dplus, real *lplus, real *work, integer *info);
+
+/* Subroutine */ int slarrj_(integer *n, real *d__, real *e2, integer *ifirst, 
+			     integer *ilast, real *rtol, integer *offset, real *w, real *werr, 
+			     real *work, integer *iwork, real *pivmin, real *spdiam, integer *info);
+
+/* Subroutine */ int slarrk_(integer *n, integer *iw, real *gl, real *gu, 
+			     real *d__, real *e2, real *pivmin, real *reltol, real *w, real *werr, 
+			     integer *info);
+
+/* Subroutine */ int slarrr_(integer *n, real *d__, real *e, integer *info);
+
+/* Subroutine */ int slarrv_(integer *n, real *vl, real *vu, real *d__, real *
+			     l, real *pivmin, integer *isplit, integer *m, integer *dol, integer *
+			     dou, real *minrgp, real *rtol1, real *rtol2, real *w, real *werr, 
+			     real *wgap, integer *iblock, integer *indexw, real *gers, real *z__, 
+			     integer *ldz, integer *isuppz, real *work, integer *iwork, integer *
+			     info);
+
+/* Subroutine */ int slarscl2_(integer *m, integer *n, real *d__, real *x, 
+			       integer *ldx);
+
+/* Subroutine */ int slartg_(real *f, real *g, real *cs, real *sn, real *r__);
+
+/* Subroutine */ int slartv_(integer *n, real *x, integer *incx, real *y, 
+			     integer *incy, real *c__, real *s, integer *incc);
+
+/* Subroutine */ int slaruv_(integer *iseed, integer *n, real *x);
+
+/* Subroutine */ int slarz_(char *side, integer *m, integer *n, integer *l, 
+			    real *v, integer *incv, real *tau, real *c__, integer *ldc, real *
+			    work);
+
+/* Subroutine */ int slarzb_(char *side, char *trans, char *direct, char *
+			     storev, integer *m, integer *n, integer *k, integer *l, real *v, 
+			     integer *ldv, real *t, integer *ldt, real *c__, integer *ldc, real *
+			     work, integer *ldwork);
+
+/* Subroutine */ int slarzt_(char *direct, char *storev, integer *n, integer *
+			     k, real *v, integer *ldv, real *tau, real *t, integer *ldt);
+
+/* Subroutine */ int slas2_(real *f, real *g, real *h__, real *ssmin, real *
+			    ssmax);
+
+/* Subroutine */ int slascl_(char *type__, integer *kl, integer *ku, real *
+			     cfrom, real *cto, integer *m, integer *n, real *a, integer *lda, 
+			     integer *info);
+
+/* Subroutine */ int slascl2_(integer *m, integer *n, real *d__, real *x, 
+			      integer *ldx);
+
+/* Subroutine */ int slasd0_(integer *n, integer *sqre, real *d__, real *e, 
+			     real *u, integer *ldu, real *vt, integer *ldvt, integer *smlsiz, 
+			     integer *iwork, real *work, integer *info);
+
+/* Subroutine */ int slasd1_(integer *nl, integer *nr, integer *sqre, real *
+			     d__, real *alpha, real *beta, real *u, integer *ldu, real *vt, 
+			     integer *ldvt, integer *idxq, integer *iwork, real *work, integer *
+			     info);
+
+/* Subroutine */ int slasd2_(integer *nl, integer *nr, integer *sqre, integer 
+			     *k, real *d__, real *z__, real *alpha, real *beta, real *u, integer *
+			     ldu, real *vt, integer *ldvt, real *dsigma, real *u2, integer *ldu2, 
+			     real *vt2, integer *ldvt2, integer *idxp, integer *idx, integer *idxc, 
+			     integer *idxq, integer *coltyp, integer *info);
+
+/* Subroutine */ int slasd3_(integer *nl, integer *nr, integer *sqre, integer 
+			     *k, real *d__, real *q, integer *ldq, real *dsigma, real *u, integer *
+			     ldu, real *u2, integer *ldu2, real *vt, integer *ldvt, real *vt2, 
+			     integer *ldvt2, integer *idxc, integer *ctot, real *z__, integer *
+			     info);
+
+/* Subroutine */ int slasd4_(integer *n, integer *i__, real *d__, real *z__, 
+			     real *delta, real *rho, real *sigma, real *work, integer *info);
+
+/* Subroutine */ int slasd5_(integer *i__, real *d__, real *z__, real *delta, 
+			     real *rho, real *dsigma, real *work);
+
+/* Subroutine */ int slasd6_(integer *icompq, integer *nl, integer *nr, 
+			     integer *sqre, real *d__, real *vf, real *vl, real *alpha, real *beta, 
+			     integer *idxq, integer *perm, integer *givptr, integer *givcol, 
+			     integer *ldgcol, real *givnum, integer *ldgnum, real *poles, real *
+			     difl, real *difr, real *z__, integer *k, real *c__, real *s, real *
+			     work, integer *iwork, integer *info);
+
+/* Subroutine */ int slasd7_(integer *icompq, integer *nl, integer *nr, 
+			     integer *sqre, integer *k, real *d__, real *z__, real *zw, real *vf, 
+			     real *vfw, real *vl, real *vlw, real *alpha, real *beta, real *dsigma, 
+			     integer *idx, integer *idxp, integer *idxq, integer *perm, integer *
+			     givptr, integer *givcol, integer *ldgcol, real *givnum, integer *
+			     ldgnum, real *c__, real *s, integer *info);
+
+/* Subroutine */ int slasd8_(integer *icompq, integer *k, real *d__, real *
+			     z__, real *vf, real *vl, real *difl, real *difr, integer *lddifr, 
+			     real *dsigma, real *work, integer *info);
+
+/* Subroutine */ int slasda_(integer *icompq, integer *smlsiz, integer *n, 
+			     integer *sqre, real *d__, real *e, real *u, integer *ldu, real *vt, 
+			     integer *k, real *difl, real *difr, real *z__, real *poles, integer *
+			     givptr, integer *givcol, integer *ldgcol, integer *perm, real *givnum, 
+			     real *c__, real *s, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int slasdq_(char *uplo, integer *sqre, integer *n, integer *
+			     ncvt, integer *nru, integer *ncc, real *d__, real *e, real *vt, 
+			     integer *ldvt, real *u, integer *ldu, real *c__, integer *ldc, real *
+			     work, integer *info);
+
+/* Subroutine */ int slasdt_(integer *n, integer *lvl, integer *nd, integer *
+			     inode, integer *ndiml, integer *ndimr, integer *msub);
+
+/* Subroutine */ int slaset_(char *uplo, integer *m, integer *n, real *alpha, 
+			     real *beta, real *a, integer *lda);
+
+/* Subroutine */ int slasq1_(integer *n, real *d__, real *e, real *work, 
+			     integer *info);
+
+/* Subroutine */ int slasq2_(integer *n, real *z__, integer *info);
+
+/* Subroutine */ int slasq3_(integer *i0, integer *n0, real *z__, integer *pp, 
+			     real *dmin__, real *sigma, real *desig, real *qmax, integer *nfail, 
+			     integer *iter, integer *ndiv, logical *ieee, integer *ttype, real *
+			     dmin1, real *dmin2, real *dn, real *dn1, real *dn2, real *g, real *
+			     tau);
+
+/* Subroutine */ int slasq4_(integer *i0, integer *n0, real *z__, integer *pp, 
+			     integer *n0in, real *dmin__, real *dmin1, real *dmin2, real *dn, 
+			     real *dn1, real *dn2, real *tau, integer *ttype, real *g);
+
+/* Subroutine */ int slasq5_(integer *i0, integer *n0, real *z__, integer *pp, 
+			     real *tau, real *dmin__, real *dmin1, real *dmin2, real *dn, real *
+			     dnm1, real *dnm2, logical *ieee);
+
+/* Subroutine */ int slasq6_(integer *i0, integer *n0, real *z__, integer *pp, 
+			     real *dmin__, real *dmin1, real *dmin2, real *dn, real *dnm1, real *
+			     dnm2);
+
+/* Subroutine */ int slasr_(char *side, char *pivot, char *direct, integer *m, 
+			    integer *n, real *c__, real *s, real *a, integer *lda);
+
+/* Subroutine */ int slasrt_(char *id, integer *n, real *d__, integer *info);
+
+/* Subroutine */ int slassq_(integer *n, real *x, integer *incx, real *scale, 
+			     real *sumsq);
+
+/* Subroutine */ int slasv2_(real *f, real *g, real *h__, real *ssmin, real *
+			     ssmax, real *snr, real *csr, real *snl, real *csl);
+
+/* Subroutine */ int slaswp_(integer *n, real *a, integer *lda, integer *k1, 
+			     integer *k2, integer *ipiv, integer *incx);
+
+/* Subroutine */ int slasy2_(logical *ltranl, logical *ltranr, integer *isgn, 
+			     integer *n1, integer *n2, real *tl, integer *ldtl, real *tr, integer *
+			     ldtr, real *b, integer *ldb, real *scale, real *x, integer *ldx, real 
+			     *xnorm, integer *info);
+
+/* Subroutine */ int slasyf_(char *uplo, integer *n, integer *nb, integer *kb, 
+			     real *a, integer *lda, integer *ipiv, real *w, integer *ldw, integer 
+			     *info);
+
+/* Subroutine */ int slatbs_(char *uplo, char *trans, char *diag, char *
+			     normin, integer *n, integer *kd, real *ab, integer *ldab, real *x, 
+			     real *scale, real *cnorm, integer *info);
+
+/* Subroutine */ int slatdf_(integer *ijob, integer *n, real *z__, integer *
+			     ldz, real *rhs, real *rdsum, real *rdscal, integer *ipiv, integer *
+			     jpiv);
+
+/* Subroutine */ int slatps_(char *uplo, char *trans, char *diag, char *
+			     normin, integer *n, real *ap, real *x, real *scale, real *cnorm, 
+			     integer *info);
+
+/* Subroutine */ int slatrd_(char *uplo, integer *n, integer *nb, real *a, 
+			     integer *lda, real *e, real *tau, real *w, integer *ldw);
+
+/* Subroutine */ int slatrs_(char *uplo, char *trans, char *diag, char *
+			     normin, integer *n, real *a, integer *lda, real *x, real *scale, real 
+			     *cnorm, integer *info);
+
+/* Subroutine */ int slatrz_(integer *m, integer *n, integer *l, real *a, 
+			     integer *lda, real *tau, real *work);
+
+/* Subroutine */ int slatzm_(char *side, integer *m, integer *n, real *v, 
+			     integer *incv, real *tau, real *c1, real *c2, integer *ldc, real *
+			     work);
+
+/* Subroutine */ int slauu2_(char *uplo, integer *n, real *a, integer *lda, 
+			     integer *info);
+
+/* Subroutine */ int slauum_(char *uplo, integer *n, real *a, integer *lda, 
+			     integer *info);
+
+/* Subroutine */ int sopgtr_(char *uplo, integer *n, real *ap, real *tau, 
+			     real *q, integer *ldq, real *work, integer *info);
+
+/* Subroutine */ int sopmtr_(char *side, char *uplo, char *trans, integer *m, 
+			     integer *n, real *ap, real *tau, real *c__, integer *ldc, real *work, 
+			     integer *info);
+
+/* Subroutine */ int sorg2l_(integer *m, integer *n, integer *k, real *a, 
+			     integer *lda, real *tau, real *work, integer *info);
+
+/* Subroutine */ int sorg2r_(integer *m, integer *n, integer *k, real *a, 
+			     integer *lda, real *tau, real *work, integer *info);
+
+/* Subroutine */ int sorgbr_(char *vect, integer *m, integer *n, integer *k, 
+			     real *a, integer *lda, real *tau, real *work, integer *lwork, integer 
+			     *info);
+
+/* Subroutine */ int sorghr_(integer *n, integer *ilo, integer *ihi, real *a, 
+			     integer *lda, real *tau, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sorgl2_(integer *m, integer *n, integer *k, real *a, 
+			     integer *lda, real *tau, real *work, integer *info);
+
+/* Subroutine */ int sorglq_(integer *m, integer *n, integer *k, real *a, 
+			     integer *lda, real *tau, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sorgql_(integer *m, integer *n, integer *k, real *a, 
+			     integer *lda, real *tau, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sorgqr_(integer *m, integer *n, integer *k, real *a, 
+			     integer *lda, real *tau, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sorgr2_(integer *m, integer *n, integer *k, real *a, 
+			     integer *lda, real *tau, real *work, integer *info);
+
+/* Subroutine */ int sorgrq_(integer *m, integer *n, integer *k, real *a, 
+			     integer *lda, real *tau, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sorgtr_(char *uplo, integer *n, real *a, integer *lda, 
+			     real *tau, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sorm2l_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, 
+			     real *work, integer *info);
+
+/* Subroutine */ int sorm2r_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, 
+			     real *work, integer *info);
+
+/* Subroutine */ int sormbr_(char *vect, char *side, char *trans, integer *m, 
+			     integer *n, integer *k, real *a, integer *lda, real *tau, real *c__, 
+			     integer *ldc, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sormhr_(char *side, char *trans, integer *m, integer *n, 
+			     integer *ilo, integer *ihi, real *a, integer *lda, real *tau, real *
+			     c__, integer *ldc, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sorml2_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, 
+			     real *work, integer *info);
+
+/* Subroutine */ int sormlq_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, 
+			     real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sormql_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, 
+			     real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sormqr_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, 
+			     real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sormr2_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, 
+			     real *work, integer *info);
+
+/* Subroutine */ int sormr3_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, integer *l, real *a, integer *lda, real *tau, real *c__, 
+			     integer *ldc, real *work, integer *info);
+
+/* Subroutine */ int sormrq_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, 
+			     real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sormrz_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, integer *l, real *a, integer *lda, real *tau, real *c__, 
+			     integer *ldc, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int sormtr_(char *side, char *uplo, char *trans, integer *m, 
+			     integer *n, real *a, integer *lda, real *tau, real *c__, integer *ldc, 
+			     real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int spbcon_(char *uplo, integer *n, integer *kd, real *ab, 
+			     integer *ldab, real *anorm, real *rcond, real *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int spbequ_(char *uplo, integer *n, integer *kd, real *ab, 
+			     integer *ldab, real *s, real *scond, real *amax, integer *info);
+
+/* Subroutine */ int spbrfs_(char *uplo, integer *n, integer *kd, integer *
+			     nrhs, real *ab, integer *ldab, real *afb, integer *ldafb, real *b, 
+			     integer *ldb, real *x, integer *ldx, real *ferr, real *berr, real *
+			     work, integer *iwork, integer *info);
+
+/* Subroutine */ int spbstf_(char *uplo, integer *n, integer *kd, real *ab, 
+			     integer *ldab, integer *info);
+
+/* Subroutine */ int spbsv_(char *uplo, integer *n, integer *kd, integer *
+			    nrhs, real *ab, integer *ldab, real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int spbsvx_(char *fact, char *uplo, integer *n, integer *kd, 
+			     integer *nrhs, real *ab, integer *ldab, real *afb, integer *ldafb, 
+			     char *equed, real *s, real *b, integer *ldb, real *x, integer *ldx, 
+			     real *rcond, real *ferr, real *berr, real *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int spbtf2_(char *uplo, integer *n, integer *kd, real *ab, 
+			     integer *ldab, integer *info);
+
+/* Subroutine */ int spbtrf_(char *uplo, integer *n, integer *kd, real *ab, 
+			     integer *ldab, integer *info);
+
+/* Subroutine */ int spbtrs_(char *uplo, integer *n, integer *kd, integer *
+			     nrhs, real *ab, integer *ldab, real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int spftrf_(char *transr, char *uplo, integer *n, real *a, 
+			     integer *info);
+
+/* Subroutine */ int spftri_(char *transr, char *uplo, integer *n, real *a, 
+			     integer *info);
+
+/* Subroutine */ int spftrs_(char *transr, char *uplo, integer *n, integer *
+			     nrhs, real *a, real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int spocon_(char *uplo, integer *n, real *a, integer *lda, 
+			     real *anorm, real *rcond, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int spoequ_(integer *n, real *a, integer *lda, real *s, real 
+			     *scond, real *amax, integer *info);
+
+/* Subroutine */ int spoequb_(integer *n, real *a, integer *lda, real *s, 
+			      real *scond, real *amax, integer *info);
+
+/* Subroutine */ int sporfs_(char *uplo, integer *n, integer *nrhs, real *a, 
+			     integer *lda, real *af, integer *ldaf, real *b, integer *ldb, real *x, 
+			     integer *ldx, real *ferr, real *berr, real *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int sporfsx_(char *uplo, char *equed, integer *n, integer *
+			      nrhs, real *a, integer *lda, real *af, integer *ldaf, real *s, real *
+			      b, integer *ldb, real *x, integer *ldx, real *rcond, real *berr, 
+			      integer *n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, 
+			      integer *nparams, real *params, real *work, integer *iwork, integer *
+			      info);
+
+/* Subroutine */ int sposv_(char *uplo, integer *n, integer *nrhs, real *a, 
+			    integer *lda, real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int sposvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, real *a, integer *lda, real *af, integer *ldaf, char *equed, 
+			     real *s, real *b, integer *ldb, real *x, integer *ldx, real *rcond, 
+			     real *ferr, real *berr, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int sposvxx_(char *fact, char *uplo, integer *n, integer *
+			      nrhs, real *a, integer *lda, real *af, integer *ldaf, char *equed, 
+			      real *s, real *b, integer *ldb, real *x, integer *ldx, real *rcond, 
+			      real *rpvgrw, real *berr, integer *n_err_bnds__, real *
+			      err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real *
+			      params, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int spotf2_(char *uplo, integer *n, real *a, integer *lda, 
+			     integer *info);
+
+/* Subroutine */ int spotrf_(char *uplo, integer *n, real *a, integer *lda, 
+			     integer *info);
+
+/* Subroutine */ int spotri_(char *uplo, integer *n, real *a, integer *lda, 
+			     integer *info);
+
+/* Subroutine */ int spotrs_(char *uplo, integer *n, integer *nrhs, real *a, 
+			     integer *lda, real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int sppcon_(char *uplo, integer *n, real *ap, real *anorm, 
+			     real *rcond, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int sppequ_(char *uplo, integer *n, real *ap, real *s, real *
+			     scond, real *amax, integer *info);
+
+/* Subroutine */ int spprfs_(char *uplo, integer *n, integer *nrhs, real *ap, 
+			     real *afp, real *b, integer *ldb, real *x, integer *ldx, real *ferr, 
+			     real *berr, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int sppsv_(char *uplo, integer *n, integer *nrhs, real *ap, 
+			    real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int sppsvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, real *ap, real *afp, char *equed, real *s, real *b, integer *
+			     ldb, real *x, integer *ldx, real *rcond, real *ferr, real *berr, real 
+			     *work, integer *iwork, integer *info);
+
+/* Subroutine */ int spptrf_(char *uplo, integer *n, real *ap, integer *info);
+
+/* Subroutine */ int spptri_(char *uplo, integer *n, real *ap, integer *info);
+
+/* Subroutine */ int spptrs_(char *uplo, integer *n, integer *nrhs, real *ap, 
+			     real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int spstf2_(char *uplo, integer *n, real *a, integer *lda, 
+			     integer *piv, integer *rank, real *tol, real *work, integer *info);
+
+/* Subroutine */ int spstrf_(char *uplo, integer *n, real *a, integer *lda, 
+			     integer *piv, integer *rank, real *tol, real *work, integer *info);
+
+/* Subroutine */ int sptcon_(integer *n, real *d__, real *e, real *anorm, 
+			     real *rcond, real *work, integer *info);
+
+/* Subroutine */ int spteqr_(char *compz, integer *n, real *d__, real *e, 
+			     real *z__, integer *ldz, real *work, integer *info);
+
+/* Subroutine */ int sptrfs_(integer *n, integer *nrhs, real *d__, real *e, 
+			     real *df, real *ef, real *b, integer *ldb, real *x, integer *ldx, 
+			     real *ferr, real *berr, real *work, integer *info);
+
+/* Subroutine */ int sptsv_(integer *n, integer *nrhs, real *d__, real *e, 
+			    real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int sptsvx_(char *fact, integer *n, integer *nrhs, real *d__, 
+			     real *e, real *df, real *ef, real *b, integer *ldb, real *x, integer 
+			     *ldx, real *rcond, real *ferr, real *berr, real *work, integer *info);
+
+/* Subroutine */ int spttrf_(integer *n, real *d__, real *e, integer *info);
+
+/* Subroutine */ int spttrs_(integer *n, integer *nrhs, real *d__, real *e, 
+			     real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int sptts2_(integer *n, integer *nrhs, real *d__, real *e, 
+			     real *b, integer *ldb);
+
+/* Subroutine */ int srscl_(integer *n, real *sa, real *sx, integer *incx);
+
+/* Subroutine */ int ssbev_(char *jobz, char *uplo, integer *n, integer *kd, 
+			    real *ab, integer *ldab, real *w, real *z__, integer *ldz, real *work, 
+			    integer *info);
+
+/* Subroutine */ int ssbevd_(char *jobz, char *uplo, integer *n, integer *kd, 
+			     real *ab, integer *ldab, real *w, real *z__, integer *ldz, real *work, 
+			     integer *lwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int ssbevx_(char *jobz, char *range, char *uplo, integer *n, 
+			     integer *kd, real *ab, integer *ldab, real *q, integer *ldq, real *vl, 
+			     real *vu, integer *il, integer *iu, real *abstol, integer *m, real *
+			     w, real *z__, integer *ldz, real *work, integer *iwork, integer *
+			     ifail, integer *info);
+
+/* Subroutine */ int ssbgst_(char *vect, char *uplo, integer *n, integer *ka, 
+			     integer *kb, real *ab, integer *ldab, real *bb, integer *ldbb, real *
+			     x, integer *ldx, real *work, integer *info);
+
+/* Subroutine */ int ssbgv_(char *jobz, char *uplo, integer *n, integer *ka, 
+			    integer *kb, real *ab, integer *ldab, real *bb, integer *ldbb, real *
+			    w, real *z__, integer *ldz, real *work, integer *info);
+
+/* Subroutine */ int ssbgvd_(char *jobz, char *uplo, integer *n, integer *ka, 
+			     integer *kb, real *ab, integer *ldab, real *bb, integer *ldbb, real *
+			     w, real *z__, integer *ldz, real *work, integer *lwork, integer *
+			     iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int ssbgvx_(char *jobz, char *range, char *uplo, integer *n, 
+			     integer *ka, integer *kb, real *ab, integer *ldab, real *bb, integer *
+			     ldbb, real *q, integer *ldq, real *vl, real *vu, integer *il, integer 
+			     *iu, real *abstol, integer *m, real *w, real *z__, integer *ldz, real 
+			     *work, integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int ssbtrd_(char *vect, char *uplo, integer *n, integer *kd, 
+			     real *ab, integer *ldab, real *d__, real *e, real *q, integer *ldq, 
+			     real *work, integer *info);
+
+/* Subroutine */ int ssfrk_(char *transr, char *uplo, char *trans, integer *n, 
+			    integer *k, real *alpha, real *a, integer *lda, real *beta, real *
+			    c__);
+
+/* Subroutine */ int sspcon_(char *uplo, integer *n, real *ap, integer *ipiv, 
+			     real *anorm, real *rcond, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int sspev_(char *jobz, char *uplo, integer *n, real *ap, 
+			    real *w, real *z__, integer *ldz, real *work, integer *info);
+
+/* Subroutine */ int sspevd_(char *jobz, char *uplo, integer *n, real *ap, 
+			     real *w, real *z__, integer *ldz, real *work, integer *lwork, integer 
+			     *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int sspevx_(char *jobz, char *range, char *uplo, integer *n, 
+			     real *ap, real *vl, real *vu, integer *il, integer *iu, real *abstol, 
+			     integer *m, real *w, real *z__, integer *ldz, real *work, integer *
+			     iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int sspgst_(integer *itype, char *uplo, integer *n, real *ap, 
+			     real *bp, integer *info);
+
+/* Subroutine */ int sspgv_(integer *itype, char *jobz, char *uplo, integer *
+			    n, real *ap, real *bp, real *w, real *z__, integer *ldz, real *work, 
+			    integer *info);
+
+/* Subroutine */ int sspgvd_(integer *itype, char *jobz, char *uplo, integer *
+			     n, real *ap, real *bp, real *w, real *z__, integer *ldz, real *work, 
+			     integer *lwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int sspgvx_(integer *itype, char *jobz, char *range, char *
+			     uplo, integer *n, real *ap, real *bp, real *vl, real *vu, integer *il, 
+			     integer *iu, real *abstol, integer *m, real *w, real *z__, integer *
+			     ldz, real *work, integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int ssprfs_(char *uplo, integer *n, integer *nrhs, real *ap, 
+			     real *afp, integer *ipiv, real *b, integer *ldb, real *x, integer *
+			     ldx, real *ferr, real *berr, real *work, integer *iwork, integer *
+			     info);
+
+/* Subroutine */ int sspsv_(char *uplo, integer *n, integer *nrhs, real *ap, 
+			    integer *ipiv, real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int sspsvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, real *ap, real *afp, integer *ipiv, real *b, integer *ldb, real 
+			     *x, integer *ldx, real *rcond, real *ferr, real *berr, real *work, 
+			     integer *iwork, integer *info);
+
+/* Subroutine */ int ssptrd_(char *uplo, integer *n, real *ap, real *d__, 
+			     real *e, real *tau, integer *info);
+
+/* Subroutine */ int ssptrf_(char *uplo, integer *n, real *ap, integer *ipiv, 
+			     integer *info);
+
+/* Subroutine */ int ssptri_(char *uplo, integer *n, real *ap, integer *ipiv, 
+			     real *work, integer *info);
+
+/* Subroutine */ int ssptrs_(char *uplo, integer *n, integer *nrhs, real *ap, 
+			     integer *ipiv, real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int sstebz_(char *range, char *order, integer *n, real *vl, 
+			     real *vu, integer *il, integer *iu, real *abstol, real *d__, real *e, 
+			     integer *m, integer *nsplit, real *w, integer *iblock, integer *
+			     isplit, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int sstedc_(char *compz, integer *n, real *d__, real *e, 
+			     real *z__, integer *ldz, real *work, integer *lwork, integer *iwork, 
+			     integer *liwork, integer *info);
+
+/* Subroutine */ int sstegr_(char *jobz, char *range, integer *n, real *d__, 
+			     real *e, real *vl, real *vu, integer *il, integer *iu, real *abstol, 
+			     integer *m, real *w, real *z__, integer *ldz, integer *isuppz, real *
+			     work, integer *lwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int sstein_(integer *n, real *d__, real *e, integer *m, real 
+			     *w, integer *iblock, integer *isplit, real *z__, integer *ldz, real *
+			     work, integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int sstemr_(char *jobz, char *range, integer *n, real *d__, 
+			     real *e, real *vl, real *vu, integer *il, integer *iu, integer *m, 
+			     real *w, real *z__, integer *ldz, integer *nzc, integer *isuppz, 
+			     logical *tryrac, real *work, integer *lwork, integer *iwork, integer *
+			     liwork, integer *info);
+
+/* Subroutine */ int ssteqr_(char *compz, integer *n, real *d__, real *e, 
+			     real *z__, integer *ldz, real *work, integer *info);
+
+/* Subroutine */ int ssterf_(integer *n, real *d__, real *e, integer *info);
+
+/* Subroutine */ int sstev_(char *jobz, integer *n, real *d__, real *e, real *
+			    z__, integer *ldz, real *work, integer *info);
+
+/* Subroutine */ int sstevd_(char *jobz, integer *n, real *d__, real *e, real 
+			     *z__, integer *ldz, real *work, integer *lwork, integer *iwork, 
+			     integer *liwork, integer *info);
+
+/* Subroutine */ int sstevr_(char *jobz, char *range, integer *n, real *d__, 
+			     real *e, real *vl, real *vu, integer *il, integer *iu, real *abstol, 
+			     integer *m, real *w, real *z__, integer *ldz, integer *isuppz, real *
+			     work, integer *lwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int sstevx_(char *jobz, char *range, integer *n, real *d__, 
+			     real *e, real *vl, real *vu, integer *il, integer *iu, real *abstol, 
+			     integer *m, real *w, real *z__, integer *ldz, real *work, integer *
+			     iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int ssycon_(char *uplo, integer *n, real *a, integer *lda, 
+			     integer *ipiv, real *anorm, real *rcond, real *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int ssyequb_(char *uplo, integer *n, real *a, integer *lda, 
+			      real *s, real *scond, real *amax, real *work, integer *info);
+
+/* Subroutine */ int ssyev_(char *jobz, char *uplo, integer *n, real *a, 
+			    integer *lda, real *w, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int ssyevd_(char *jobz, char *uplo, integer *n, real *a, 
+			     integer *lda, real *w, real *work, integer *lwork, integer *iwork, 
+			     integer *liwork, integer *info);
+
+/* Subroutine */ int ssyevr_(char *jobz, char *range, char *uplo, integer *n, 
+			     real *a, integer *lda, real *vl, real *vu, integer *il, integer *iu, 
+			     real *abstol, integer *m, real *w, real *z__, integer *ldz, integer *
+			     isuppz, real *work, integer *lwork, integer *iwork, integer *liwork, 
+			     integer *info);
+
+/* Subroutine */ int ssyevx_(char *jobz, char *range, char *uplo, integer *n, 
+			     real *a, integer *lda, real *vl, real *vu, integer *il, integer *iu, 
+			     real *abstol, integer *m, real *w, real *z__, integer *ldz, real *
+			     work, integer *lwork, integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int ssygs2_(integer *itype, char *uplo, integer *n, real *a, 
+			     integer *lda, real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int ssygst_(integer *itype, char *uplo, integer *n, real *a, 
+			     integer *lda, real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int ssygv_(integer *itype, char *jobz, char *uplo, integer *
+			    n, real *a, integer *lda, real *b, integer *ldb, real *w, real *work, 
+			    integer *lwork, integer *info);
+
+/* Subroutine */ int ssygvd_(integer *itype, char *jobz, char *uplo, integer *
+			     n, real *a, integer *lda, real *b, integer *ldb, real *w, real *work, 
+			     integer *lwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int ssygvx_(integer *itype, char *jobz, char *range, char *
+			     uplo, integer *n, real *a, integer *lda, real *b, integer *ldb, real *
+			     vl, real *vu, integer *il, integer *iu, real *abstol, integer *m, 
+			     real *w, real *z__, integer *ldz, real *work, integer *lwork, integer 
+			     *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int ssyrfs_(char *uplo, integer *n, integer *nrhs, real *a, 
+			     integer *lda, real *af, integer *ldaf, integer *ipiv, real *b, 
+			     integer *ldb, real *x, integer *ldx, real *ferr, real *berr, real *
+			     work, integer *iwork, integer *info);
+
+/* Subroutine */ int ssyrfsx_(char *uplo, char *equed, integer *n, integer *
+			      nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, 
+			      real *s, real *b, integer *ldb, real *x, integer *ldx, real *rcond, 
+			      real *berr, integer *n_err_bnds__, real *err_bnds_norm__, real *
+			      err_bnds_comp__, integer *nparams, real *params, real *work, integer *
+			      iwork, integer *info);
+
+/* Subroutine */ int ssysv_(char *uplo, integer *n, integer *nrhs, real *a, 
+			    integer *lda, integer *ipiv, real *b, integer *ldb, real *work, 
+			    integer *lwork, integer *info);
+
+/* Subroutine */ int ssysvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, 
+			     real *b, integer *ldb, real *x, integer *ldx, real *rcond, real *ferr, 
+			     real *berr, real *work, integer *lwork, integer *iwork, integer *
+			     info);
+
+/* Subroutine */ int ssysvxx_(char *fact, char *uplo, integer *n, integer *
+			      nrhs, real *a, integer *lda, real *af, integer *ldaf, integer *ipiv, 
+			      char *equed, real *s, real *b, integer *ldb, real *x, integer *ldx, 
+			      real *rcond, real *rpvgrw, real *berr, integer *n_err_bnds__, real *
+			      err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real *
+			      params, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int ssytd2_(char *uplo, integer *n, real *a, integer *lda, 
+			     real *d__, real *e, real *tau, integer *info);
+
+/* Subroutine */ int ssytf2_(char *uplo, integer *n, real *a, integer *lda, 
+			     integer *ipiv, integer *info);
+
+/* Subroutine */ int ssytrd_(char *uplo, integer *n, real *a, integer *lda, 
+			     real *d__, real *e, real *tau, real *work, integer *lwork, integer *
+			     info);
+
+/* Subroutine */ int ssytrf_(char *uplo, integer *n, real *a, integer *lda, 
+			     integer *ipiv, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int ssytri_(char *uplo, integer *n, real *a, integer *lda, 
+			     integer *ipiv, real *work, integer *info);
+
+/* Subroutine */ int ssytrs_(char *uplo, integer *n, integer *nrhs, real *a, 
+			     integer *lda, integer *ipiv, real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int stbcon_(char *norm, char *uplo, char *diag, integer *n, 
+			     integer *kd, real *ab, integer *ldab, real *rcond, real *work, 
+			     integer *iwork, integer *info);
+
+/* Subroutine */ int stbrfs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *kd, integer *nrhs, real *ab, integer *ldab, real *b, integer 
+			     *ldb, real *x, integer *ldx, real *ferr, real *berr, real *work, 
+			     integer *iwork, integer *info);
+
+/* Subroutine */ int stbtrs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *kd, integer *nrhs, real *ab, integer *ldab, real *b, integer 
+			     *ldb, integer *info);
+
+/* Subroutine */ int stfsm_(char *transr, char *side, char *uplo, char *trans, 
+			    char *diag, integer *m, integer *n, real *alpha, real *a, real *b, 
+			    integer *ldb);
+
+/* Subroutine */ int stftri_(char *transr, char *uplo, char *diag, integer *n, 
+			     real *a, integer *info);
+
+/* Subroutine */ int stfttp_(char *transr, char *uplo, integer *n, real *arf, 
+			     real *ap, integer *info);
+
+/* Subroutine */ int stfttr_(char *transr, char *uplo, integer *n, real *arf, 
+			     real *a, integer *lda, integer *info);
+
+/* Subroutine */ int stgevc_(char *side, char *howmny, logical *select, 
+			     integer *n, real *s, integer *lds, real *p, integer *ldp, real *vl, 
+			     integer *ldvl, real *vr, integer *ldvr, integer *mm, integer *m, real 
+			     *work, integer *info);
+
+/* Subroutine */ int stgex2_(logical *wantq, logical *wantz, integer *n, real 
+			     *a, integer *lda, real *b, integer *ldb, real *q, integer *ldq, real *
+			     z__, integer *ldz, integer *j1, integer *n1, integer *n2, real *work, 
+			     integer *lwork, integer *info);
+
+/* Subroutine */ int stgexc_(logical *wantq, logical *wantz, integer *n, real 
+			     *a, integer *lda, real *b, integer *ldb, real *q, integer *ldq, real *
+			     z__, integer *ldz, integer *ifst, integer *ilst, real *work, integer *
+			     lwork, integer *info);
+
+/* Subroutine */ int stgsen_(integer *ijob, logical *wantq, logical *wantz, 
+			     logical *select, integer *n, real *a, integer *lda, real *b, integer *
+			     ldb, real *alphar, real *alphai, real *beta, real *q, integer *ldq, 
+			     real *z__, integer *ldz, integer *m, real *pl, real *pr, real *dif, 
+			     real *work, integer *lwork, integer *iwork, integer *liwork, integer *
+			     info);
+
+/* Subroutine */ int stgsja_(char *jobu, char *jobv, char *jobq, integer *m, 
+			     integer *p, integer *n, integer *k, integer *l, real *a, integer *lda, 
+			     real *b, integer *ldb, real *tola, real *tolb, real *alpha, real *
+			     beta, real *u, integer *ldu, real *v, integer *ldv, real *q, integer *
+			     ldq, real *work, integer *ncycle, integer *info);
+
+/* Subroutine */ int stgsna_(char *job, char *howmny, logical *select, 
+			     integer *n, real *a, integer *lda, real *b, integer *ldb, real *vl, 
+			     integer *ldvl, real *vr, integer *ldvr, real *s, real *dif, integer *
+			     mm, integer *m, real *work, integer *lwork, integer *iwork, integer *
+			     info);
+
+/* Subroutine */ int stgsy2_(char *trans, integer *ijob, integer *m, integer *
+			     n, real *a, integer *lda, real *b, integer *ldb, real *c__, integer *
+			     ldc, real *d__, integer *ldd, real *e, integer *lde, real *f, integer 
+			     *ldf, real *scale, real *rdsum, real *rdscal, integer *iwork, integer 
+			     *pq, integer *info);
+
+/* Subroutine */ int stgsyl_(char *trans, integer *ijob, integer *m, integer *
+			     n, real *a, integer *lda, real *b, integer *ldb, real *c__, integer *
+			     ldc, real *d__, integer *ldd, real *e, integer *lde, real *f, integer 
+			     *ldf, real *scale, real *dif, real *work, integer *lwork, integer *
+			     iwork, integer *info);
+
+/* Subroutine */ int stpcon_(char *norm, char *uplo, char *diag, integer *n, 
+			     real *ap, real *rcond, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int stprfs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, real *ap, real *b, integer *ldb, real *x, integer *ldx, 
+			     real *ferr, real *berr, real *work, integer *iwork, integer *info);
+
+/* Subroutine */ int stptri_(char *uplo, char *diag, integer *n, real *ap, 
+			     integer *info);
+
+/* Subroutine */ int stptrs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, real *ap, real *b, integer *ldb, integer *info);
+
+/* Subroutine */ int stpttf_(char *transr, char *uplo, integer *n, real *ap, 
+			     real *arf, integer *info);
+
+/* Subroutine */ int stpttr_(char *uplo, integer *n, real *ap, real *a, 
+			     integer *lda, integer *info);
+
+/* Subroutine */ int strcon_(char *norm, char *uplo, char *diag, integer *n, 
+			     real *a, integer *lda, real *rcond, real *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int strevc_(char *side, char *howmny, logical *select, 
+			     integer *n, real *t, integer *ldt, real *vl, integer *ldvl, real *vr, 
+			     integer *ldvr, integer *mm, integer *m, real *work, integer *info);
+
+/* Subroutine */ int strexc_(char *compq, integer *n, real *t, integer *ldt, 
+			     real *q, integer *ldq, integer *ifst, integer *ilst, real *work, 
+			     integer *info);
+
+/* Subroutine */ int strrfs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, real *a, integer *lda, real *b, integer *ldb, real *x, 
+			     integer *ldx, real *ferr, real *berr, real *work, integer *iwork, 
+			     integer *info);
+
+/* Subroutine */ int strsen_(char *job, char *compq, logical *select, integer 
+			     *n, real *t, integer *ldt, real *q, integer *ldq, real *wr, real *wi, 
+			     integer *m, real *s, real *sep, real *work, integer *lwork, integer *
+			     iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int strsna_(char *job, char *howmny, logical *select, 
+			     integer *n, real *t, integer *ldt, real *vl, integer *ldvl, real *vr, 
+			     integer *ldvr, real *s, real *sep, integer *mm, integer *m, real *
+			     work, integer *ldwork, integer *iwork, integer *info);
+
+/* Subroutine */ int strsyl_(char *trana, char *tranb, integer *isgn, integer 
+			     *m, integer *n, real *a, integer *lda, real *b, integer *ldb, real *
+			     c__, integer *ldc, real *scale, integer *info);
+
+/* Subroutine */ int strti2_(char *uplo, char *diag, integer *n, real *a, 
+			     integer *lda, integer *info);
+
+/* Subroutine */ int strtri_(char *uplo, char *diag, integer *n, real *a, 
+			     integer *lda, integer *info);
+
+/* Subroutine */ int strtrs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, real *a, integer *lda, real *b, integer *ldb, integer *
+			     info);
+
+/* Subroutine */ int strttf_(char *transr, char *uplo, integer *n, real *a, 
+			     integer *lda, real *arf, integer *info);
+
+/* Subroutine */ int strttp_(char *uplo, integer *n, real *a, integer *lda, 
+			     real *ap, integer *info);
+
+/* Subroutine */ int stzrqf_(integer *m, integer *n, real *a, integer *lda, 
+			     real *tau, integer *info);
+
+/* Subroutine */ int stzrzf_(integer *m, integer *n, real *a, integer *lda, 
+			     real *tau, real *work, integer *lwork, integer *info);
+
+/* Subroutine */ int xerbla_(char *srname, integer *info);
+
+/* Subroutine */ int xerbla_array__(char *srname_array__, integer *
+				    srname_len__, integer *info, ftnlen srname_array_len);
+
+/* Subroutine */ int zbdsqr_(char *uplo, integer *n, integer *ncvt, integer *
+			     nru, integer *ncc, doublereal *d__, doublereal *e, doublecomplex *vt, 
+			     integer *ldvt, doublecomplex *u, integer *ldu, doublecomplex *c__, 
+			     integer *ldc, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zcgesv_(integer *n, integer *nrhs, doublecomplex *a, 
+			     integer *lda, integer *ipiv, doublecomplex *b, integer *ldb, 
+			     doublecomplex *x, integer *ldx, doublecomplex *work, singlecomplex *swork, 
+			     doublereal *rwork, integer *iter, integer *info);
+
+/* Subroutine */ int zcposv_(char *uplo, integer *n, integer *nrhs, 
+			     doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			     doublecomplex *x, integer *ldx, doublecomplex *work, singlecomplex *swork, 
+			     doublereal *rwork, integer *iter, integer *info);
+
+/* Subroutine */ int zdrscl_(integer *n, doublereal *sa, doublecomplex *sx, 
+			     integer *incx);
+
+/* Subroutine */ int zgbbrd_(char *vect, integer *m, integer *n, integer *ncc, 
+			     integer *kl, integer *ku, doublecomplex *ab, integer *ldab, 
+			     doublereal *d__, doublereal *e, doublecomplex *q, integer *ldq, 
+			     doublecomplex *pt, integer *ldpt, doublecomplex *c__, integer *ldc, 
+			     doublecomplex *work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgbcon_(char *norm, integer *n, integer *kl, integer *ku, 
+			     doublecomplex *ab, integer *ldab, integer *ipiv, doublereal *anorm, 
+			     doublereal *rcond, doublecomplex *work, doublereal *rwork, integer *
+			     info);
+
+/* Subroutine */ int zgbequ_(integer *m, integer *n, integer *kl, integer *ku, 
+			     doublecomplex *ab, integer *ldab, doublereal *r__, doublereal *c__, 
+			     doublereal *rowcnd, doublereal *colcnd, doublereal *amax, integer *
+			     info);
+
+/* Subroutine */ int zgbequb_(integer *m, integer *n, integer *kl, integer *
+			      ku, doublecomplex *ab, integer *ldab, doublereal *r__, doublereal *
+			      c__, doublereal *rowcnd, doublereal *colcnd, doublereal *amax, 
+			      integer *info);
+
+/* Subroutine */ int zgbrfs_(char *trans, integer *n, integer *kl, integer *
+			     ku, integer *nrhs, doublecomplex *ab, integer *ldab, doublecomplex *
+			     afb, integer *ldafb, integer *ipiv, doublecomplex *b, integer *ldb, 
+			     doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, 
+			     doublecomplex *work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgbrfsx_(char *trans, char *equed, integer *n, integer *
+			      kl, integer *ku, integer *nrhs, doublecomplex *ab, integer *ldab, 
+			      doublecomplex *afb, integer *ldafb, integer *ipiv, doublereal *r__, 
+			      doublereal *c__, doublecomplex *b, integer *ldb, doublecomplex *x, 
+			      integer *ldx, doublereal *rcond, doublereal *berr, integer *
+			      n_err_bnds__, doublereal *err_bnds_norm__, doublereal *
+			      err_bnds_comp__, integer *nparams, doublereal *params, doublecomplex *
+			      work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgbsv_(integer *n, integer *kl, integer *ku, integer *
+			    nrhs, doublecomplex *ab, integer *ldab, integer *ipiv, doublecomplex *
+			    b, integer *ldb, integer *info);
+
+/* Subroutine */ int zgbsvx_(char *fact, char *trans, integer *n, integer *kl, 
+			     integer *ku, integer *nrhs, doublecomplex *ab, integer *ldab, 
+			     doublecomplex *afb, integer *ldafb, integer *ipiv, char *equed, 
+			     doublereal *r__, doublereal *c__, doublecomplex *b, integer *ldb, 
+			     doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, 
+			     doublereal *berr, doublecomplex *work, doublereal *rwork, integer *
+			     info);
+
+/* Subroutine */ int zgbsvxx_(char *fact, char *trans, integer *n, integer *
+			      kl, integer *ku, integer *nrhs, doublecomplex *ab, integer *ldab, 
+			      doublecomplex *afb, integer *ldafb, integer *ipiv, char *equed, 
+			      doublereal *r__, doublereal *c__, doublecomplex *b, integer *ldb, 
+			      doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *rpvgrw, 
+			      doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, 
+			      doublereal *err_bnds_comp__, integer *nparams, doublereal *params, 
+			      doublecomplex *work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgbtf2_(integer *m, integer *n, integer *kl, integer *ku, 
+			     doublecomplex *ab, integer *ldab, integer *ipiv, integer *info);
+
+/* Subroutine */ int zgbtrf_(integer *m, integer *n, integer *kl, integer *ku, 
+			     doublecomplex *ab, integer *ldab, integer *ipiv, integer *info);
+
+/* Subroutine */ int zgbtrs_(char *trans, integer *n, integer *kl, integer *
+			     ku, integer *nrhs, doublecomplex *ab, integer *ldab, integer *ipiv, 
+			     doublecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int zgebak_(char *job, char *side, integer *n, integer *ilo, 
+			     integer *ihi, doublereal *scale, integer *m, doublecomplex *v, 
+			     integer *ldv, integer *info);
+
+/* Subroutine */ int zgebal_(char *job, integer *n, doublecomplex *a, integer 
+			     *lda, integer *ilo, integer *ihi, doublereal *scale, integer *info);
+
+/* Subroutine */ int zgebd2_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, doublereal *d__, doublereal *e, doublecomplex *tauq, 
+			     doublecomplex *taup, doublecomplex *work, integer *info);
+
+/* Subroutine */ int zgebrd_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, doublereal *d__, doublereal *e, doublecomplex *tauq, 
+			     doublecomplex *taup, doublecomplex *work, integer *lwork, integer *
+			     info);
+
+/* Subroutine */ int zgecon_(char *norm, integer *n, doublecomplex *a, 
+			     integer *lda, doublereal *anorm, doublereal *rcond, doublecomplex *
+			     work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgeequ_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, 
+			     doublereal *colcnd, doublereal *amax, integer *info);
+
+/* Subroutine */ int zgeequb_(integer *m, integer *n, doublecomplex *a, 
+			      integer *lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, 
+			      doublereal *colcnd, doublereal *amax, integer *info);
+
+/* Subroutine */ int zgees_(char *jobvs, char *sort, L_fp select, integer *n, 
+			    doublecomplex *a, integer *lda, integer *sdim, doublecomplex *w, 
+			    doublecomplex *vs, integer *ldvs, doublecomplex *work, integer *lwork, 
+			    doublereal *rwork, logical *bwork, integer *info);
+
+/* Subroutine */ int zgeesx_(char *jobvs, char *sort, L_fp select, char *
+			     sense, integer *n, doublecomplex *a, integer *lda, integer *sdim, 
+			     doublecomplex *w, doublecomplex *vs, integer *ldvs, doublereal *
+			     rconde, doublereal *rcondv, doublecomplex *work, integer *lwork, 
+			     doublereal *rwork, logical *bwork, integer *info);
+
+/* Subroutine */ int zgeev_(char *jobvl, char *jobvr, integer *n, 
+			    doublecomplex *a, integer *lda, doublecomplex *w, doublecomplex *vl, 
+			    integer *ldvl, doublecomplex *vr, integer *ldvr, doublecomplex *work, 
+			    integer *lwork, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgeevx_(char *balanc, char *jobvl, char *jobvr, char *
+			     sense, integer *n, doublecomplex *a, integer *lda, doublecomplex *w, 
+			     doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr, 
+			     integer *ilo, integer *ihi, doublereal *scale, doublereal *abnrm, 
+			     doublereal *rconde, doublereal *rcondv, doublecomplex *work, integer *
+			     lwork, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgegs_(char *jobvsl, char *jobvsr, integer *n, 
+			    doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			    doublecomplex *alpha, doublecomplex *beta, doublecomplex *vsl, 
+			    integer *ldvsl, doublecomplex *vsr, integer *ldvsr, doublecomplex *
+			    work, integer *lwork, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgegv_(char *jobvl, char *jobvr, integer *n, 
+			    doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			    doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, integer 
+			    *ldvl, doublecomplex *vr, integer *ldvr, doublecomplex *work, integer 
+			    *lwork, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgehd2_(integer *n, integer *ilo, integer *ihi, 
+			     doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
+			     work, integer *info);
+
+/* Subroutine */ int zgehrd_(integer *n, integer *ilo, integer *ihi, 
+			     doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
+			     work, integer *lwork, integer *info);
+
+/* Subroutine */ int zgelq2_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, doublecomplex *tau, doublecomplex *work, integer *info);
+
+/* Subroutine */ int zgelqf_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int zgels_(char *trans, integer *m, integer *n, integer *
+			    nrhs, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			    doublecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int zgelsd_(integer *m, integer *n, integer *nrhs, 
+			     doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			     doublereal *s, doublereal *rcond, integer *rank, doublecomplex *work, 
+			     integer *lwork, doublereal *rwork, integer *iwork, integer *info);
+
+/* Subroutine */ int zgelss_(integer *m, integer *n, integer *nrhs, 
+			     doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			     doublereal *s, doublereal *rcond, integer *rank, doublecomplex *work, 
+			     integer *lwork, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgelsx_(integer *m, integer *n, integer *nrhs, 
+			     doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			     integer *jpvt, doublereal *rcond, integer *rank, doublecomplex *work, 
+			     doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgelsy_(integer *m, integer *n, integer *nrhs, 
+			     doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			     integer *jpvt, doublereal *rcond, integer *rank, doublecomplex *work, 
+			     integer *lwork, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgeql2_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, doublecomplex *tau, doublecomplex *work, integer *info);
+
+/* Subroutine */ int zgeqlf_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int zgeqp3_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, integer *jpvt, doublecomplex *tau, doublecomplex *work, 
+			     integer *lwork, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgeqpf_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, integer *jpvt, doublecomplex *tau, doublecomplex *work, 
+			     doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgeqr2_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, doublecomplex *tau, doublecomplex *work, integer *info);
+
+/* Subroutine */ int zgeqrf_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int zgerfs_(char *trans, integer *n, integer *nrhs, 
+			     doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, 
+			     integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, 
+			     integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, 
+			     doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgerfsx_(char *trans, char *equed, integer *n, integer *
+			      nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *
+			      ldaf, integer *ipiv, doublereal *r__, doublereal *c__, doublecomplex *
+			      b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, 
+			      doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, 
+			      doublereal *err_bnds_comp__, integer *nparams, doublereal *params, 
+			      doublecomplex *work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgerq2_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, doublecomplex *tau, doublecomplex *work, integer *info);
+
+/* Subroutine */ int zgerqf_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int zgesc2_(integer *n, doublecomplex *a, integer *lda, 
+			     doublecomplex *rhs, integer *ipiv, integer *jpiv, doublereal *scale);
+
+/* Subroutine */ int zgesdd_(char *jobz, integer *m, integer *n, 
+			     doublecomplex *a, integer *lda, doublereal *s, doublecomplex *u, 
+			     integer *ldu, doublecomplex *vt, integer *ldvt, doublecomplex *work, 
+			     integer *lwork, doublereal *rwork, integer *iwork, integer *info);
+
+/* Subroutine */ int zgesv_(integer *n, integer *nrhs, doublecomplex *a, 
+			    integer *lda, integer *ipiv, doublecomplex *b, integer *ldb, integer *
+			    info);
+
+/* Subroutine */ int zgesvd_(char *jobu, char *jobvt, integer *m, integer *n, 
+			     doublecomplex *a, integer *lda, doublereal *s, doublecomplex *u, 
+			     integer *ldu, doublecomplex *vt, integer *ldvt, doublecomplex *work, 
+			     integer *lwork, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgesvx_(char *fact, char *trans, integer *n, integer *
+			     nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *
+			     ldaf, integer *ipiv, char *equed, doublereal *r__, doublereal *c__, 
+			     doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, 
+			     doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex *
+			     work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgesvxx_(char *fact, char *trans, integer *n, integer *
+			      nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *
+			      ldaf, integer *ipiv, char *equed, doublereal *r__, doublereal *c__, 
+			      doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, 
+			      doublereal *rcond, doublereal *rpvgrw, doublereal *berr, integer *
+			      n_err_bnds__, doublereal *err_bnds_norm__, doublereal *
+			      err_bnds_comp__, integer *nparams, doublereal *params, doublecomplex *
+			      work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgetc2_(integer *n, doublecomplex *a, integer *lda, 
+			     integer *ipiv, integer *jpiv, integer *info);
+
+/* Subroutine */ int zgetf2_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, integer *ipiv, integer *info);
+
+/* Subroutine */ int zgetrf_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, integer *ipiv, integer *info);
+
+/* Subroutine */ int zgetri_(integer *n, doublecomplex *a, integer *lda, 
+			     integer *ipiv, doublecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int zgetrs_(char *trans, integer *n, integer *nrhs, 
+			     doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, 
+			     integer *ldb, integer *info);
+
+/* Subroutine */ int zggbak_(char *job, char *side, integer *n, integer *ilo, 
+			     integer *ihi, doublereal *lscale, doublereal *rscale, integer *m, 
+			     doublecomplex *v, integer *ldv, integer *info);
+
+/* Subroutine */ int zggbal_(char *job, integer *n, doublecomplex *a, integer 
+			     *lda, doublecomplex *b, integer *ldb, integer *ilo, integer *ihi, 
+			     doublereal *lscale, doublereal *rscale, doublereal *work, integer *
+			     info);
+
+/* Subroutine */ int zgges_(char *jobvsl, char *jobvsr, char *sort, L_fp 
+			    selctg, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, 
+			    integer *ldb, integer *sdim, doublecomplex *alpha, doublecomplex *
+			    beta, doublecomplex *vsl, integer *ldvsl, doublecomplex *vsr, integer 
+			    *ldvsr, doublecomplex *work, integer *lwork, doublereal *rwork, 
+			    logical *bwork, integer *info);
+
+/* Subroutine */ int zggesx_(char *jobvsl, char *jobvsr, char *sort, L_fp 
+			     selctg, char *sense, integer *n, doublecomplex *a, integer *lda, 
+			     doublecomplex *b, integer *ldb, integer *sdim, doublecomplex *alpha, 
+			     doublecomplex *beta, doublecomplex *vsl, integer *ldvsl, 
+			     doublecomplex *vsr, integer *ldvsr, doublereal *rconde, doublereal *
+			     rcondv, doublecomplex *work, integer *lwork, doublereal *rwork, 
+			     integer *iwork, integer *liwork, logical *bwork, integer *info);
+
+/* Subroutine */ int zggev_(char *jobvl, char *jobvr, integer *n, 
+			    doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			    doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, integer 
+			    *ldvl, doublecomplex *vr, integer *ldvr, doublecomplex *work, integer 
+			    *lwork, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zggevx_(char *balanc, char *jobvl, char *jobvr, char *
+			     sense, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, 
+			     integer *ldb, doublecomplex *alpha, doublecomplex *beta, 
+			     doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr, 
+			     integer *ilo, integer *ihi, doublereal *lscale, doublereal *rscale, 
+			     doublereal *abnrm, doublereal *bbnrm, doublereal *rconde, doublereal *
+			     rcondv, doublecomplex *work, integer *lwork, doublereal *rwork, 
+			     integer *iwork, logical *bwork, integer *info);
+
+/* Subroutine */ int zggglm_(integer *n, integer *m, integer *p, 
+			     doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			     doublecomplex *d__, doublecomplex *x, doublecomplex *y, doublecomplex 
+			     *work, integer *lwork, integer *info);
+
+/* Subroutine */ int zgghrd_(char *compq, char *compz, integer *n, integer *
+			     ilo, integer *ihi, doublecomplex *a, integer *lda, doublecomplex *b, 
+			     integer *ldb, doublecomplex *q, integer *ldq, doublecomplex *z__, 
+			     integer *ldz, integer *info);
+
+/* Subroutine */ int zgglse_(integer *m, integer *n, integer *p, 
+			     doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			     doublecomplex *c__, doublecomplex *d__, doublecomplex *x, 
+			     doublecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int zggqrf_(integer *n, integer *m, integer *p, 
+			     doublecomplex *a, integer *lda, doublecomplex *taua, doublecomplex *b, 
+			     integer *ldb, doublecomplex *taub, doublecomplex *work, integer *
+			     lwork, integer *info);
+
+/* Subroutine */ int zggrqf_(integer *m, integer *p, integer *n, 
+			     doublecomplex *a, integer *lda, doublecomplex *taua, doublecomplex *b, 
+			     integer *ldb, doublecomplex *taub, doublecomplex *work, integer *
+			     lwork, integer *info);
+
+/* Subroutine */ int zggsvd_(char *jobu, char *jobv, char *jobq, integer *m, 
+			     integer *n, integer *p, integer *k, integer *l, doublecomplex *a, 
+			     integer *lda, doublecomplex *b, integer *ldb, doublereal *alpha, 
+			     doublereal *beta, doublecomplex *u, integer *ldu, doublecomplex *v, 
+			     integer *ldv, doublecomplex *q, integer *ldq, doublecomplex *work, 
+			     doublereal *rwork, integer *iwork, integer *info);
+
+/* Subroutine */ int zggsvp_(char *jobu, char *jobv, char *jobq, integer *m, 
+			     integer *p, integer *n, doublecomplex *a, integer *lda, doublecomplex 
+			     *b, integer *ldb, doublereal *tola, doublereal *tolb, integer *k, 
+			     integer *l, doublecomplex *u, integer *ldu, doublecomplex *v, integer 
+			     *ldv, doublecomplex *q, integer *ldq, integer *iwork, doublereal *
+			     rwork, doublecomplex *tau, doublecomplex *work, integer *info);
+
+/* Subroutine */ int zgtcon_(char *norm, integer *n, doublecomplex *dl, 
+			     doublecomplex *d__, doublecomplex *du, doublecomplex *du2, integer *
+			     ipiv, doublereal *anorm, doublereal *rcond, doublecomplex *work, 
+			     integer *info);
+
+/* Subroutine */ int zgtrfs_(char *trans, integer *n, integer *nrhs, 
+			     doublecomplex *dl, doublecomplex *d__, doublecomplex *du, 
+			     doublecomplex *dlf, doublecomplex *df, doublecomplex *duf, 
+			     doublecomplex *du2, integer *ipiv, doublecomplex *b, integer *ldb, 
+			     doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, 
+			     doublecomplex *work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zgtsv_(integer *n, integer *nrhs, doublecomplex *dl, 
+			    doublecomplex *d__, doublecomplex *du, doublecomplex *b, integer *ldb, 
+			    integer *info);
+
+/* Subroutine */ int zgtsvx_(char *fact, char *trans, integer *n, integer *
+			     nrhs, doublecomplex *dl, doublecomplex *d__, doublecomplex *du, 
+			     doublecomplex *dlf, doublecomplex *df, doublecomplex *duf, 
+			     doublecomplex *du2, integer *ipiv, doublecomplex *b, integer *ldb, 
+			     doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, 
+			     doublereal *berr, doublecomplex *work, doublereal *rwork, integer *
+			     info);
+
+/* Subroutine */ int zgttrf_(integer *n, doublecomplex *dl, doublecomplex *
+			     d__, doublecomplex *du, doublecomplex *du2, integer *ipiv, integer *
+			     info);
+
+/* Subroutine */ int zgttrs_(char *trans, integer *n, integer *nrhs, 
+			     doublecomplex *dl, doublecomplex *d__, doublecomplex *du, 
+			     doublecomplex *du2, integer *ipiv, doublecomplex *b, integer *ldb, 
+			     integer *info);
+
+/* Subroutine */ int zgtts2_(integer *itrans, integer *n, integer *nrhs, 
+			     doublecomplex *dl, doublecomplex *d__, doublecomplex *du, 
+			     doublecomplex *du2, integer *ipiv, doublecomplex *b, integer *ldb);
+
+/* Subroutine */ int zhbev_(char *jobz, char *uplo, integer *n, integer *kd, 
+			    doublecomplex *ab, integer *ldab, doublereal *w, doublecomplex *z__, 
+			    integer *ldz, doublecomplex *work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zhbevd_(char *jobz, char *uplo, integer *n, integer *kd, 
+			     doublecomplex *ab, integer *ldab, doublereal *w, doublecomplex *z__, 
+			     integer *ldz, doublecomplex *work, integer *lwork, doublereal *rwork, 
+			     integer *lrwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int zhbevx_(char *jobz, char *range, char *uplo, integer *n, 
+			     integer *kd, doublecomplex *ab, integer *ldab, doublecomplex *q, 
+			     integer *ldq, doublereal *vl, doublereal *vu, integer *il, integer *
+			     iu, doublereal *abstol, integer *m, doublereal *w, doublecomplex *z__, 
+			     integer *ldz, doublecomplex *work, doublereal *rwork, integer *iwork, 
+			     integer *ifail, integer *info);
+
+/* Subroutine */ int zhbgst_(char *vect, char *uplo, integer *n, integer *ka, 
+			     integer *kb, doublecomplex *ab, integer *ldab, doublecomplex *bb, 
+			     integer *ldbb, doublecomplex *x, integer *ldx, doublecomplex *work, 
+			     doublereal *rwork, integer *info);
+
+/* Subroutine */ int zhbgv_(char *jobz, char *uplo, integer *n, integer *ka, 
+			    integer *kb, doublecomplex *ab, integer *ldab, doublecomplex *bb, 
+			    integer *ldbb, doublereal *w, doublecomplex *z__, integer *ldz, 
+			    doublecomplex *work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zhbgvd_(char *jobz, char *uplo, integer *n, integer *ka, 
+			     integer *kb, doublecomplex *ab, integer *ldab, doublecomplex *bb, 
+			     integer *ldbb, doublereal *w, doublecomplex *z__, integer *ldz, 
+			     doublecomplex *work, integer *lwork, doublereal *rwork, integer *
+			     lrwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int zhbgvx_(char *jobz, char *range, char *uplo, integer *n, 
+			     integer *ka, integer *kb, doublecomplex *ab, integer *ldab, 
+			     doublecomplex *bb, integer *ldbb, doublecomplex *q, integer *ldq, 
+			     doublereal *vl, doublereal *vu, integer *il, integer *iu, doublereal *
+			     abstol, integer *m, doublereal *w, doublecomplex *z__, integer *ldz, 
+			     doublecomplex *work, doublereal *rwork, integer *iwork, integer *
+			     ifail, integer *info);
+
+/* Subroutine */ int zhbtrd_(char *vect, char *uplo, integer *n, integer *kd, 
+			     doublecomplex *ab, integer *ldab, doublereal *d__, doublereal *e, 
+			     doublecomplex *q, integer *ldq, doublecomplex *work, integer *info);
+
+/* Subroutine */ int zhecon_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, integer *ipiv, doublereal *anorm, doublereal *rcond, 
+			     doublecomplex *work, integer *info);
+
+/* Subroutine */ int zheequb_(char *uplo, integer *n, doublecomplex *a, 
+			      integer *lda, doublereal *s, doublereal *scond, doublereal *amax, 
+			      doublecomplex *work, integer *info);
+
+/* Subroutine */ int zheev_(char *jobz, char *uplo, integer *n, doublecomplex 
+			    *a, integer *lda, doublereal *w, doublecomplex *work, integer *lwork, 
+			    doublereal *rwork, integer *info);
+
+/* Subroutine */ int zheevd_(char *jobz, char *uplo, integer *n, 
+			     doublecomplex *a, integer *lda, doublereal *w, doublecomplex *work, 
+			     integer *lwork, doublereal *rwork, integer *lrwork, integer *iwork, 
+			     integer *liwork, integer *info);
+
+/* Subroutine */ int zheevr_(char *jobz, char *range, char *uplo, integer *n, 
+			     doublecomplex *a, integer *lda, doublereal *vl, doublereal *vu, 
+			     integer *il, integer *iu, doublereal *abstol, integer *m, doublereal *
+			     w, doublecomplex *z__, integer *ldz, integer *isuppz, doublecomplex *
+			     work, integer *lwork, doublereal *rwork, integer *lrwork, integer *
+			     iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int zheevx_(char *jobz, char *range, char *uplo, integer *n, 
+			     doublecomplex *a, integer *lda, doublereal *vl, doublereal *vu, 
+			     integer *il, integer *iu, doublereal *abstol, integer *m, doublereal *
+			     w, doublecomplex *z__, integer *ldz, doublecomplex *work, integer *
+			     lwork, doublereal *rwork, integer *iwork, integer *ifail, integer *
+			     info);
+
+/* Subroutine */ int zhegs2_(integer *itype, char *uplo, integer *n, 
+			     doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			     integer *info);
+
+/* Subroutine */ int zhegst_(integer *itype, char *uplo, integer *n, 
+			     doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			     integer *info);
+
+/* Subroutine */ int zhegv_(integer *itype, char *jobz, char *uplo, integer *
+			    n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			    doublereal *w, doublecomplex *work, integer *lwork, doublereal *rwork, 
+			    integer *info);
+
+/* Subroutine */ int zhegvd_(integer *itype, char *jobz, char *uplo, integer *
+			     n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			     doublereal *w, doublecomplex *work, integer *lwork, doublereal *rwork, 
+			     integer *lrwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int zhegvx_(integer *itype, char *jobz, char *range, char *
+			     uplo, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, 
+			     integer *ldb, doublereal *vl, doublereal *vu, integer *il, integer *
+			     iu, doublereal *abstol, integer *m, doublereal *w, doublecomplex *z__, 
+			     integer *ldz, doublecomplex *work, integer *lwork, doublereal *rwork, 
+			     integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int zherfs_(char *uplo, integer *n, integer *nrhs, 
+			     doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, 
+			     integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, 
+			     integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, 
+			     doublereal *rwork, integer *info);
+
+/* Subroutine */ int zherfsx_(char *uplo, char *equed, integer *n, integer *
+			      nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *
+			      ldaf, integer *ipiv, doublereal *s, doublecomplex *b, integer *ldb, 
+			      doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *berr, 
+			      integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal *
+			      err_bnds_comp__, integer *nparams, doublereal *params, doublecomplex *
+			      work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zhesv_(char *uplo, integer *n, integer *nrhs, 
+			    doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, 
+			    integer *ldb, doublecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int zhesvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *
+			     ldaf, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, 
+			     integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, 
+			     doublecomplex *work, integer *lwork, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zhesvxx_(char *fact, char *uplo, integer *n, integer *
+			      nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *
+			      ldaf, integer *ipiv, char *equed, doublereal *s, doublecomplex *b, 
+			      integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, 
+			      doublereal *rpvgrw, doublereal *berr, integer *n_err_bnds__, 
+			      doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer *
+			      nparams, doublereal *params, doublecomplex *work, doublereal *rwork, 
+			      integer *info);
+
+/* Subroutine */ int zhetd2_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, doublereal *d__, doublereal *e, doublecomplex *tau, 
+			     integer *info);
+
+/* Subroutine */ int zhetf2_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, integer *ipiv, integer *info);
+
+/* Subroutine */ int zhetrd_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, doublereal *d__, doublereal *e, doublecomplex *tau, 
+			     doublecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int zhetrf_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, integer *ipiv, doublecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int zhetri_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, integer *ipiv, doublecomplex *work, integer *info);
+
+/* Subroutine */ int zhetrs_(char *uplo, integer *n, integer *nrhs, 
+			     doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, 
+			     integer *ldb, integer *info);
+
+/* Subroutine */ int zhfrk_(char *transr, char *uplo, char *trans, integer *n, 
+			    integer *k, doublereal *alpha, doublecomplex *a, integer *lda, 
+			    doublereal *beta, doublecomplex *c__);
+
+/* Subroutine */ int zhgeqz_(char *job, char *compq, char *compz, integer *n, 
+			     integer *ilo, integer *ihi, doublecomplex *h__, integer *ldh, 
+			     doublecomplex *t, integer *ldt, doublecomplex *alpha, doublecomplex *
+			     beta, doublecomplex *q, integer *ldq, doublecomplex *z__, integer *
+			     ldz, doublecomplex *work, integer *lwork, doublereal *rwork, integer *
+			     info);
+
+/* Subroutine */ int zhpcon_(char *uplo, integer *n, doublecomplex *ap, 
+			     integer *ipiv, doublereal *anorm, doublereal *rcond, doublecomplex *
+			     work, integer *info);
+
+/* Subroutine */ int zhpev_(char *jobz, char *uplo, integer *n, doublecomplex 
+			    *ap, doublereal *w, doublecomplex *z__, integer *ldz, doublecomplex *
+			    work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zhpevd_(char *jobz, char *uplo, integer *n, 
+			     doublecomplex *ap, doublereal *w, doublecomplex *z__, integer *ldz, 
+			     doublecomplex *work, integer *lwork, doublereal *rwork, integer *
+			     lrwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int zhpevx_(char *jobz, char *range, char *uplo, integer *n, 
+			     doublecomplex *ap, doublereal *vl, doublereal *vu, integer *il, 
+			     integer *iu, doublereal *abstol, integer *m, doublereal *w, 
+			     doublecomplex *z__, integer *ldz, doublecomplex *work, doublereal *
+			     rwork, integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int zhpgst_(integer *itype, char *uplo, integer *n, 
+			     doublecomplex *ap, doublecomplex *bp, integer *info);
+
+/* Subroutine */ int zhpgv_(integer *itype, char *jobz, char *uplo, integer *
+			    n, doublecomplex *ap, doublecomplex *bp, doublereal *w, doublecomplex 
+			    *z__, integer *ldz, doublecomplex *work, doublereal *rwork, integer *
+			    info);
+
+/* Subroutine */ int zhpgvd_(integer *itype, char *jobz, char *uplo, integer *
+			     n, doublecomplex *ap, doublecomplex *bp, doublereal *w, doublecomplex 
+			     *z__, integer *ldz, doublecomplex *work, integer *lwork, doublereal *
+			     rwork, integer *lrwork, integer *iwork, integer *liwork, integer *
+			     info);
+
+/* Subroutine */ int zhpgvx_(integer *itype, char *jobz, char *range, char *
+			     uplo, integer *n, doublecomplex *ap, doublecomplex *bp, doublereal *
+			     vl, doublereal *vu, integer *il, integer *iu, doublereal *abstol, 
+			     integer *m, doublereal *w, doublecomplex *z__, integer *ldz, 
+			     doublecomplex *work, doublereal *rwork, integer *iwork, integer *
+			     ifail, integer *info);
+
+/* Subroutine */ int zhprfs_(char *uplo, integer *n, integer *nrhs, 
+			     doublecomplex *ap, doublecomplex *afp, integer *ipiv, doublecomplex *
+			     b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, 
+			     doublereal *berr, doublecomplex *work, doublereal *rwork, integer *
+			     info);
+
+/* Subroutine */ int zhpsv_(char *uplo, integer *n, integer *nrhs, 
+			    doublecomplex *ap, integer *ipiv, doublecomplex *b, integer *ldb, 
+			    integer *info);
+
+/* Subroutine */ int zhpsvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, doublecomplex *ap, doublecomplex *afp, integer *ipiv, 
+			     doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, 
+			     doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex *
+			     work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zhptrd_(char *uplo, integer *n, doublecomplex *ap, 
+			     doublereal *d__, doublereal *e, doublecomplex *tau, integer *info);
+
+/* Subroutine */ int zhptrf_(char *uplo, integer *n, doublecomplex *ap, 
+			     integer *ipiv, integer *info);
+
+/* Subroutine */ int zhptri_(char *uplo, integer *n, doublecomplex *ap, 
+			     integer *ipiv, doublecomplex *work, integer *info);
+
+/* Subroutine */ int zhptrs_(char *uplo, integer *n, integer *nrhs, 
+			     doublecomplex *ap, integer *ipiv, doublecomplex *b, integer *ldb, 
+			     integer *info);
+
+/* Subroutine */ int zhsein_(char *side, char *eigsrc, char *initv, logical *
+			     select, integer *n, doublecomplex *h__, integer *ldh, doublecomplex *
+			     w, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *ldvr, 
+			     integer *mm, integer *m, doublecomplex *work, doublereal *rwork, 
+			     integer *ifaill, integer *ifailr, integer *info);
+
+/* Subroutine */ int zhseqr_(char *job, char *compz, integer *n, integer *ilo, 
+			     integer *ihi, doublecomplex *h__, integer *ldh, doublecomplex *w, 
+			     doublecomplex *z__, integer *ldz, doublecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int zla_gbamv__(integer *trans, integer *m, integer *n, 
+				 integer *kl, integer *ku, doublereal *alpha, doublecomplex *ab, 
+				 integer *ldab, doublecomplex *x, integer *incx, doublereal *beta, 
+				 doublereal *y, integer *incy);
+
+doublereal zla_gbrcond_c__(char *trans, integer *n, integer *kl, integer *ku, 
+			   doublecomplex *ab, integer *ldab, doublecomplex *afb, integer *ldafb, 
+			   integer *ipiv, doublereal *c__, logical *capply, integer *info, 
+			   doublecomplex *work, doublereal *rwork, ftnlen trans_len);
+
+doublereal zla_gbrcond_x__(char *trans, integer *n, integer *kl, integer *ku, 
+			   doublecomplex *ab, integer *ldab, doublecomplex *afb, integer *ldafb, 
+			   integer *ipiv, doublecomplex *x, integer *info, doublecomplex *work, 
+			   doublereal *rwork, ftnlen trans_len);
+
+/* Subroutine */ int zla_gbrfsx_extended__(integer *prec_type__, integer *
+					   trans_type__, integer *n, integer *kl, integer *ku, integer *nrhs, 
+					   doublecomplex *ab, integer *ldab, doublecomplex *afb, integer *ldafb, 
+					   integer *ipiv, logical *colequ, doublereal *c__, doublecomplex *b, 
+					   integer *ldb, doublecomplex *y, integer *ldy, doublereal *berr_out__, 
+					   integer *n_norms__, doublereal *errs_n__, doublereal *errs_c__, 
+					   doublecomplex *res, doublereal *ayb, doublecomplex *dy, doublecomplex 
+					   *y_tail__, doublereal *rcond, integer *ithresh, doublereal *rthresh, 
+					   doublereal *dz_ub__, logical *ignore_cwise__, integer *info);
+
+doublereal zla_gbrpvgrw__(integer *n, integer *kl, integer *ku, integer *
+			  ncols, doublecomplex *ab, integer *ldab, doublecomplex *afb, integer *
+			  ldafb);
+
+/* Subroutine */ int zla_geamv__(integer *trans, integer *m, integer *n, 
+				 doublereal *alpha, doublecomplex *a, integer *lda, doublecomplex *x, 
+				 integer *incx, doublereal *beta, doublereal *y, integer *incy);
+
+doublereal zla_gercond_c__(char *trans, integer *n, doublecomplex *a, integer 
+			   *lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublereal *
+			   c__, logical *capply, integer *info, doublecomplex *work, doublereal *
+			   rwork, ftnlen trans_len);
+
+doublereal zla_gercond_x__(char *trans, integer *n, doublecomplex *a, integer 
+			   *lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublecomplex *
+			   x, integer *info, doublecomplex *work, doublereal *rwork, ftnlen 
+			   trans_len);
+
+/* Subroutine */ int zla_gerfsx_extended__(integer *prec_type__, integer *
+					   trans_type__, integer *n, integer *nrhs, doublecomplex *a, integer *
+					   lda, doublecomplex *af, integer *ldaf, integer *ipiv, logical *colequ,
+					   doublereal *c__, doublecomplex *b, integer *ldb, doublecomplex *y, 
+					   integer *ldy, doublereal *berr_out__, integer *n_norms__, doublereal *
+					   errs_n__, doublereal *errs_c__, doublecomplex *res, doublereal *ayb, 
+					   doublecomplex *dy, doublecomplex *y_tail__, doublereal *rcond, 
+					   integer *ithresh, doublereal *rthresh, doublereal *dz_ub__, logical *
+					   ignore_cwise__, integer *info);
+
+/* Subroutine */ int zla_heamv__(integer *uplo, integer *n, doublereal *alpha,
+				 doublecomplex *a, integer *lda, doublecomplex *x, integer *incx, 
+				 doublereal *beta, doublereal *y, integer *incy);
+
+doublereal zla_hercond_c__(char *uplo, integer *n, doublecomplex *a, integer *
+			   lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublereal *c__,
+			   logical *capply, integer *info, doublecomplex *work, doublereal *
+			   rwork, ftnlen uplo_len);
+
+doublereal zla_hercond_x__(char *uplo, integer *n, doublecomplex *a, integer *
+			   lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublecomplex *
+			   x, integer *info, doublecomplex *work, doublereal *rwork, ftnlen 
+			   uplo_len);
+
+/* Subroutine */ int zla_herfsx_extended__(integer *prec_type__, char *uplo, 
+					   integer *n, integer *nrhs, doublecomplex *a, integer *lda, 
+					   doublecomplex *af, integer *ldaf, integer *ipiv, logical *colequ, 
+					   doublereal *c__, doublecomplex *b, integer *ldb, doublecomplex *y, 
+					   integer *ldy, doublereal *berr_out__, integer *n_norms__, doublereal *
+					   errs_n__, doublereal *errs_c__, doublecomplex *res, doublereal *ayb, 
+					   doublecomplex *dy, doublecomplex *y_tail__, doublereal *rcond, 
+					   integer *ithresh, doublereal *rthresh, doublereal *dz_ub__, logical *
+					   ignore_cwise__, integer *info, ftnlen uplo_len);
+
+doublereal zla_herpvgrw__(char *uplo, integer *n, integer *info, 
+			  doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, 
+			  integer *ipiv, doublereal *work, ftnlen uplo_len);
+
+/* Subroutine */ int zla_lin_berr__(integer *n, integer *nz, integer *nrhs, 
+				    doublecomplex *res, doublereal *ayb, doublereal *berr);
+
+doublereal zla_porcond_c__(char *uplo, integer *n, doublecomplex *a, integer *
+			   lda, doublecomplex *af, integer *ldaf, doublereal *c__, logical *
+			   capply, integer *info, doublecomplex *work, doublereal *rwork, ftnlen 
+			   uplo_len);
+
+doublereal zla_porcond_x__(char *uplo, integer *n, doublecomplex *a, integer *
+			   lda, doublecomplex *af, integer *ldaf, doublecomplex *x, integer *
+			   info, doublecomplex *work, doublereal *rwork, ftnlen uplo_len);
+
+/* Subroutine */ int zla_porfsx_extended__(integer *prec_type__, char *uplo, 
+					   integer *n, integer *nrhs, doublecomplex *a, integer *lda, 
+					   doublecomplex *af, integer *ldaf, logical *colequ, doublereal *c__, 
+					   doublecomplex *b, integer *ldb, doublecomplex *y, integer *ldy, 
+					   doublereal *berr_out__, integer *n_norms__, doublereal *errs_n__, 
+					   doublereal *errs_c__, doublecomplex *res, doublereal *ayb, 
+					   doublecomplex *dy, doublecomplex *y_tail__, doublereal *rcond, 
+					   integer *ithresh, doublereal *rthresh, doublereal *dz_ub__, logical *
+					   ignore_cwise__, integer *info, ftnlen uplo_len);
+
+doublereal zla_porpvgrw__(char *uplo, integer *ncols, doublecomplex *a, 
+			  integer *lda, doublecomplex *af, integer *ldaf, doublereal *work, 
+			  ftnlen uplo_len);
+
+doublereal zla_rpvgrw__(integer *n, integer *ncols, doublecomplex *a, integer 
+			*lda, doublecomplex *af, integer *ldaf);
+
+/* Subroutine */ int zla_syamv__(integer *uplo, integer *n, doublereal *alpha,
+				 doublecomplex *a, integer *lda, doublecomplex *x, integer *incx, 
+				 doublereal *beta, doublereal *y, integer *incy);
+
+doublereal zla_syrcond_c__(char *uplo, integer *n, doublecomplex *a, integer *
+			   lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublereal *c__,
+			   logical *capply, integer *info, doublecomplex *work, doublereal *
+			   rwork, ftnlen uplo_len);
+
+doublereal zla_syrcond_x__(char *uplo, integer *n, doublecomplex *a, integer *
+			   lda, doublecomplex *af, integer *ldaf, integer *ipiv, doublecomplex *
+			   x, integer *info, doublecomplex *work, doublereal *rwork, ftnlen 
+			   uplo_len);
+
+/* Subroutine */ int zla_syrfsx_extended__(integer *prec_type__, char *uplo, 
+					   integer *n, integer *nrhs, doublecomplex *a, integer *lda, 
+					   doublecomplex *af, integer *ldaf, integer *ipiv, logical *colequ, 
+					   doublereal *c__, doublecomplex *b, integer *ldb, doublecomplex *y, 
+					   integer *ldy, doublereal *berr_out__, integer *n_norms__, doublereal *
+					   errs_n__, doublereal *errs_c__, doublecomplex *res, doublereal *ayb, 
+					   doublecomplex *dy, doublecomplex *y_tail__, doublereal *rcond, 
+					   integer *ithresh, doublereal *rthresh, doublereal *dz_ub__, logical *
+					   ignore_cwise__, integer *info, ftnlen uplo_len);
+
+doublereal zla_syrpvgrw__(char *uplo, integer *n, integer *info, 
+			  doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, 
+			  integer *ipiv, doublereal *work, ftnlen uplo_len);
+
+/* Subroutine */ int zla_wwaddw__(integer *n, doublecomplex *x, doublecomplex 
+				  *y, doublecomplex *w);
+
+/* Subroutine */ int zlabrd_(integer *m, integer *n, integer *nb, 
+			     doublecomplex *a, integer *lda, doublereal *d__, doublereal *e, 
+			     doublecomplex *tauq, doublecomplex *taup, doublecomplex *x, integer *
+			     ldx, doublecomplex *y, integer *ldy);
+
+/* Subroutine */ int zlacgv_(integer *n, doublecomplex *x, integer *incx);
+
+/* Subroutine */ int zlacn2_(integer *n, doublecomplex *v, doublecomplex *x, 
+			     doublereal *est, integer *kase, integer *isave);
+
+/* Subroutine */ int zlacon_(integer *n, doublecomplex *v, doublecomplex *x, 
+			     doublereal *est, integer *kase);
+
+/* Subroutine */ int zlacp2_(char *uplo, integer *m, integer *n, doublereal *
+			     a, integer *lda, doublecomplex *b, integer *ldb);
+
+/* Subroutine */ int zlacpy_(char *uplo, integer *m, integer *n, 
+			     doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb);
+
+/* Subroutine */ int zlacrm_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, doublereal *b, integer *ldb, doublecomplex *c__, 
+			     integer *ldc, doublereal *rwork);
+
+/* Subroutine */ int zlacrt_(integer *n, doublecomplex *cx, integer *incx, 
+			     doublecomplex *cy, integer *incy, doublecomplex *c__, doublecomplex *
+			     s);
+
+/* Double singlecomplex */ VOID zladiv_(doublecomplex * ret_val, doublecomplex *x, 
+					doublecomplex *y);
+
+/* Subroutine */ int zlaed0_(integer *qsiz, integer *n, doublereal *d__, 
+			     doublereal *e, doublecomplex *q, integer *ldq, doublecomplex *qstore, 
+			     integer *ldqs, doublereal *rwork, integer *iwork, integer *info);
+
+/* Subroutine */ int zlaed7_(integer *n, integer *cutpnt, integer *qsiz, 
+			     integer *tlvls, integer *curlvl, integer *curpbm, doublereal *d__, 
+			     doublecomplex *q, integer *ldq, doublereal *rho, integer *indxq, 
+			     doublereal *qstore, integer *qptr, integer *prmptr, integer *perm, 
+			     integer *givptr, integer *givcol, doublereal *givnum, doublecomplex *
+			     work, doublereal *rwork, integer *iwork, integer *info);
+
+/* Subroutine */ int zlaed8_(integer *k, integer *n, integer *qsiz, 
+			     doublecomplex *q, integer *ldq, doublereal *d__, doublereal *rho, 
+			     integer *cutpnt, doublereal *z__, doublereal *dlamda, doublecomplex *
+			     q2, integer *ldq2, doublereal *w, integer *indxp, integer *indx, 
+			     integer *indxq, integer *perm, integer *givptr, integer *givcol, 
+			     doublereal *givnum, integer *info);
+
+/* Subroutine */ int zlaein_(logical *rightv, logical *noinit, integer *n, 
+			     doublecomplex *h__, integer *ldh, doublecomplex *w, doublecomplex *v, 
+			     doublecomplex *b, integer *ldb, doublereal *rwork, doublereal *eps3, 
+			     doublereal *smlnum, integer *info);
+
+/* Subroutine */ int zlaesy_(doublecomplex *a, doublecomplex *b, 
+			     doublecomplex *c__, doublecomplex *rt1, doublecomplex *rt2, 
+			     doublecomplex *evscal, doublecomplex *cs1, doublecomplex *sn1);
+
+/* Subroutine */ int zlaev2_(doublecomplex *a, doublecomplex *b, 
+			     doublecomplex *c__, doublereal *rt1, doublereal *rt2, doublereal *cs1, 
+			     doublecomplex *sn1);
+
+/* Subroutine */ int zlag2c_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, singlecomplex *sa, integer *ldsa, integer *info);
+
+/* Subroutine */ int zlags2_(logical *upper, doublereal *a1, doublecomplex *
+			     a2, doublereal *a3, doublereal *b1, doublecomplex *b2, doublereal *b3, 
+			     doublereal *csu, doublecomplex *snu, doublereal *csv, doublecomplex *
+			     snv, doublereal *csq, doublecomplex *snq);
+
+/* Subroutine */ int zlagtm_(char *trans, integer *n, integer *nrhs, 
+			     doublereal *alpha, doublecomplex *dl, doublecomplex *d__, 
+			     doublecomplex *du, doublecomplex *x, integer *ldx, doublereal *beta, 
+			     doublecomplex *b, integer *ldb);
+
+/* Subroutine */ int zlahef_(char *uplo, integer *n, integer *nb, integer *kb, 
+			     doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *w, 
+			     integer *ldw, integer *info);
+
+/* Subroutine */ int zlahqr_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ilo, integer *ihi, doublecomplex *h__, integer *ldh, 
+			     doublecomplex *w, integer *iloz, integer *ihiz, doublecomplex *z__, 
+			     integer *ldz, integer *info);
+
+/* Subroutine */ int zlahr2_(integer *n, integer *k, integer *nb, 
+			     doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *t, 
+			     integer *ldt, doublecomplex *y, integer *ldy);
+
+/* Subroutine */ int zlahrd_(integer *n, integer *k, integer *nb, 
+			     doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *t, 
+			     integer *ldt, doublecomplex *y, integer *ldy);
+
+/* Subroutine */ int zlaic1_(integer *job, integer *j, doublecomplex *x, 
+			     doublereal *sest, doublecomplex *w, doublecomplex *gamma, doublereal *
+			     sestpr, doublecomplex *s, doublecomplex *c__);
+
+/* Subroutine */ int zlals0_(integer *icompq, integer *nl, integer *nr, 
+			     integer *sqre, integer *nrhs, doublecomplex *b, integer *ldb, 
+			     doublecomplex *bx, integer *ldbx, integer *perm, integer *givptr, 
+			     integer *givcol, integer *ldgcol, doublereal *givnum, integer *ldgnum, 
+			     doublereal *poles, doublereal *difl, doublereal *difr, doublereal *
+			     z__, integer *k, doublereal *c__, doublereal *s, doublereal *rwork, 
+			     integer *info);
+
+/* Subroutine */ int zlalsa_(integer *icompq, integer *smlsiz, integer *n, 
+			     integer *nrhs, doublecomplex *b, integer *ldb, doublecomplex *bx, 
+			     integer *ldbx, doublereal *u, integer *ldu, doublereal *vt, integer *
+			     k, doublereal *difl, doublereal *difr, doublereal *z__, doublereal *
+			     poles, integer *givptr, integer *givcol, integer *ldgcol, integer *
+			     perm, doublereal *givnum, doublereal *c__, doublereal *s, doublereal *
+			     rwork, integer *iwork, integer *info);
+
+/* Subroutine */ int zlalsd_(char *uplo, integer *smlsiz, integer *n, integer 
+			     *nrhs, doublereal *d__, doublereal *e, doublecomplex *b, integer *ldb, 
+			     doublereal *rcond, integer *rank, doublecomplex *work, doublereal *
+			     rwork, integer *iwork, integer *info);
+
+doublereal zlangb_(char *norm, integer *n, integer *kl, integer *ku, 
+		   doublecomplex *ab, integer *ldab, doublereal *work);
+
+doublereal zlange_(char *norm, integer *m, integer *n, doublecomplex *a, 
+		   integer *lda, doublereal *work);
+
+doublereal zlangt_(char *norm, integer *n, doublecomplex *dl, doublecomplex *
+		   d__, doublecomplex *du);
+
+doublereal zlanhb_(char *norm, char *uplo, integer *n, integer *k, 
+		   doublecomplex *ab, integer *ldab, doublereal *work);
+
+doublereal zlanhe_(char *norm, char *uplo, integer *n, doublecomplex *a, 
+		   integer *lda, doublereal *work);
+
+doublereal zlanhf_(char *norm, char *transr, char *uplo, integer *n, 
+		   doublecomplex *a, doublereal *work);
+
+doublereal zlanhp_(char *norm, char *uplo, integer *n, doublecomplex *ap, 
+		   doublereal *work);
+
+doublereal zlanhs_(char *norm, integer *n, doublecomplex *a, integer *lda, 
+		   doublereal *work);
+
+doublereal zlanht_(char *norm, integer *n, doublereal *d__, doublecomplex *e);
+
+doublereal zlansb_(char *norm, char *uplo, integer *n, integer *k, 
+		   doublecomplex *ab, integer *ldab, doublereal *work);
+
+doublereal zlansp_(char *norm, char *uplo, integer *n, doublecomplex *ap, 
+		   doublereal *work);
+
+doublereal zlansy_(char *norm, char *uplo, integer *n, doublecomplex *a, 
+		   integer *lda, doublereal *work);
+
+doublereal zlantb_(char *norm, char *uplo, char *diag, integer *n, integer *k, 
+		   doublecomplex *ab, integer *ldab, doublereal *work);
+
+doublereal zlantp_(char *norm, char *uplo, char *diag, integer *n, 
+		   doublecomplex *ap, doublereal *work);
+
+doublereal zlantr_(char *norm, char *uplo, char *diag, integer *m, integer *n, 
+		   doublecomplex *a, integer *lda, doublereal *work);
+
+/* Subroutine */ int zlapll_(integer *n, doublecomplex *x, integer *incx, 
+			     doublecomplex *y, integer *incy, doublereal *ssmin);
+
+/* Subroutine */ int zlapmt_(logical *forwrd, integer *m, integer *n, 
+			     doublecomplex *x, integer *ldx, integer *k);
+
+/* Subroutine */ int zlaqgb_(integer *m, integer *n, integer *kl, integer *ku, 
+			     doublecomplex *ab, integer *ldab, doublereal *r__, doublereal *c__, 
+			     doublereal *rowcnd, doublereal *colcnd, doublereal *amax, char *equed);
+
+/* Subroutine */ int zlaqge_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, doublereal *r__, doublereal *c__, doublereal *rowcnd, 
+			     doublereal *colcnd, doublereal *amax, char *equed);
+
+/* Subroutine */ int zlaqhb_(char *uplo, integer *n, integer *kd, 
+			     doublecomplex *ab, integer *ldab, doublereal *s, doublereal *scond, 
+			     doublereal *amax, char *equed);
+
+/* Subroutine */ int zlaqhe_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, doublereal *s, doublereal *scond, doublereal *amax, 
+			     char *equed);
+
+/* Subroutine */ int zlaqhp_(char *uplo, integer *n, doublecomplex *ap, 
+			     doublereal *s, doublereal *scond, doublereal *amax, char *equed);
+
+/* Subroutine */ int zlaqp2_(integer *m, integer *n, integer *offset, 
+			     doublecomplex *a, integer *lda, integer *jpvt, doublecomplex *tau, 
+			     doublereal *vn1, doublereal *vn2, doublecomplex *work);
+
+/* Subroutine */ int zlaqps_(integer *m, integer *n, integer *offset, integer 
+			     *nb, integer *kb, doublecomplex *a, integer *lda, integer *jpvt, 
+			     doublecomplex *tau, doublereal *vn1, doublereal *vn2, doublecomplex *
+			     auxv, doublecomplex *f, integer *ldf);
+
+/* Subroutine */ int zlaqr0_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ilo, integer *ihi, doublecomplex *h__, integer *ldh, 
+			     doublecomplex *w, integer *iloz, integer *ihiz, doublecomplex *z__, 
+			     integer *ldz, doublecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int zlaqr1_(integer *n, doublecomplex *h__, integer *ldh, 
+			     doublecomplex *s1, doublecomplex *s2, doublecomplex *v);
+
+/* Subroutine */ int zlaqr2_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ktop, integer *kbot, integer *nw, doublecomplex *h__, 
+			     integer *ldh, integer *iloz, integer *ihiz, doublecomplex *z__, 
+			     integer *ldz, integer *ns, integer *nd, doublecomplex *sh, 
+			     doublecomplex *v, integer *ldv, integer *nh, doublecomplex *t, 
+			     integer *ldt, integer *nv, doublecomplex *wv, integer *ldwv, 
+			     doublecomplex *work, integer *lwork);
+
+/* Subroutine */ int zlaqr3_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ktop, integer *kbot, integer *nw, doublecomplex *h__, 
+			     integer *ldh, integer *iloz, integer *ihiz, doublecomplex *z__, 
+			     integer *ldz, integer *ns, integer *nd, doublecomplex *sh, 
+			     doublecomplex *v, integer *ldv, integer *nh, doublecomplex *t, 
+			     integer *ldt, integer *nv, doublecomplex *wv, integer *ldwv, 
+			     doublecomplex *work, integer *lwork);
+
+/* Subroutine */ int zlaqr4_(logical *wantt, logical *wantz, integer *n, 
+			     integer *ilo, integer *ihi, doublecomplex *h__, integer *ldh, 
+			     doublecomplex *w, integer *iloz, integer *ihiz, doublecomplex *z__, 
+			     integer *ldz, doublecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int zlaqr5_(logical *wantt, logical *wantz, integer *kacc22, 
+			     integer *n, integer *ktop, integer *kbot, integer *nshfts, 
+			     doublecomplex *s, doublecomplex *h__, integer *ldh, integer *iloz, 
+			     integer *ihiz, doublecomplex *z__, integer *ldz, doublecomplex *v, 
+			     integer *ldv, doublecomplex *u, integer *ldu, integer *nv, 
+			     doublecomplex *wv, integer *ldwv, integer *nh, doublecomplex *wh, 
+			     integer *ldwh);
+
+/* Subroutine */ int zlaqsb_(char *uplo, integer *n, integer *kd, 
+			     doublecomplex *ab, integer *ldab, doublereal *s, doublereal *scond, 
+			     doublereal *amax, char *equed);
+
+/* Subroutine */ int zlaqsp_(char *uplo, integer *n, doublecomplex *ap, 
+			     doublereal *s, doublereal *scond, doublereal *amax, char *equed);
+
+/* Subroutine */ int zlaqsy_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, doublereal *s, doublereal *scond, doublereal *amax, 
+			     char *equed);
+
+/* Subroutine */ int zlar1v_(integer *n, integer *b1, integer *bn, doublereal 
+			     *lambda, doublereal *d__, doublereal *l, doublereal *ld, doublereal *
+			     lld, doublereal *pivmin, doublereal *gaptol, doublecomplex *z__, 
+			     logical *wantnc, integer *negcnt, doublereal *ztz, doublereal *mingma, 
+			     integer *r__, integer *isuppz, doublereal *nrminv, doublereal *resid, 
+			     doublereal *rqcorr, doublereal *work);
+
+/* Subroutine */ int zlar2v_(integer *n, doublecomplex *x, doublecomplex *y, 
+			     doublecomplex *z__, integer *incx, doublereal *c__, doublecomplex *s, 
+			     integer *incc);
+
+/* Subroutine */ int zlarcm_(integer *m, integer *n, doublereal *a, integer *
+			     lda, doublecomplex *b, integer *ldb, doublecomplex *c__, integer *ldc, 
+			     doublereal *rwork);
+
+/* Subroutine */ int zlarf_(char *side, integer *m, integer *n, doublecomplex 
+			    *v, integer *incv, doublecomplex *tau, doublecomplex *c__, integer *
+			    ldc, doublecomplex *work);
+
+/* Subroutine */ int zlarfb_(char *side, char *trans, char *direct, char *
+			     storev, integer *m, integer *n, integer *k, doublecomplex *v, integer 
+			     *ldv, doublecomplex *t, integer *ldt, doublecomplex *c__, integer *
+			     ldc, doublecomplex *work, integer *ldwork);
+
+/* Subroutine */ int zlarfg_(integer *n, doublecomplex *alpha, doublecomplex *
+			     x, integer *incx, doublecomplex *tau);
+
+/* Subroutine */ int zlarfp_(integer *n, doublecomplex *alpha, doublecomplex *
+			     x, integer *incx, doublecomplex *tau);
+
+/* Subroutine */ int zlarft_(char *direct, char *storev, integer *n, integer *
+			     k, doublecomplex *v, integer *ldv, doublecomplex *tau, doublecomplex *
+			     t, integer *ldt);
+
+/* Subroutine */ int zlarfx_(char *side, integer *m, integer *n, 
+			     doublecomplex *v, doublecomplex *tau, doublecomplex *c__, integer *
+			     ldc, doublecomplex *work);
+
+/* Subroutine */ int zlargv_(integer *n, doublecomplex *x, integer *incx, 
+			     doublecomplex *y, integer *incy, doublereal *c__, integer *incc);
+
+/* Subroutine */ int zlarnv_(integer *idist, integer *iseed, integer *n, 
+			     doublecomplex *x);
+
+/* Subroutine */ int zlarrv_(integer *n, doublereal *vl, doublereal *vu, 
+			     doublereal *d__, doublereal *l, doublereal *pivmin, integer *isplit, 
+			     integer *m, integer *dol, integer *dou, doublereal *minrgp, 
+			     doublereal *rtol1, doublereal *rtol2, doublereal *w, doublereal *werr, 
+			     doublereal *wgap, integer *iblock, integer *indexw, doublereal *gers, 
+			     doublecomplex *z__, integer *ldz, integer *isuppz, doublereal *work, 
+			     integer *iwork, integer *info);
+
+/* Subroutine */ int zlarscl2_(integer *m, integer *n, doublereal *d__, 
+			       doublecomplex *x, integer *ldx);
+
+/* Subroutine */ int zlartg_(doublecomplex *f, doublecomplex *g, doublereal *
+			     cs, doublecomplex *sn, doublecomplex *r__);
+
+/* Subroutine */ int zlartv_(integer *n, doublecomplex *x, integer *incx, 
+			     doublecomplex *y, integer *incy, doublereal *c__, doublecomplex *s, 
+			     integer *incc);
+
+/* Subroutine */ int zlarz_(char *side, integer *m, integer *n, integer *l, 
+			    doublecomplex *v, integer *incv, doublecomplex *tau, doublecomplex *
+			    c__, integer *ldc, doublecomplex *work);
+
+/* Subroutine */ int zlarzb_(char *side, char *trans, char *direct, char *
+			     storev, integer *m, integer *n, integer *k, integer *l, doublecomplex 
+			     *v, integer *ldv, doublecomplex *t, integer *ldt, doublecomplex *c__, 
+			     integer *ldc, doublecomplex *work, integer *ldwork);
+
+/* Subroutine */ int zlarzt_(char *direct, char *storev, integer *n, integer *
+			     k, doublecomplex *v, integer *ldv, doublecomplex *tau, doublecomplex *
+			     t, integer *ldt);
+
+/* Subroutine */ int zlascl_(char *type__, integer *kl, integer *ku, 
+			     doublereal *cfrom, doublereal *cto, integer *m, integer *n, 
+			     doublecomplex *a, integer *lda, integer *info);
+
+/* Subroutine */ int zlascl2_(integer *m, integer *n, doublereal *d__, 
+			      doublecomplex *x, integer *ldx);
+
+/* Subroutine */ int zlaset_(char *uplo, integer *m, integer *n, 
+			     doublecomplex *alpha, doublecomplex *beta, doublecomplex *a, integer *
+			     lda);
+
+/* Subroutine */ int zlasr_(char *side, char *pivot, char *direct, integer *m, 
+			    integer *n, doublereal *c__, doublereal *s, doublecomplex *a, 
+			    integer *lda);
+
+/* Subroutine */ int zlassq_(integer *n, doublecomplex *x, integer *incx, 
+			     doublereal *scale, doublereal *sumsq);
+
+/* Subroutine */ int zlaswp_(integer *n, doublecomplex *a, integer *lda, 
+			     integer *k1, integer *k2, integer *ipiv, integer *incx);
+
+/* Subroutine */ int zlasyf_(char *uplo, integer *n, integer *nb, integer *kb, 
+			     doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *w, 
+			     integer *ldw, integer *info);
+
+/* Subroutine */ int zlat2c_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, singlecomplex *sa, integer *ldsa, integer *info);
+
+/* Subroutine */ int zlatbs_(char *uplo, char *trans, char *diag, char *
+			     normin, integer *n, integer *kd, doublecomplex *ab, integer *ldab, 
+			     doublecomplex *x, doublereal *scale, doublereal *cnorm, integer *info);
+
+/* Subroutine */ int zlatdf_(integer *ijob, integer *n, doublecomplex *z__, 
+			     integer *ldz, doublecomplex *rhs, doublereal *rdsum, doublereal *
+			     rdscal, integer *ipiv, integer *jpiv);
+
+/* Subroutine */ int zlatps_(char *uplo, char *trans, char *diag, char *
+			     normin, integer *n, doublecomplex *ap, doublecomplex *x, doublereal *
+			     scale, doublereal *cnorm, integer *info);
+
+/* Subroutine */ int zlatrd_(char *uplo, integer *n, integer *nb, 
+			     doublecomplex *a, integer *lda, doublereal *e, doublecomplex *tau, 
+			     doublecomplex *w, integer *ldw);
+
+/* Subroutine */ int zlatrs_(char *uplo, char *trans, char *diag, char *
+			     normin, integer *n, doublecomplex *a, integer *lda, doublecomplex *x, 
+			     doublereal *scale, doublereal *cnorm, integer *info);
+
+/* Subroutine */ int zlatrz_(integer *m, integer *n, integer *l, 
+			     doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
+			     work);
+
+/* Subroutine */ int zlatzm_(char *side, integer *m, integer *n, 
+			     doublecomplex *v, integer *incv, doublecomplex *tau, doublecomplex *
+			     c1, doublecomplex *c2, integer *ldc, doublecomplex *work);
+
+/* Subroutine */ int zlauu2_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, integer *info);
+
+/* Subroutine */ int zlauum_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, integer *info);
+
+/* Subroutine */ int zpbcon_(char *uplo, integer *n, integer *kd, 
+			     doublecomplex *ab, integer *ldab, doublereal *anorm, doublereal *
+			     rcond, doublecomplex *work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zpbequ_(char *uplo, integer *n, integer *kd, 
+			     doublecomplex *ab, integer *ldab, doublereal *s, doublereal *scond, 
+			     doublereal *amax, integer *info);
+
+/* Subroutine */ int zpbrfs_(char *uplo, integer *n, integer *kd, integer *
+			     nrhs, doublecomplex *ab, integer *ldab, doublecomplex *afb, integer *
+			     ldafb, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, 
+			     doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *
+			     rwork, integer *info);
+
+/* Subroutine */ int zpbstf_(char *uplo, integer *n, integer *kd, 
+			     doublecomplex *ab, integer *ldab, integer *info);
+
+/* Subroutine */ int zpbsv_(char *uplo, integer *n, integer *kd, integer *
+			    nrhs, doublecomplex *ab, integer *ldab, doublecomplex *b, integer *
+			    ldb, integer *info);
+
+/* Subroutine */ int zpbsvx_(char *fact, char *uplo, integer *n, integer *kd, 
+			     integer *nrhs, doublecomplex *ab, integer *ldab, doublecomplex *afb, 
+			     integer *ldafb, char *equed, doublereal *s, doublecomplex *b, integer 
+			     *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *
+			     ferr, doublereal *berr, doublecomplex *work, doublereal *rwork, 
+			     integer *info);
+
+/* Subroutine */ int zpbtf2_(char *uplo, integer *n, integer *kd, 
+			     doublecomplex *ab, integer *ldab, integer *info);
+
+/* Subroutine */ int zpbtrf_(char *uplo, integer *n, integer *kd, 
+			     doublecomplex *ab, integer *ldab, integer *info);
+
+/* Subroutine */ int zpbtrs_(char *uplo, integer *n, integer *kd, integer *
+			     nrhs, doublecomplex *ab, integer *ldab, doublecomplex *b, integer *
+			     ldb, integer *info);
+
+/* Subroutine */ int zpftrf_(char *transr, char *uplo, integer *n, 
+			     doublecomplex *a, integer *info);
+
+/* Subroutine */ int zpftri_(char *transr, char *uplo, integer *n, 
+			     doublecomplex *a, integer *info);
+
+/* Subroutine */ int zpftrs_(char *transr, char *uplo, integer *n, integer *
+			     nrhs, doublecomplex *a, doublecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int zpocon_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, doublereal *anorm, doublereal *rcond, doublecomplex *
+			     work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zpoequ_(integer *n, doublecomplex *a, integer *lda, 
+			     doublereal *s, doublereal *scond, doublereal *amax, integer *info);
+
+/* Subroutine */ int zpoequb_(integer *n, doublecomplex *a, integer *lda, 
+			      doublereal *s, doublereal *scond, doublereal *amax, integer *info);
+
+/* Subroutine */ int zporfs_(char *uplo, integer *n, integer *nrhs, 
+			     doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, 
+			     doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, 
+			     doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *
+			     rwork, integer *info);
+
+/* Subroutine */ int zporfsx_(char *uplo, char *equed, integer *n, integer *
+			      nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *
+			      ldaf, doublereal *s, doublecomplex *b, integer *ldb, doublecomplex *x, 
+			      integer *ldx, doublereal *rcond, doublereal *berr, integer *
+			      n_err_bnds__, doublereal *err_bnds_norm__, doublereal *
+			      err_bnds_comp__, integer *nparams, doublereal *params, doublecomplex *
+			      work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zposv_(char *uplo, integer *n, integer *nrhs, 
+			    doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			    integer *info);
+
+/* Subroutine */ int zposvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *
+			     ldaf, char *equed, doublereal *s, doublecomplex *b, integer *ldb, 
+			     doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *ferr, 
+			     doublereal *berr, doublecomplex *work, doublereal *rwork, integer *
+			     info);
+
+/* Subroutine */ int zposvxx_(char *fact, char *uplo, integer *n, integer *
+			      nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *
+			      ldaf, char *equed, doublereal *s, doublecomplex *b, integer *ldb, 
+			      doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *rpvgrw, 
+			      doublereal *berr, integer *n_err_bnds__, doublereal *err_bnds_norm__, 
+			      doublereal *err_bnds_comp__, integer *nparams, doublereal *params, 
+			      doublecomplex *work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zpotf2_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, integer *info);
+
+/* Subroutine */ int zpotrf_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, integer *info);
+
+/* Subroutine */ int zpotri_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, integer *info);
+
+/* Subroutine */ int zpotrs_(char *uplo, integer *n, integer *nrhs, 
+			     doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			     integer *info);
+
+/* Subroutine */ int zppcon_(char *uplo, integer *n, doublecomplex *ap, 
+			     doublereal *anorm, doublereal *rcond, doublecomplex *work, doublereal 
+			     *rwork, integer *info);
+
+/* Subroutine */ int zppequ_(char *uplo, integer *n, doublecomplex *ap, 
+			     doublereal *s, doublereal *scond, doublereal *amax, integer *info);
+
+/* Subroutine */ int zpprfs_(char *uplo, integer *n, integer *nrhs, 
+			     doublecomplex *ap, doublecomplex *afp, doublecomplex *b, integer *ldb, 
+			     doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, 
+			     doublecomplex *work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zppsv_(char *uplo, integer *n, integer *nrhs, 
+			    doublecomplex *ap, doublecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int zppsvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, doublecomplex *ap, doublecomplex *afp, char *equed, doublereal *
+			     s, doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, 
+			     doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex *
+			     work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zpptrf_(char *uplo, integer *n, doublecomplex *ap, 
+			     integer *info);
+
+/* Subroutine */ int zpptri_(char *uplo, integer *n, doublecomplex *ap, 
+			     integer *info);
+
+/* Subroutine */ int zpptrs_(char *uplo, integer *n, integer *nrhs, 
+			     doublecomplex *ap, doublecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int zpstf2_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, integer *piv, integer *rank, doublereal *tol, 
+			     doublereal *work, integer *info);
+
+/* Subroutine */ int zpstrf_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, integer *piv, integer *rank, doublereal *tol, 
+			     doublereal *work, integer *info);
+
+/* Subroutine */ int zptcon_(integer *n, doublereal *d__, doublecomplex *e, 
+			     doublereal *anorm, doublereal *rcond, doublereal *rwork, integer *
+			     info);
+
+/* Subroutine */ int zpteqr_(char *compz, integer *n, doublereal *d__, 
+			     doublereal *e, doublecomplex *z__, integer *ldz, doublereal *work, 
+			     integer *info);
+
+/* Subroutine */ int zptrfs_(char *uplo, integer *n, integer *nrhs, 
+			     doublereal *d__, doublecomplex *e, doublereal *df, doublecomplex *ef, 
+			     doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, 
+			     doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *
+			     rwork, integer *info);
+
+/* Subroutine */ int zptsv_(integer *n, integer *nrhs, doublereal *d__, 
+			    doublecomplex *e, doublecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int zptsvx_(char *fact, integer *n, integer *nrhs, 
+			     doublereal *d__, doublecomplex *e, doublereal *df, doublecomplex *ef, 
+			     doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, 
+			     doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex *
+			     work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zpttrf_(integer *n, doublereal *d__, doublecomplex *e, 
+			     integer *info);
+
+/* Subroutine */ int zpttrs_(char *uplo, integer *n, integer *nrhs, 
+			     doublereal *d__, doublecomplex *e, doublecomplex *b, integer *ldb, 
+			     integer *info);
+
+/* Subroutine */ int zptts2_(integer *iuplo, integer *n, integer *nrhs, 
+			     doublereal *d__, doublecomplex *e, doublecomplex *b, integer *ldb);
+
+/* Subroutine */ int zrot_(integer *n, doublecomplex *cx, integer *incx, 
+			   doublecomplex *cy, integer *incy, doublereal *c__, doublecomplex *s);
+
+/* Subroutine */ int zspcon_(char *uplo, integer *n, doublecomplex *ap, 
+			     integer *ipiv, doublereal *anorm, doublereal *rcond, doublecomplex *
+			     work, integer *info);
+
+/* Subroutine */ int zspmv_(char *uplo, integer *n, doublecomplex *alpha, 
+			    doublecomplex *ap, doublecomplex *x, integer *incx, doublecomplex *
+			    beta, doublecomplex *y, integer *incy);
+
+/* Subroutine */ int zspr_(char *uplo, integer *n, doublecomplex *alpha, 
+			   doublecomplex *x, integer *incx, doublecomplex *ap);
+
+/* Subroutine */ int zsprfs_(char *uplo, integer *n, integer *nrhs, 
+			     doublecomplex *ap, doublecomplex *afp, integer *ipiv, doublecomplex *
+			     b, integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, 
+			     doublereal *berr, doublecomplex *work, doublereal *rwork, integer *
+			     info);
+
+/* Subroutine */ int zspsv_(char *uplo, integer *n, integer *nrhs, 
+			    doublecomplex *ap, integer *ipiv, doublecomplex *b, integer *ldb, 
+			    integer *info);
+
+/* Subroutine */ int zspsvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, doublecomplex *ap, doublecomplex *afp, integer *ipiv, 
+			     doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, 
+			     doublereal *rcond, doublereal *ferr, doublereal *berr, doublecomplex *
+			     work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zsptrf_(char *uplo, integer *n, doublecomplex *ap, 
+			     integer *ipiv, integer *info);
+
+/* Subroutine */ int zsptri_(char *uplo, integer *n, doublecomplex *ap, 
+			     integer *ipiv, doublecomplex *work, integer *info);
+
+/* Subroutine */ int zsptrs_(char *uplo, integer *n, integer *nrhs, 
+			     doublecomplex *ap, integer *ipiv, doublecomplex *b, integer *ldb, 
+			     integer *info);
+
+/* Subroutine */ int zstedc_(char *compz, integer *n, doublereal *d__, 
+			     doublereal *e, doublecomplex *z__, integer *ldz, doublecomplex *work, 
+			     integer *lwork, doublereal *rwork, integer *lrwork, integer *iwork, 
+			     integer *liwork, integer *info);
+
+/* Subroutine */ int zstegr_(char *jobz, char *range, integer *n, doublereal *
+			     d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, 
+			     integer *iu, doublereal *abstol, integer *m, doublereal *w, 
+			     doublecomplex *z__, integer *ldz, integer *isuppz, doublereal *work, 
+			     integer *lwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int zstein_(integer *n, doublereal *d__, doublereal *e, 
+			     integer *m, doublereal *w, integer *iblock, integer *isplit, 
+			     doublecomplex *z__, integer *ldz, doublereal *work, integer *iwork, 
+			     integer *ifail, integer *info);
+
+/* Subroutine */ int zstemr_(char *jobz, char *range, integer *n, doublereal *
+			     d__, doublereal *e, doublereal *vl, doublereal *vu, integer *il, 
+			     integer *iu, integer *m, doublereal *w, doublecomplex *z__, integer *
+			     ldz, integer *nzc, integer *isuppz, logical *tryrac, doublereal *work, 
+			     integer *lwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int zsteqr_(char *compz, integer *n, doublereal *d__, 
+			     doublereal *e, doublecomplex *z__, integer *ldz, doublereal *work, 
+			     integer *info);
+
+/* Subroutine */ int zsycon_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, integer *ipiv, doublereal *anorm, doublereal *rcond, 
+			     doublecomplex *work, integer *info);
+
+/* Subroutine */ int zsyequb_(char *uplo, integer *n, doublecomplex *a, 
+			      integer *lda, doublereal *s, doublereal *scond, doublereal *amax, 
+			      doublecomplex *work, integer *info);
+
+/* Subroutine */ int zsymv_(char *uplo, integer *n, doublecomplex *alpha, 
+			    doublecomplex *a, integer *lda, doublecomplex *x, integer *incx, 
+			    doublecomplex *beta, doublecomplex *y, integer *incy);
+
+/* Subroutine */ int zsyr_(char *uplo, integer *n, doublecomplex *alpha, 
+			   doublecomplex *x, integer *incx, doublecomplex *a, integer *lda);
+
+/* Subroutine */ int zsyrfs_(char *uplo, integer *n, integer *nrhs, 
+			     doublecomplex *a, integer *lda, doublecomplex *af, integer *ldaf, 
+			     integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, 
+			     integer *ldx, doublereal *ferr, doublereal *berr, doublecomplex *work, 
+			     doublereal *rwork, integer *info);
+
+/* Subroutine */ int zsyrfsx_(char *uplo, char *equed, integer *n, integer *
+			      nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *
+			      ldaf, integer *ipiv, doublereal *s, doublecomplex *b, integer *ldb, 
+			      doublecomplex *x, integer *ldx, doublereal *rcond, doublereal *berr, 
+			      integer *n_err_bnds__, doublereal *err_bnds_norm__, doublereal *
+			      err_bnds_comp__, integer *nparams, doublereal *params, doublecomplex *
+			      work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zsysv_(char *uplo, integer *n, integer *nrhs, 
+			    doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, 
+			    integer *ldb, doublecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int zsysvx_(char *fact, char *uplo, integer *n, integer *
+			     nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *
+			     ldaf, integer *ipiv, doublecomplex *b, integer *ldb, doublecomplex *x, 
+			     integer *ldx, doublereal *rcond, doublereal *ferr, doublereal *berr, 
+			     doublecomplex *work, integer *lwork, doublereal *rwork, integer *info);
+
+/* Subroutine */ int zsysvxx_(char *fact, char *uplo, integer *n, integer *
+			      nrhs, doublecomplex *a, integer *lda, doublecomplex *af, integer *
+			      ldaf, integer *ipiv, char *equed, doublereal *s, doublecomplex *b, 
+			      integer *ldb, doublecomplex *x, integer *ldx, doublereal *rcond, 
+			      doublereal *rpvgrw, doublereal *berr, integer *n_err_bnds__, 
+			      doublereal *err_bnds_norm__, doublereal *err_bnds_comp__, integer *
+			      nparams, doublereal *params, doublecomplex *work, doublereal *rwork, 
+			      integer *info);
+
+/* Subroutine */ int zsytf2_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, integer *ipiv, integer *info);
+
+/* Subroutine */ int zsytrf_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, integer *ipiv, doublecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int zsytri_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, integer *ipiv, doublecomplex *work, integer *info);
+
+/* Subroutine */ int zsytrs_(char *uplo, integer *n, integer *nrhs, 
+			     doublecomplex *a, integer *lda, integer *ipiv, doublecomplex *b, 
+			     integer *ldb, integer *info);
+
+/* Subroutine */ int ztbcon_(char *norm, char *uplo, char *diag, integer *n, 
+			     integer *kd, doublecomplex *ab, integer *ldab, doublereal *rcond, 
+			     doublecomplex *work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int ztbrfs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *kd, integer *nrhs, doublecomplex *ab, integer *ldab, 
+			     doublecomplex *b, integer *ldb, doublecomplex *x, integer *ldx, 
+			     doublereal *ferr, doublereal *berr, doublecomplex *work, doublereal *
+			     rwork, integer *info);
+
+/* Subroutine */ int ztbtrs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *kd, integer *nrhs, doublecomplex *ab, integer *ldab, 
+			     doublecomplex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int ztfsm_(char *transr, char *side, char *uplo, char *trans, 
+			    char *diag, integer *m, integer *n, doublecomplex *alpha, 
+			    doublecomplex *a, doublecomplex *b, integer *ldb);
+
+/* Subroutine */ int ztftri_(char *transr, char *uplo, char *diag, integer *n, 
+			     doublecomplex *a, integer *info);
+
+/* Subroutine */ int ztfttp_(char *transr, char *uplo, integer *n, 
+			     doublecomplex *arf, doublecomplex *ap, integer *info);
+
+/* Subroutine */ int ztfttr_(char *transr, char *uplo, integer *n, 
+			     doublecomplex *arf, doublecomplex *a, integer *lda, integer *info);
+
+/* Subroutine */ int ztgevc_(char *side, char *howmny, logical *select, 
+			     integer *n, doublecomplex *s, integer *lds, doublecomplex *p, integer 
+			     *ldp, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *
+			     ldvr, integer *mm, integer *m, doublecomplex *work, doublereal *rwork, 
+			     integer *info);
+
+/* Subroutine */ int ztgex2_(logical *wantq, logical *wantz, integer *n, 
+			     doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			     doublecomplex *q, integer *ldq, doublecomplex *z__, integer *ldz, 
+			     integer *j1, integer *info);
+
+/* Subroutine */ int ztgexc_(logical *wantq, logical *wantz, integer *n, 
+			     doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			     doublecomplex *q, integer *ldq, doublecomplex *z__, integer *ldz, 
+			     integer *ifst, integer *ilst, integer *info);
+
+/* Subroutine */ int ztgsen_(integer *ijob, logical *wantq, logical *wantz, 
+			     logical *select, integer *n, doublecomplex *a, integer *lda, 
+			     doublecomplex *b, integer *ldb, doublecomplex *alpha, doublecomplex *
+			     beta, doublecomplex *q, integer *ldq, doublecomplex *z__, integer *
+			     ldz, integer *m, doublereal *pl, doublereal *pr, doublereal *dif, 
+			     doublecomplex *work, integer *lwork, integer *iwork, integer *liwork, 
+			     integer *info);
+
+/* Subroutine */ int ztgsja_(char *jobu, char *jobv, char *jobq, integer *m, 
+			     integer *p, integer *n, integer *k, integer *l, doublecomplex *a, 
+			     integer *lda, doublecomplex *b, integer *ldb, doublereal *tola, 
+			     doublereal *tolb, doublereal *alpha, doublereal *beta, doublecomplex *
+			     u, integer *ldu, doublecomplex *v, integer *ldv, doublecomplex *q, 
+			     integer *ldq, doublecomplex *work, integer *ncycle, integer *info);
+
+/* Subroutine */ int ztgsna_(char *job, char *howmny, logical *select, 
+			     integer *n, doublecomplex *a, integer *lda, doublecomplex *b, integer 
+			     *ldb, doublecomplex *vl, integer *ldvl, doublecomplex *vr, integer *
+			     ldvr, doublereal *s, doublereal *dif, integer *mm, integer *m, 
+			     doublecomplex *work, integer *lwork, integer *iwork, integer *info);
+
+/* Subroutine */ int ztgsy2_(char *trans, integer *ijob, integer *m, integer *
+			     n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			     doublecomplex *c__, integer *ldc, doublecomplex *d__, integer *ldd, 
+			     doublecomplex *e, integer *lde, doublecomplex *f, integer *ldf, 
+			     doublereal *scale, doublereal *rdsum, doublereal *rdscal, integer *
+			     info);
+
+/* Subroutine */ int ztgsyl_(char *trans, integer *ijob, integer *m, integer *
+			     n, doublecomplex *a, integer *lda, doublecomplex *b, integer *ldb, 
+			     doublecomplex *c__, integer *ldc, doublecomplex *d__, integer *ldd, 
+			     doublecomplex *e, integer *lde, doublecomplex *f, integer *ldf, 
+			     doublereal *scale, doublereal *dif, doublecomplex *work, integer *
+			     lwork, integer *iwork, integer *info);
+
+/* Subroutine */ int ztpcon_(char *norm, char *uplo, char *diag, integer *n, 
+			     doublecomplex *ap, doublereal *rcond, doublecomplex *work, doublereal 
+			     *rwork, integer *info);
+
+/* Subroutine */ int ztprfs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, doublecomplex *ap, doublecomplex *b, integer *ldb, 
+			     doublecomplex *x, integer *ldx, doublereal *ferr, doublereal *berr, 
+			     doublecomplex *work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int ztptri_(char *uplo, char *diag, integer *n, 
+			     doublecomplex *ap, integer *info);
+
+/* Subroutine */ int ztptrs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, doublecomplex *ap, doublecomplex *b, integer *ldb, 
+			     integer *info);
+
+/* Subroutine */ int ztpttf_(char *transr, char *uplo, integer *n, 
+			     doublecomplex *ap, doublecomplex *arf, integer *info);
+
+/* Subroutine */ int ztpttr_(char *uplo, integer *n, doublecomplex *ap, 
+			     doublecomplex *a, integer *lda, integer *info);
+
+/* Subroutine */ int ztrcon_(char *norm, char *uplo, char *diag, integer *n, 
+			     doublecomplex *a, integer *lda, doublereal *rcond, doublecomplex *
+			     work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int ztrevc_(char *side, char *howmny, logical *select, 
+			     integer *n, doublecomplex *t, integer *ldt, doublecomplex *vl, 
+			     integer *ldvl, doublecomplex *vr, integer *ldvr, integer *mm, integer 
+			     *m, doublecomplex *work, doublereal *rwork, integer *info);
+
+/* Subroutine */ int ztrexc_(char *compq, integer *n, doublecomplex *t, 
+			     integer *ldt, doublecomplex *q, integer *ldq, integer *ifst, integer *
+			     ilst, integer *info);
+
+/* Subroutine */ int ztrrfs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *b, 
+			     integer *ldb, doublecomplex *x, integer *ldx, doublereal *ferr, 
+			     doublereal *berr, doublecomplex *work, doublereal *rwork, integer *
+			     info);
+
+/* Subroutine */ int ztrsen_(char *job, char *compq, logical *select, integer 
+			     *n, doublecomplex *t, integer *ldt, doublecomplex *q, integer *ldq, 
+			     doublecomplex *w, integer *m, doublereal *s, doublereal *sep, 
+			     doublecomplex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int ztrsna_(char *job, char *howmny, logical *select, 
+			     integer *n, doublecomplex *t, integer *ldt, doublecomplex *vl, 
+			     integer *ldvl, doublecomplex *vr, integer *ldvr, doublereal *s, 
+			     doublereal *sep, integer *mm, integer *m, doublecomplex *work, 
+			     integer *ldwork, doublereal *rwork, integer *info);
+
+/* Subroutine */ int ztrsyl_(char *trana, char *tranb, integer *isgn, integer 
+			     *m, integer *n, doublecomplex *a, integer *lda, doublecomplex *b, 
+			     integer *ldb, doublecomplex *c__, integer *ldc, doublereal *scale, 
+			     integer *info);
+
+/* Subroutine */ int ztrti2_(char *uplo, char *diag, integer *n, 
+			     doublecomplex *a, integer *lda, integer *info);
+
+/* Subroutine */ int ztrtri_(char *uplo, char *diag, integer *n, 
+			     doublecomplex *a, integer *lda, integer *info);
+
+/* Subroutine */ int ztrtrs_(char *uplo, char *trans, char *diag, integer *n, 
+			     integer *nrhs, doublecomplex *a, integer *lda, doublecomplex *b, 
+			     integer *ldb, integer *info);
+
+/* Subroutine */ int ztrttf_(char *transr, char *uplo, integer *n, 
+			     doublecomplex *a, integer *lda, doublecomplex *arf, integer *info);
+
+/* Subroutine */ int ztrttp_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, doublecomplex *ap, integer *info);
+
+/* Subroutine */ int ztzrqf_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, doublecomplex *tau, integer *info);
+
+/* Subroutine */ int ztzrzf_(integer *m, integer *n, doublecomplex *a, 
+			     integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int zung2l_(integer *m, integer *n, integer *k, 
+			     doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
+			     work, integer *info);
+
+/* Subroutine */ int zung2r_(integer *m, integer *n, integer *k, 
+			     doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
+			     work, integer *info);
+
+/* Subroutine */ int zungbr_(char *vect, integer *m, integer *n, integer *k, 
+			     doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
+			     work, integer *lwork, integer *info);
+
+/* Subroutine */ int zunghr_(integer *n, integer *ilo, integer *ihi, 
+			     doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
+			     work, integer *lwork, integer *info);
+
+/* Subroutine */ int zungl2_(integer *m, integer *n, integer *k, 
+			     doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
+			     work, integer *info);
+
+/* Subroutine */ int zunglq_(integer *m, integer *n, integer *k, 
+			     doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
+			     work, integer *lwork, integer *info);
+
+/* Subroutine */ int zungql_(integer *m, integer *n, integer *k, 
+			     doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
+			     work, integer *lwork, integer *info);
+
+/* Subroutine */ int zungqr_(integer *m, integer *n, integer *k, 
+			     doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
+			     work, integer *lwork, integer *info);
+
+/* Subroutine */ int zungr2_(integer *m, integer *n, integer *k, 
+			     doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
+			     work, integer *info);
+
+/* Subroutine */ int zungrq_(integer *m, integer *n, integer *k, 
+			     doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
+			     work, integer *lwork, integer *info);
+
+/* Subroutine */ int zungtr_(char *uplo, integer *n, doublecomplex *a, 
+			     integer *lda, doublecomplex *tau, doublecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int zunm2l_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, 
+			     doublecomplex *c__, integer *ldc, doublecomplex *work, integer *info);
+
+/* Subroutine */ int zunm2r_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, 
+			     doublecomplex *c__, integer *ldc, doublecomplex *work, integer *info);
+
+/* Subroutine */ int zunmbr_(char *vect, char *side, char *trans, integer *m, 
+			     integer *n, integer *k, doublecomplex *a, integer *lda, doublecomplex 
+			     *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *
+			     lwork, integer *info);
+
+/* Subroutine */ int zunmhr_(char *side, char *trans, integer *m, integer *n, 
+			     integer *ilo, integer *ihi, doublecomplex *a, integer *lda, 
+			     doublecomplex *tau, doublecomplex *c__, integer *ldc, doublecomplex *
+			     work, integer *lwork, integer *info);
+
+/* Subroutine */ int zunml2_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, 
+			     doublecomplex *c__, integer *ldc, doublecomplex *work, integer *info);
+
+/* Subroutine */ int zunmlq_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, 
+			     doublecomplex *c__, integer *ldc, doublecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int zunmql_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, 
+			     doublecomplex *c__, integer *ldc, doublecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int zunmqr_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, 
+			     doublecomplex *c__, integer *ldc, doublecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int zunmr2_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, 
+			     doublecomplex *c__, integer *ldc, doublecomplex *work, integer *info);
+
+/* Subroutine */ int zunmr3_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, integer *l, doublecomplex *a, integer *lda, doublecomplex 
+			     *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *
+			     info);
+
+/* Subroutine */ int zunmrq_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, doublecomplex *a, integer *lda, doublecomplex *tau, 
+			     doublecomplex *c__, integer *ldc, doublecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int zunmrz_(char *side, char *trans, integer *m, integer *n, 
+			     integer *k, integer *l, doublecomplex *a, integer *lda, doublecomplex 
+			     *tau, doublecomplex *c__, integer *ldc, doublecomplex *work, integer *
+			     lwork, integer *info);
+
+/* Subroutine */ int zunmtr_(char *side, char *uplo, char *trans, integer *m, 
+			     integer *n, doublecomplex *a, integer *lda, doublecomplex *tau, 
+			     doublecomplex *c__, integer *ldc, doublecomplex *work, integer *lwork, 
+			     integer *info);
+
+/* Subroutine */ int zupgtr_(char *uplo, integer *n, doublecomplex *ap, 
+			     doublecomplex *tau, doublecomplex *q, integer *ldq, doublecomplex *
+			     work, integer *info);
+
+/* Subroutine */ int zupmtr_(char *side, char *uplo, char *trans, integer *m, 
+			     integer *n, doublecomplex *ap, doublecomplex *tau, doublecomplex *c__, 
+			     integer *ldc, doublecomplex *work, integer *info);
+
+/* Subroutine */ int dlamc1_(integer *beta, integer *t, logical *rnd, logical 
+			     *ieee1);
+
+doublereal dsecnd_();
+
+/* Subroutine */ int ilaver_(integer *vers_major__, integer *vers_minor__, 
+			     integer *vers_patch__);
+
+logical lsame_(char *ca, char *cb);
+
+doublereal second_();
+
+doublereal slamch_(char *cmach);
+
+/* Subroutine */ int slamc1_(integer *beta, integer *t, logical *rnd, logical 
+			     *ieee1);
+
+/* Subroutine */ int slamc2_(integer *beta, integer *t, logical *rnd, real *
+			     eps, integer *emin, real *rmin, integer *emax, real *rmax);
+
+doublereal slamc3_(real *a, real *b);
+
+/* Subroutine */ int slamc4_(integer *emin, real *start, integer *base);
+
+/* Subroutine */ int slamc5_(integer *beta, integer *p, integer *emin,
+			     logical *ieee, integer *emax, real *rmax);
+
+
+doublereal dlamch_(char *cmach);
+
+/* Subroutine */ int dlamc1_(integer *beta, integer *t, logical *rnd, logical
+			     *ieee1);
+
+/* Subroutine */ int dlamc2_(integer *beta, integer *t, logical *rnd,
+			     doublereal *eps, integer *emin, doublereal *rmin, integer *emax,
+			     doublereal *rmax);
+
+doublereal dlamc3_(doublereal *a, doublereal *b);
+
+/* Subroutine */ int dlamc4_(integer *emin, doublereal *start, integer *base);
+
+/* Subroutine */ int dlamc5_(integer *beta, integer *p, integer *emin,
+			     logical *ieee, integer *emax, doublereal *rmax);
+
+integer ilaenv_(integer *ispec, char *name__, char *opts, integer *n1, 
+		integer *n2, integer *n3, integer *n4);
+
+
+#endif /* __CLAPACK_H */
diff --git a/nanoblas/src/inverse.hpp b/nanoblas/src/inverse.hpp
new file mode 100644
index 000000000..87ffbc5e8
--- /dev/null
+++ b/nanoblas/src/inverse.hpp
@@ -0,0 +1,86 @@
+#ifndef INVERSE_HPP
+#define INVERSE_HPP
+
+#include <vector>
+#include <utility>
+
+#include <matrix.hpp>
+
+namespace nanoblas {
+
+  template <typename T>  
+  void calcInverse(MatrixView<T> mat) 
+  {
+    if (mat.rows() != mat.cols())
+      throw std::invalid_argument("Matrix must be square to compute its inverse.");
+
+    size_t n = mat.rows();
+
+    std::vector<int> p(n);   // pivot-permutation
+    for (size_t j = 0; j < n; j++) p[j] = j;
+
+    for (size_t j = 0; j < n; j++)
+      {
+	// pivot search
+	double maxval = abs(mat(j,j));
+	size_t r = j;
+
+	for (size_t i = j+1; i < n; i++)
+	  if (abs (mat(j, i)) > maxval)
+	    {
+	      r = i;
+	      maxval = abs (mat(r, i));
+	    }
+      
+        double rest = 0.0;
+        for (size_t i = j+1; i < n; i++)
+          rest += abs(mat(r, i));
+	if (maxval < 1e-20*rest)
+          throw std::runtime_error("Inverse matrix: Matrix singular");
+
+
+	// exchange rows
+	if (r > j)
+	  {
+	    for (size_t k = 0; k < n; k++)
+	      std::swap (mat(k, j), mat(k, r));
+	    std::swap (p[j], p[r]);
+	  }
+      
+
+	// transformation
+	
+	T hr = 1.0 / mat(j,j);
+	for (size_t i = 0; i < n; i++)
+          mat(j,i) *= hr;
+	mat(j,j) = hr;
+
+	for (size_t k = 0; k < n; k++)
+	  if (k != j)
+	    {
+	      T help = mat(k,j);
+	      T h = help * hr;   
+
+	      for (size_t i = 0; i < n; i++)
+                mat(k,i) -= help * mat(j,i); 
+
+	      mat(k,j) = -h;
+	    }
+      }
+
+    // row exchange
+    std::vector<T> hv(n);
+    for (size_t i = 0; i < n; i++)
+      {
+	for (size_t k = 0; k < n; k++) hv[p[k]] = mat(k, i);
+	for (size_t k = 0; k < n; k++) mat(k, i) = hv[k];
+      }
+
+  }
+
+
+}
+
+#endif
+
+
diff --git a/nanoblas/src/lapack_interface.hpp b/nanoblas/src/lapack_interface.hpp
new file mode 100644
index 000000000..aba307568
--- /dev/null
+++ b/nanoblas/src/lapack_interface.hpp
@@ -0,0 +1,218 @@
+#ifndef FILE_LAPACK_INTERFACE_H
+#define FILE_LAPACK_INTERFACE_H
+
+#include <iostream>
+#include <string>
+#include <algorithm>
+
+#include "vector.hpp"
+#include "matrix.hpp"
+
+
+#include <complex>
+
+typedef int integer;
+typedef integer logical;
+typedef float real;
+typedef double doublereal;
+typedef std::complex<float> singlecomplex;
+typedef std::complex<double> doublecomplex;
+
+// Windows SDK defines VOID in the file WinNT.h
+#ifndef VOID
+typedef void VOID;
+#endif
+typedef int ftnlen;
+typedef int L_fp;  // ?
+
+
+extern "C" {
+#include <clapack.h>
+}
+
+
+
+
+namespace nanoblas
+{
+  
+  // BLAS-1 functions:
+
+  /*
+    int daxpy_(integer *n, doublereal *da, doublereal *dx, 
+    integer *incx, doublereal *dy, integer *incy);
+  */
+  // y += alpha x
+  template <typename SX, typename SY>
+  void AddVectorLapack (double alpha, VectorView<double,SX> x, VectorView<double,SY> y)
+  {
+    integer n = x.size();
+    integer incx = x.dist();
+    integer incy = y.dist();
+    daxpy_ (&n, &alpha, &x(0),  &incx, &y(0), &incy);
+  }
+  
+  
+  // BLAS-2 functions:
+  // int dgemv_ (char *trans, integer *m, integer *n, doublereal *alpha,
+  //             doublereal *a, integer *lda, doublereal *x, integer *incx,
+  //             doublereal *beta, doublereal *y, integer *incy);
+
+  // y = alpha*A*x + beta*y
+  template <typename T, ORDERING ORD>
+  void MultMatVecLapack (double alpha,
+                         MatrixView<T,ORD> a, 
+                         VectorView<T,size_t> x, 
+                         double beta, 
+                         VectorView<T,size_t> y)
+  {
+    char transa = (ORD == ColMajor) ? 'N' : 'T';
+
+    integer n = a.rows();
+    integer m = a.cols();
+    integer lda = std::max<size_t>(a.dist(), 1);
+
+    integer dx = std::max<size_t>(x.dist(), 1);
+    integer dy = std::max<size_t>(y.dist(), 1);
+
+    int err =
+      dgemv_(&transa,
+             &n, &m,
+             &alpha,
+             a.data(), &lda,
+             x.data(), &dx,
+             &beta,
+             y.data(), &dy);
+  }
+   
+  // BLAS-3 functions:
+  // overload for float, double and comlex<double>
+  
+  inline int gemm(char *transa, char *transb, integer *m, integer *
+                  n, integer *k, real *alpha, real *a, integer *lda,
+                  real *b, integer *ldb, real *beta, real *c__,
+                  integer *ldc)
+  {
+    return sgemm_ (transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c__, ldc);
+  }
+  
+  inline int gemm(char *transa, char *transb, integer *m, integer *
+                  n, integer *k, doublereal *alpha, doublereal *a, integer *lda,
+                  doublereal *b, integer *ldb, doublereal *beta, doublereal *c__,
+                  integer *ldc)
+  {
+    return dgemm_ (transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c__, ldc);
+  }
+  
+  inline int gemm(char *transa, char *transb, integer *m, integer *
+                  n, integer *k, doublecomplex *alpha, doublecomplex *a, integer *lda,
+                  doublecomplex *b, integer *ldb, doublecomplex *beta, doublecomplex *
+                  c__, integer *ldc)
+  {
+    return zgemm_ (transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c__, ldc);
+  }
+
+
+
+  // c = a*b
+  template <typename T, ORDERING OA, ORDERING OB>
+  void MultMatMatLapack (MatrixView<T, OA> a,
+                         MatrixView<T, OB> b,
+                         MatrixView<T, ColMajor> c)
+  {
+    char transa_ = (OA == ColMajor) ? 'N' : 'T';
+    char transb_ = (OB == ColMajor) ? 'N' : 'T'; 
+  
+    integer n = c.rows();
+    integer m = c.cols();
+    integer k = a.cols();
+  
+    double alpha = 1.0;
+    double beta = 0;
+    integer lda = std::max<size_t>(a.dist(), 1);
+    integer ldb = std::max<size_t>(b.dist(), 1);
+    integer ldc = std::max<size_t>(c.dist(), 1);
+
+    int err =
+      gemm (&transa_, &transb_, &n, &m, &k, &alpha, 
+            a.data(), &lda, b.data(), &ldb, &beta, c.data(), &ldc);
+
+    if (err != 0)
+      throw std::runtime_error(std::string("MultMatMat got error "+std::to_string(err)));
+  }
+                       
+  template <ORDERING OA, ORDERING OB>
+  void MultMatMatLapack (MatrixView<double, OA> a,
+                         MatrixView<double, OB> b,
+                         MatrixView<double, RowMajor> c)
+  {
+    MultMatMatLapack (trans(b), trans(a), trans(c));
+  }
+
+
+  
+
+  template <ORDERING ORD>
+  class LapackLU {
+    Matrix <double, ORD> a;
+    std::vector<integer> ipiv;
+    
+  public:
+    LapackLU (Matrix<double,ORD> _a)
+      : a(std::move(_a)), ipiv(a.rows()) {
+      integer m = a.rows();
+      if (m == 0) return;
+      integer n = a.cols();
+      integer lda = a.dist();
+      integer info;
+    
+      // int dgetrf_(integer *m, integer *n, doublereal *a, 
+      //             integer * lda, integer *ipiv, integer *info);
+
+      dgetrf_(&n, &m, &a(0,0), &lda, &ipiv[0], &info);
+    }
+    
+    // b overwritten with A^{-1} b
+    void solve (VectorView<double> b) const {
+      char transa =  (ORD == ColMajor) ? 'N' : 'T';
+      integer n = a.rows();
+      integer nrhs = 1;
+      integer lda = a.dist();
+      integer ldb = b.size();
+      integer info;
+
+      // int dgetrs_(char *trans, integer *n, integer *nrhs, 
+      //             doublereal *a, integer *lda, integer *ipiv,
+      //             doublereal *b, integer *ldb, integer *info);
+
+      dgetrs_(&transa, &n, &nrhs, a.data(), &lda, (integer*)ipiv.data(), b.data(), &ldb, &info);
+    }
+  
+    Matrix<double,ORD> inverse() && {
+      double hwork;
+      integer lwork = -1;
+      integer n = a.rows();      
+      integer lda = a.dist();
+      integer info;
+
+      // int dgetri_(integer *n, doublereal *a, integer *lda, 
+      //             integer *ipiv, doublereal *work, integer *lwork, 
+      //             integer *info);
+
+      // query work-size
+      dgetri_(&n, &a(0,0), &lda, ipiv.data(), &hwork, &lwork, &info);
+      lwork = integer(hwork);
+      std::vector<double> work(lwork);
+      dgetri_(&n, &a(0,0), &lda, ipiv.data(), &work[0], &lwork, &info);
+      return std::move(a);      
+    }
+
+    // Matrix<double,ORD> LFactor() const { ... }
+    // Matrix<double,ORD> UFactor() const { ... }
+    // Matrix<double,ORD> PFactor() const { ... }
+  };
+  
+}
+
+
+#endif
diff --git a/nanoblas/src/matexpr.hpp b/nanoblas/src/matexpr.hpp
new file mode 100644
index 000000000..2c0164d62
--- /dev/null
+++ b/nanoblas/src/matexpr.hpp
@@ -0,0 +1,170 @@
+#ifndef FILE_MATEXPR
+#define FILE_MATEXPR
+
+#include <cstddef>
+#include <iostream>
+
+#include "vecexpr.hpp"
+
+namespace nanoblas
+{
+
+  /*
+    Expression templates for matrix expressions
+    and matrix-vector expressions
+  */
+  
+  
+  // base class for all matrix expressions
+  
+  template <typename T>
+  class MatExpr
+  {
+  public:
+    auto derived() const { return static_cast<const T&> (*this); }
+    size_t rows() const { return derived().rows(); }
+    size_t cols() const { return derived().cols(); }
+    auto shape() const { return derived().shape(); }
+    auto operator() (size_t i, size_t j) const { return derived()(i,j); }
+  };
+  
+  // ************************* output operator *******************
+  
+  template <typename TM>
+  std::ostream & operator<< (std::ostream & os, const MatExpr<TM> & m)
+  {
+    for (size_t i = 0; i < m.rows(); i++)
+      {
+        for (size_t j = 0; j < m.cols(); j++)
+          os << m(i,j) << " ";
+        os << std::endl;
+      }
+    return os;
+  }
+
+
+  // ************************* SumMatExpr *******************  
+
+  template <typename TA, typename TB>
+  class SumMatExpr : public MatExpr<SumMatExpr<TA,TB>>
+  {
+    TA a;
+    TB b;
+  public:
+    SumMatExpr (TA _a, TB _b) : a(_a), b(_b) { }
+    auto operator() (size_t i) const { return a(i)+b(i); }
+    size_t rows() const { return a.rows(); }
+    size_t cols() const { return a.cols(); }  
+    auto shape() const { return a.shape(); }    
+  };
+  
+  template <typename TA, typename TB>
+  auto operator+ (const MatExpr<TA>& a, const MatExpr<TB>& b)
+  {
+    assert(a.rows()==b.rows() && a.cols()==b.cols());
+    return SumMatExpr(a.derived(), b.derived());
+  }
+
+
+  // ************************ ScaleMatExpr *********************  
+  
+  
+  template <typename TSCAL, typename TM>
+  class ScaleMatExpr : public MatExpr<ScaleMatExpr<TSCAL,TM>>
+  {
+    TSCAL m_scal;
+    TM m_mat;
+  public:
+    ScaleMatExpr (TSCAL scal, TM mat) : m_scal(scal), m_mat(mat) { }
+    auto operator() (size_t i, size_t j) const { return m_scal*m_mat(i,j); }
+    size_t rows() const { return m_mat.rows(); }
+    size_t cols() const { return m_mat.cols(); }  
+  };
+
+
+  /*
+  // C++17 needs the enable_if workaround instead of the 'requires' concept syntax
+  template <typename TSCAL, typename T,
+            typename std::enable_if<isScalar<TSCAL>(),int>::type = 0>
+  */
+  template <typename TSCAL, typename T> requires (isScalar<TSCAL>())
+  auto operator* (TSCAL scal, const MatExpr<T>& m)
+  {
+    return ScaleMatExpr(scal, m.derived());
+  }
+  
+  
+
+  // ************************* MultMatMatExpr *******************
+  
+  template <typename TA, typename TB>
+  class MultMatMatExpr : public MatExpr<MultMatMatExpr<TA,TB>>
+  {
+    TA a;
+    TB b;
+  public:
+    MultMatMatExpr (TA _a, TB _b) : a(_a), b(_b) { }
+    size_t rows() const { return a.rows(); }
+    size_t cols() const { return b.cols(); }
+    auto shape() const { return std::array<size_t,2>{a.shape()[0], b.shape()[1]}; }
+    
+    // auto operator() (size_t i, size_t j) const { return dot(a.row(i), b.col(j)); }
+    auto operator() (size_t i, size_t j) const { 
+      using elemtypeA = std::invoke_result<TA,size_t,size_t>::type;
+      using elemtypeB = std::invoke_result<TB,size_t,size_t>::type;
+      using TSCAL = decltype(std::declval<elemtypeA>()*std::declval<elemtypeB>());
+      
+      TSCAL sum = 0;
+      for (size_t k = 0; k < a.cols(); k++)
+        sum += a(i,k) * b(k,j); 
+      return sum;
+    }
+
+    
+  };
+  
+  template <typename TA, typename TB>
+  auto operator* (const MatExpr<TA>& a, const MatExpr<TB>& b)
+  {
+    assert(a.cols()==b.rows());
+    return MultMatMatExpr<TA,TB>(a.derived(), b.derived());
+  }
+  
+
+
+  // ************************* MultMatVecExpr *******************
+  
+  template <typename TA, typename TB>
+  class MultMatVecExpr : public VecExpr<MultMatVecExpr<TA,TB>>
+  {
+    TA a;
+    TB b;
+  public:
+    MultMatVecExpr (TA _a, TB _b) : a(_a), b(_b) { }
+    size_t size() const { return a.rows(); }
+    
+    // auto operator() (size_t i) const { return dot(a.row(i), b); }
+    auto operator() (size_t i) const { 
+      using elemtypeA = std::invoke_result<TA,size_t,size_t>::type;
+      using elemtypeB = std::invoke_result<TB,size_t>::type;
+      using TSCAL = decltype(std::declval<elemtypeA>()*std::declval<elemtypeB>());
+      
+      TSCAL sum = 0;
+      for (size_t k = 0; k < a.cols(); k++)
+        sum += a(i,k) * b(k); 
+      return sum;
+    }
+    
+  };
+
+  template <typename TA, typename TB>
+  auto operator* (const MatExpr<TA>& a, const VecExpr<TB>& b)
+  {
+    assert(a.cols()==b.size());    
+    return MultMatVecExpr<TA,TB>(a.derived(), b.derived());
+  }
+ 
+
+} // namespace nanoblas
+
+#endif
diff --git a/nanoblas/src/matrix.hpp b/nanoblas/src/matrix.hpp
new file mode 100644
index 000000000..a5d739ed0
--- /dev/null
+++ b/nanoblas/src/matrix.hpp
@@ -0,0 +1,205 @@
+#ifndef FILE_MATRIX
+#define FILE_MATRIX
+
+#include "matexpr.hpp"
+#include "vector.hpp"
+
+namespace nanoblas
+{
+  
+  // enum ORDERING { RowMajor, ColMajor };
+
+  template <typename T, ORDERING ORD>
+  class MatrixView : public MatExpr<MatrixView<T,ORD>>
+  {
+  protected:
+    T* m_data;
+    size_t m_rows, m_cols;
+    size_t m_dist;
+
+    size_t index(size_t i, size_t j) const
+    {
+      return (ORD==RowMajor) ? i*m_dist+j : j*m_dist+i;
+    }
+  public:
+    MatrixView() = default;
+    MatrixView(const MatrixView &) = default;
+        
+    MatrixView (size_t rows, size_t cols, T* data)
+      : m_data(data), m_rows(rows), m_cols(cols)
+    {
+      m_dist = (ORD==RowMajor) ? m_cols : m_rows;
+    }
+    
+    MatrixView (size_t rows, size_t cols, size_t dist, T* data)
+      : m_data(data), m_rows(rows), m_cols(cols), m_dist(dist) { }
+    
+    template <typename TB, ORDERING ORD2>
+    MatrixView (const MatrixView<TB,ORD2>& m2)
+      : m_data(m2.data()), m_rows(m2.rows()), m_cols(m2.cols()), m_dist(m2.dist()) { }
+
+
+    MatrixView& operator= (const MatrixView& m2)
+    {
+      for (size_t i = 0; i < m_rows; i++)
+        for (size_t j = 0; j < m_cols; j++)
+          (*this)(i,j) = m2(i,j);
+      return *this;
+    }
+    
+    template <typename TB>
+    MatrixView& operator= (const MatExpr<TB>& m2)
+    {
+      for (size_t i = 0; i < m_rows; i++)
+        for (size_t j = 0; j < m_cols; j++)
+          (*this)(i,j) = m2(i,j);
+      return *this;
+    }
+        
+    MatrixView& operator= (T scal)
+    {
+      for (size_t i = 0; i < m_rows; i++)
+        for (size_t j = 0; j < m_cols; j++)
+          (*this)(i,j) = scal;
+      return *this;
+    }
+        
+    T* data() const { return m_data; }
+    size_t rows() const { return m_rows; }
+    size_t cols() const { return m_cols; }
+    size_t dist() const { return m_dist; }
+    auto shape() const { return std::array<size_t,2>{m_rows, m_cols}; }
+
+    T& operator()(size_t i, size_t j) 
+    { 
+      return m_data[index(i,j)];
+    }
+        
+    const T& operator()(size_t i, size_t j) const 
+    {
+      return m_data[index(i,j)];
+    }
+
+
+    template <typename TB>
+    MatrixView& operator+= (const MatExpr<TB>& m2)
+    {
+      for (size_t i = 0; i < m_rows; i++)
+        for (size_t j = 0; j < m_cols; j++)
+          (*this)(i,j) += m2(i,j);
+      return *this;
+    }
+    
+    template <typename TB>
+    MatrixView& operator-= (const MatExpr<TB>& m2)
+    {
+      for (size_t i = 0; i < m_rows; i++)
+        for (size_t j = 0; j < m_cols; j++)
+          (*this)(i,j) -= m2(i,j);
+      return *this;
+    }
+
+    MatrixView& operator*= (T scal)
+    {
+      for (size_t i = 0; i < rows(); i++)
+        for (size_t j = 0; j < cols(); j++)
+          (*this)(i,j) *= scal;
+      return *this;
+    }
+
+
+    auto row(size_t i) const 
+    {
+      if constexpr (ORD == RowMajor)
+        return VectorView<T>(m_cols, m_data + i*m_dist);
+      else
+        return VectorView<T,size_t>(m_cols, m_dist, m_data + i);
+    } 
+
+    auto col(size_t j) const 
+    {
+      if constexpr (ORD == RowMajor)
+        return VectorView<T,size_t>(m_rows, m_dist, m_data + j);
+      else
+        return VectorView<T>(m_rows, m_data + j*m_dist);
+    }
+
+    auto diag() const 
+    {
+      return VectorView<T,size_t>(std::min(m_rows, m_cols), m_dist+1, m_data);
+    } 
+
+    auto rows(size_t first, size_t next) const 
+    {
+      return MatrixView<T, ORD>(next - first, m_cols, m_dist, m_data+index(first,0));
+    }
+
+    auto cols(size_t first, size_t next) const 
+    {
+      return MatrixView<T, ORD>(m_rows, next - first, m_dist, m_data+index(0,first));
+    }
+  };
+
+
+  template <typename T, ORDERING ORD>
+  auto trans (MatrixView<T,ORD> mat)
+  {
+    if constexpr (ORD==RowMajor)
+      return MatrixView<T,ColMajor>(mat.cols(), mat.rows(), mat.dist(), mat.data());
+    else
+      return MatrixView<T,RowMajor>(mat.cols(), mat.rows(), mat.dist(), mat.data());
+  }
+  
+  template <typename T=double, ORDERING ORD=RowMajor>
+  class Matrix : public MatrixView<T,ORD>
+  {
+    typedef MatrixView<T,ORD> BASE;
+    using BASE::m_cols;
+    using BASE::m_data;
+    using BASE::m_rows;
+
+  public:
+    Matrix (size_t rows, size_t cols)
+      : BASE(rows, cols, new T[rows*cols]) { }
+          
+    Matrix (const Matrix& m2)
+      : BASE(m2.rows(), m2.cols(), new T[m2.rows()*m2.cols()])
+    {
+      *this = m2;
+    }
+          
+    Matrix (std::initializer_list<std::initializer_list<T>> list)
+      : BASE(list.size(), list.begin()->size(), new T[list.size()*list.begin()->size()])
+    {
+      size_t i = 0;
+      for (auto row : list)
+        {
+          size_t j = 0;
+          for (auto val : row)
+            {
+              (*this)(i,j) = val;
+              j++;
+            }
+          i++;
+        }
+    } 
+
+    ~Matrix() { delete[] m_data; }
+
+    using BASE::operator=;
+    Matrix& operator= (const Matrix& m2)
+    {
+      if (this != &m2)
+        {
+          assert(m_rows==m2.m_rows && m_cols==m2.m_cols);
+          BASE::operator=(m2);
+        }
+      return *this;
+    }
+                    
+  };
+
+}
+
+
+#endif
diff --git a/nanoblas/src/vecexpr.hpp b/nanoblas/src/vecexpr.hpp
new file mode 100644
index 000000000..69acd1b5d
--- /dev/null
+++ b/nanoblas/src/vecexpr.hpp
@@ -0,0 +1,192 @@
+#ifndef FILE_EXPRESSION
+#define FILE_EXPRESSION
+
+#include<complex>
+#include<cassert>
+#include <type_traits>
+
+namespace nanoblas
+{
+
+  
+
+  /*
+    Expression templates for vector expressions
+    
+    VecExpr is the basis for all vector expressions
+    Uses compile-time polymorphism, known as
+    Curiously recurring template pattern (CRTP)
+  */
+
+  template <typename T>
+  class VecExpr
+  {
+  public:
+    auto derived() const { return static_cast<const T&> (*this); }
+    size_t size() const { return derived().size(); }
+    auto operator() (size_t i) const { return derived()(i); }
+  };
+
+  
+
+  // ************************ SumVecExpr *********************
+ 
+  template <typename TA, typename TB>
+  struct SumVecExpr : public VecExpr<SumVecExpr<TA,TB>>
+  {
+    TA a;
+    TB b;
+  public:
+    SumVecExpr (TA _a, TB _b) : a(_a), b(_b) { }
+
+    auto operator() (size_t i) const { return a(i)+b(i); }
+    size_t size() const { return a.size(); }      
+  };
+  
+  template <typename TA, typename TB>
+  auto operator+ (const VecExpr<TA>& a, const VecExpr<TB>& b)
+  {
+    assert(a.size()==b.size());
+    return SumVecExpr(a.derived(), b.derived());
+  }
+
+
+  // ************************ SubVecExpr *********************
+  
+  template <typename TA, typename TB>
+  class SubVecExpr : public VecExpr<SubVecExpr<TA,TB>>
+  {
+    TA a;
+    TB b;
+  public:
+    SubVecExpr (TA _a, TB _b) : a(_a), b(_b) { }
+
+    auto operator() (size_t i) const { return a(i)-b(i); }
+    size_t size() const { return a.size(); }      
+  };
+  
+  template <typename TA, typename TB>
+  auto operator- (const VecExpr<TA>& a, const VecExpr<TB>& b)
+  {
+    assert(a.size()==b.size());    
+    return SubVecExpr(a.derived(), b.derived());
+  }
+
+
+  // ************************ NegVecExpr *********************
+
+  
+  template <typename TA>
+  class NegVecExpr : public VecExpr<NegVecExpr<TA>>
+  {
+    TA a;
+  public:
+    NegVecExpr (TA _a) : a(_a) { }
+
+    auto operator() (size_t i) const { return -a(i); }
+    size_t size() const { return a.size(); }      
+  };
+  
+  template <typename TA>
+  auto operator- (const VecExpr<TA>& a)
+  {
+    return NegVecExpr(a.derived());
+  }
+
+
+
+  // ************************ ScaleVecExpr *********************
+  
+
+  template <typename T>
+  struct is_scalar_type { static constexpr bool value = std::integral<T>||std::floating_point<T>; };
+  
+  template <typename T>
+  constexpr bool isScalar() { return is_scalar_type<T>::value; }
+
+
+  template <typename T>
+  struct is_scalar_type<std::complex<T>> { static constexpr bool value = isScalar<T>(); };
+
+
+
+
+  
+  template <typename TSCAL, typename TV>
+  class ScaleVecExpr : public VecExpr<ScaleVecExpr<TSCAL,TV>>
+  {
+    TSCAL scal;
+    TV vec;
+  public:
+    ScaleVecExpr (TSCAL _scal, TV _vec) : scal(_scal), vec(_vec) { }
+    auto operator() (size_t i) const { return scal*vec(i); }
+    size_t size() const { return vec.size(); }      
+  };
+
+  /*
+  // C++17 needs the enable_if workaround instead of the 'requires' concept syntax
+  template <typename TSCAL, typename T,
+            typename std::enable_if<isScalar<TSCAL>(),int>::type = 0>
+  */
+  
+  template <typename TSCAL, typename T> requires (isScalar<TSCAL>())
+  auto operator* (TSCAL scal, const VecExpr<T>& v)
+  {
+    return ScaleVecExpr(scal, v.derived());
+  }
+
+
+  // **************** dot product of two vectors *****************
+ 
+  template <typename TA, typename TB>
+  auto dot (const VecExpr<TA>& a, const VecExpr<TB>& b)
+  {
+    assert (a.size() == b.size());
+
+    using elemtypeA = typename std::invoke_result<TA,size_t>::type;
+    using elemtypeB = typename std::invoke_result<TB,size_t>::type;
+    using TSUM = decltype(std::declval<elemtypeA>()*std::declval<elemtypeB>());
+
+    TSUM sum = 0;
+    for (size_t i = 0; i < a.size(); i++)
+      sum += a(i)*b(i);
+    return sum;
+  }
+
+
+  
+  // **************** euclidean norm of vector *****************
+
+  double norm2 (double x) { return x*x; }
+  double norm2 (std::complex<double> x) { return x.real()*x.real() + x.imag()*x.imag(); }
+
+  
+  template <typename TA>
+  auto norm (const VecExpr<TA>& a)
+  {
+    using elemtype = typename std::remove_cvref<typename std::invoke_result<TA,size_t>::type>::type;
+
+    elemtype sum = 0;
+    for (size_t i = 0; i < a.size(); i++)
+      sum += norm2(a(i));
+    return sqrt(sum);
+  }
+
+  
+  
+  // ***********************  output operator  *********************
+  
+
+  template <typename T>
+  std::ostream & operator<< (std::ostream& ost, const VecExpr<T>& v)
+  {
+    if (v.size() > 0)
+      ost << v(0);
+    for (size_t i = 1; i < v.size(); i++)
+      ost << ", " << v(i);
+    return ost;
+  }
+  
+}
+ 
+#endif
diff --git a/nanoblas/src/vector.hpp b/nanoblas/src/vector.hpp
new file mode 100644
index 000000000..72cc224f1
--- /dev/null
+++ b/nanoblas/src/vector.hpp
@@ -0,0 +1,251 @@
+#ifndef FILE_VECTOR
+#define FILE_VECTOR
+
+#include <iostream>
+#include <vector>
+
+#include "vecexpr.hpp"
+
+
+namespace nanoblas
+{
+ 
+  enum ORDERING { RowMajor, ColMajor };
+
+  template <typename T, ORDERING ORD = RowMajor>
+  class MatrixView;
+
+
+  
+  template <typename T=double, typename TDIST = std::integral_constant<size_t,1> >
+  class VectorView : public VecExpr<VectorView<T,TDIST>>
+  {
+  protected:
+    T* m_data;
+    size_t m_size;
+    TDIST m_dist;
+    
+  public:
+    VectorView() = default;
+    VectorView(const VectorView&) = default;
+    
+    template <typename TDIST2>
+    VectorView (const VectorView<T,TDIST2>& v2)
+      : m_data(v2.data()), m_size(v2.size()), m_dist(v2.dist()) { }
+    
+    VectorView (size_t size, T* data)
+      : m_data(data), m_size(size) { }
+    
+    VectorView (size_t size, TDIST dist, T* data)
+      : m_data(data), m_size(size), m_dist(dist) { }
+    
+    VectorView operator= (const VectorView& v2)
+    {
+      for (size_t i = 0; i < m_size; i++)
+        m_data[m_dist*i] = v2(i);
+      return *this;
+    }
+
+    template <typename TB>
+    VectorView operator= (const VecExpr<TB>& v2)
+    {
+      for (size_t i = 0; i < m_size; i++)
+        m_data[m_dist*i] = v2(i);
+      return *this;
+    }
+
+    VectorView operator= (T scal)
+    {
+      for (size_t i = 0; i < m_size; i++)
+        m_data[m_dist*i] = scal;
+      return *this;
+    }
+
+    VectorView operator= (const std::vector<T>& v2)
+    {
+      for (size_t i = 0; i < m_size; i++)
+        m_data[m_dist*i] = v2[i];
+      return *this;
+    }
+
+    operator std::vector<T>() const
+    {
+      std::vector<T> v2(m_size);
+      for (size_t i = 0; i < m_size; i++)
+        v2[i] = m_data[m_dist*i];
+      return v2;
+    }
+
+    T * data() const { return m_data; }
+    size_t size() const { return m_size; }
+    auto dist() const { return m_dist; }
+    
+    T& operator()(size_t i) { return m_data[m_dist*i]; }
+    const T& operator()(size_t i) const { return m_data[m_dist*i]; }
+    
+    T& operator[](size_t i) { return m_data[m_dist*i]; }
+    const T& operator[](size_t i) const { return m_data[m_dist*i]; }
+    
+    auto range(size_t first, size_t next) const {
+      return VectorView(next-first, m_dist, m_data+first*m_dist);
+    }
+
+    auto slice(size_t first, size_t slice) const {
+      return VectorView<T,size_t> (m_size/slice, m_dist*slice, m_data+first*m_dist);
+    }
+
+    auto asMatrix(size_t rows, size_t cols) const {
+      return MatrixView<T,RowMajor> (rows, cols, m_data);  
+    }
+    
+    template <typename TB>
+    VectorView& operator+= (const VecExpr<TB>& v2)
+    {
+      for (size_t i = 0; i < m_size; i++)
+        m_data[m_dist*i] += v2(i);
+      return *this;
+    }
+
+    template <typename TB>
+    VectorView& operator-= (const VecExpr<TB>& v2)
+      {
+        for (size_t i = 0; i < m_size; i++)
+          m_data[m_dist*i] -= v2(i);
+        return *this;
+      }
+
+    VectorView& operator*= (T scal)
+    {
+      for (size_t i = 0; i < m_size; i++)
+        m_data[m_dist*i] *= scal;
+      return *this;
+    }
+    
+  };
+  
+  
+
+  
+  template <typename T=double>
+  class Vector : public VectorView<T>
+  {
+    typedef VectorView<T> BASE;
+    using BASE::m_size;
+    using BASE::m_data;
+  public:
+    explicit Vector (size_t size) 
+      : VectorView<T> (size, new T[size]) { ; }
+    
+    Vector (const Vector& v)
+      : Vector(v.size())
+    {
+      *this = v;
+    }
+
+    Vector (Vector && v)
+      : VectorView<T> (0, nullptr)
+    {
+      std::swap(m_size, v.m_size);
+      std::swap(m_data, v.m_data);
+    }
+
+    template <typename TB>
+    Vector (const VecExpr<TB>& v)
+      : Vector(v.size())
+    {
+      *this = v;
+    }
+
+  
+    Vector (std::initializer_list<T> list) 
+      : VectorView<T> (list.size(), new T[list.size()])
+    {
+      size_t cnt = 0;
+      for (auto val : list)
+        (*this)(cnt++) = val;
+    }
+    
+    ~Vector () { delete [] m_data; }
+
+    using BASE::operator=;
+    Vector& operator=(const Vector& v2)
+    {
+      for (size_t i = 0; i < m_size; i++)
+        m_data[i] = v2(i);
+      return *this;
+    }
+
+    Vector& operator= (Vector && v2)
+    {
+      std::swap(m_size, v2.m_size);
+      std::swap(m_data, v2.m_data);
+      return *this;
+    }
+  };
+
+
+  template <typename ...Args>
+  std::ostream& operator<< (std::ostream& ost, const VectorView<Args...>& v)
+  {
+    if (v.size() > 0)
+      ost << v(0);
+    for (size_t i = 1; i < v.size(); i++)
+      ost << ", " << v(i);
+    return ost;
+  }
+
+
+  template <size_t S, typename T=double>
+  class Vec : public VecExpr<Vec<S,T>>
+  {
+    std::array<T, S> m_data;
+  public:
+    Vec() = default;
+    Vec (const Vec& v) = default;
+    
+    template <typename TB>
+    Vec (const VecExpr<TB>& v)
+    {
+      for (size_t i = 0; i < S; i++)
+        m_data[i] = v(i);
+    }
+
+    Vec (T val)
+    {
+      for (size_t i = 0; i < S; i++)
+        m_data[i] = val;
+    }
+
+    Vec (std::initializer_list<T> list)
+    {
+      size_t cnt = 0;
+      for (auto val : list)
+        (*this)(cnt++) = val;
+    }
+    
+    Vec& operator= (const Vec& v2)
+    {
+      for (size_t i = 0; i < S; i++)
+        m_data[i] = v2.m_data[i];
+      return *this;
+    }
+    
+    template <typename TB>
+    Vec& operator= (const VecExpr<TB>& v2)
+    {
+      for (size_t i = 0; i < S; i++)
+        m_data[i] = v2(i);
+      return *this;
+    }
+    
+    size_t size() const { return S; }
+    std::array<T,S>& data() { return m_data; }
+    const std::array<T,S>& data() const { return m_data; }
+    
+    T& operator() (size_t i) { return m_data[i]; }
+    const T& operator() (size_t i) const { return m_data[i]; }
+ };
+  
+}
+
+#endif
diff --git a/solution.tar.gz b/solution.tar.gz
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/.ipynb_checkpoints/CMakeLists-checkpoint.txt b/src/.ipynb_checkpoints/CMakeLists-checkpoint.txt
new file mode 100644
index 000000000..ca77dc21b
--- /dev/null
+++ b/src/.ipynb_checkpoints/CMakeLists-checkpoint.txt
@@ -0,0 +1,3 @@
+
+install (FILES nonlinfunc.hpp Newton.hpp ode.hpp DESTINATION include) 
+
diff --git a/src/.ipynb_checkpoints/CrankNicolson-checkpoint.hpp b/src/.ipynb_checkpoints/CrankNicolson-checkpoint.hpp
new file mode 100644
index 000000000..5decba086
--- /dev/null
+++ b/src/.ipynb_checkpoints/CrankNicolson-checkpoint.hpp
@@ -0,0 +1,34 @@
+#pragma once
+#include "timestepper.hpp"
+#include "function_algebra.hpp"
+#include "newton.hpp"
+
+class CrankNicolson : public TimeStepper
+{
+    std::shared_ptr<NonlinearFunction> m_equ;
+    std::shared_ptr<Parameter>        m_tau;
+    std::shared_ptr<ConstantFunction> m_yold;
+    std::shared_ptr<ConstantFunction> m_fold;   // f(y_n)
+    Vector<> m_temp;
+
+public:
+    CrankNicolson(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs), m_tau(std::make_shared<Parameter>(0.0)),
+          m_temp(rhs->dimF())
+    {
+        m_yold = std::make_shared<ConstantFunction>(rhs->dimX());
+        m_fold = std::make_shared<ConstantFunction>(rhs->dimF());
+        auto id = std::make_shared<IdentityFunction>(rhs->dimX());
+
+        m_equ = id - m_yold - 0.5 * m_tau * (m_fold + rhs);
+    }
+
+    void doStep(double tau, VectorView<double> y) override
+    {
+        m_rhs->evaluate(y, m_temp);    // compute f(y_n)
+        m_fold->set(m_temp);           // store it
+        m_yold->set(y);
+        m_tau->set(tau);
+        NewtonSolver(m_equ, y);
+    }
+};
\ No newline at end of file
diff --git a/src/.ipynb_checkpoints/ImplicitEuler-checkpoint.hpp b/src/.ipynb_checkpoints/ImplicitEuler-checkpoint.hpp
new file mode 100644
index 000000000..c80973828
--- /dev/null
+++ b/src/.ipynb_checkpoints/ImplicitEuler-checkpoint.hpp
@@ -0,0 +1,27 @@
+#pragma once
+#include "timestepper.hpp"
+#include "function_algebra.hpp"
+#include "newton.hpp"
+
+class ImplicitEuler : public TimeStepper
+{
+    std::shared_ptr<NonlinearFunction> m_equ;
+    std::shared_ptr<Parameter>        m_tau;
+    std::shared_ptr<ConstantFunction> m_yold;
+
+public:
+    ImplicitEuler(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs), m_tau(std::make_shared<Parameter>(0.0))
+    {
+        m_yold = std::make_shared<ConstantFunction>(rhs->dimX());
+        auto ynew = std::make_shared<IdentityFunction>(rhs->dimX());
+        m_equ = ynew - m_yold - m_tau * rhs;          // y - yold - tau*f(y) = 0
+    }
+
+    void doStep(double tau, VectorView<double> y) override
+    {
+        m_yold->set(y);
+        m_tau->set(tau);
+        NewtonSolver(m_equ, y);
+    }
+};
\ No newline at end of file
diff --git a/src/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp b/src/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp
new file mode 100644
index 000000000..7699f2129
--- /dev/null
+++ b/src/.ipynb_checkpoints/ImprovedEuler-checkpoint.hpp
@@ -0,0 +1,21 @@
+#pragma once
+#include "timestepper.hpp"
+
+class ImprovedEuler : public TimeStepper
+{
+    Vector<> m_k1, m_k2, m_temp;
+
+public:
+    ImprovedEuler(std::shared_ptr<NonlinearFunction> rhs)
+        : TimeStepper(rhs),
+          m_k1(rhs->dimF()), m_k2(rhs->dimF()), m_temp(rhs->dimF())
+    {}
+
+    void doStep(double tau, VectorView<double> y) override
+    {
+        m_rhs->evaluate(y, m_k1);                 // k1 = f(y_n)
+        m_temp = y + tau * m_k1;                  // predictor
+        m_rhs->evaluate(m_temp, m_k2);            // k2 = f(y_n + tau k1)
+        y += tau * (0.5 * m_k1 + 0.5 * m_k2);      // corrector
+    }
+};
\ No newline at end of file
diff --git a/src/.ipynb_checkpoints/Newton-checkpoint.hpp b/src/.ipynb_checkpoints/Newton-checkpoint.hpp
new file mode 100644
index 000000000..6021fd2b0
--- /dev/null
+++ b/src/.ipynb_checkpoints/Newton-checkpoint.hpp
@@ -0,0 +1,52 @@
+#ifndef NEWTON_HPP
+#define NEWTON_HPP
+
+#include <iostream>
+#include <vector>
+#include <cmath>
+#include <stdexcept>
+#include "nonlinfunc.hpp"
+
+class NewtonSolver {
+public:
+    double tol = 1e-8;
+    int maxIter = 50;
+
+    void solve(NonlinearFunction& func, std::vector<double>& x) {
+        size_t n = x.size();
+        std::vector<double> F(n);
+        std::vector<std::vector<double>> J(n, std::vector<double>(n));
+
+        for(int iter=0; iter<maxIter; ++iter) {
+            func.evaluate(x, F);
+            func.evaluateDeriv(x, J);
+
+            // Solve J*dx = -F using simple 2x2 solver
+            std::vector<double> dx = linearSolve(J, F);
+
+            for(size_t i=0; i<n; ++i) x[i] -= dx[i];
+
+            double norm = 0.0;
+            for(double v : dx) norm += v*v;
+            norm = std::sqrt(norm);
+
+            if(norm < tol) {
+                std::cout << "Converged in " << iter+1 << " iterations.\n";
+                return;
+            }
+        }
+        throw std::runtime_error("Newton did not converge");
+    }
+
+private:
+    std::vector<double> linearSolve(const std::vector<std::vector<double>>& J, const std::vector<double>& F) {
+        // Only works for 2x2 systems
+        double a = J[0][0], b = J[0][1];
+        double c = J[1][0], d = J[1][1];
+        double det = a*d - b*c;
+        if(std::abs(det) < 1e-12) throw std::runtime_error("Singular Jacobian");
+        return { (d*F[0]-b*F[1])/det, (-c*F[0]+a*F[1])/det };
+    }
+};
+
+#endif
diff --git a/src/.ipynb_checkpoints/bindings-checkpoint.cpp b/src/.ipynb_checkpoints/bindings-checkpoint.cpp
new file mode 100644
index 000000000..00af57ac4
--- /dev/null
+++ b/src/.ipynb_checkpoints/bindings-checkpoint.cpp
@@ -0,0 +1,41 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include "nonlinfunc.hpp"
+#include "Newton.hpp"
+#include <vector.hpp>
+#include <matrix.hpp>
+
+namespace py = pybind11;
+using namespace ASC_ode;
+using namespace nanoblas;
+
+PYBIND11_MODULE(asc_ode, m) {
+    m.doc() = "ASC ODE solver";
+
+    // Vector
+    py::class_<Vector<double>>(m, "Vector")
+        .def(py::init<size_t>())
+        .def(py::init<std::vector<double>>())
+        .def("__len__", [](const Vector<double>& v) { return v.size(); })
+        .def("__getitem__", [](Vector<double>& v, size_t i) -> double& { return v(i); })
+        .def("__setitem__", [](Vector<double>& v, size_t i, double val) { v(i) = val; })
+        .def("__repr__", [](const Vector<double>& v) {
+            std::stringstream ss; ss << "[";
+            for(size_t i=0; i<v.size(); i++) { ss << v(i); if(i+1<v.size()) ss << ", "; }
+            ss << "]"; return ss.str();
+        });
+
+    // NonlinearFunction base + Python subclass
+    py::class_<NonlinearFunction, PyNonlinearFunction, std::shared_ptr<NonlinearFunction>>(m, "NonlinearFunction", py::dynamic_attr(), py::module_local())
+        .def(py::init<>())
+        .def("dimX", &NonlinearFunction::dimX)
+        .def("dimF", &NonlinearFunction::dimF)
+        .def("evaluate", [](NonlinearFunction& self, Vector<double>& x, Vector<double>& f) { self.evaluate(x,f); })
+        .def("evaluateDeriv", [](NonlinearFunction& self, Vector<double>& x, Matrix<double>& df) { self.evaluateDeriv(x,df); });
+
+    // NewtonSolver
+    m.def("NewtonSolver", [](std::shared_ptr<NonlinearFunction> func, Vector<double>& x,
+                             double tol = 1e-12, int maxit = 50, bool linesearch = true) {
+        return NewtonSolver(func, x, tol, maxit, linesearch);
+    });
+}
diff --git a/src/.ipynb_checkpoints/function_algebra-checkpoint.hpp b/src/.ipynb_checkpoints/function_algebra-checkpoint.hpp
new file mode 100644
index 000000000..387a9858a
--- /dev/null
+++ b/src/.ipynb_checkpoints/function_algebra-checkpoint.hpp
@@ -0,0 +1,9 @@
+#pragma once
+
+// Include the individual linear algebra components
+// Assuming these files are found via your -Isrc path
+#include "vector.hpp"
+#include "matrix.hpp"
+
+// We should also include the core function type used by the steppers
+#include "function_algebra.hpp"
\ No newline at end of file
diff --git a/src/.ipynb_checkpoints/main-checkpoint.cpp b/src/.ipynb_checkpoints/main-checkpoint.cpp
new file mode 100644
index 000000000..3e50ef87f
--- /dev/null
+++ b/src/.ipynb_checkpoints/main-checkpoint.cpp
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <fstream>  // For file output
+#include <vector>
+#include <cmath>    // For math functions like sqrt, fabs, etc.
+
+// Your existing includes
+#include "nonlinfunc.hpp"
+#include "mass_spring_function.hpp"
+#include "newton.hpp"
+
+int main() {
+    // Define the system and initial conditions (this might already be in your code)
+    std::vector<double> x = {1.0, 0.0};  // Example initial conditions
+    double dt = 0.01;  // Time step
+    double t_max = 10.0;  // Max time
+    int steps = static_cast<int>(t_max / dt);
+
+    // Create a file to output data
+    std::ofstream output_file("simulation_data.csv");
+    output_file << "Time, x1, x2\n";  // Header for CSV
+
+    // Run the simulation (just an example loop)
+    for (int step = 0; step < steps; ++step) {
+        // Call the appropriate time-stepping method here (e.g., ExpEuler, ImpEuler)
+        // Example of using a simple explicit Euler method:
+        std::vector<double> f_val = {1.0, 0.0};  // This should be computed by your model
+
+        for (int i = 0; i < x.size(); ++i) {
+            x[i] += dt * f_val[i];  // Update state using Euler method
+        }
+
+        // Save the current time and state to the CSV file
+        double time = step * dt;
+        output_file << time << ", " << x[0] << ", " << x[1] << "\n";
+    }
+
+    output_file.close();  // Close the file after writing
+
+    return 0;
+}
diff --git a/src/.ipynb_checkpoints/mass_spring_function-checkpoint.hpp b/src/.ipynb_checkpoints/mass_spring_function-checkpoint.hpp
new file mode 100644
index 000000000..b5fe525c3
--- /dev/null
+++ b/src/.ipynb_checkpoints/mass_spring_function-checkpoint.hpp
@@ -0,0 +1,39 @@
+#ifndef MASS_SPRING_FUNCTION_HPP
+#define MASS_SPRING_FUNCTION_HPP
+
+#include "nonlinfunc.hpp"
+#include <vector>
+#include <cmath> // For mathematical functions like sin, cos, etc.
+
+class MassSpringFunction : public NonlinearFunction {
+public:
+    MassSpringFunction(double mass, double spring_constant)
+        : m_mass(mass), m_k(spring_constant) {}
+
+    // Evaluate the right-hand side of the ODE system
+    std::vector<double> eval(const std::vector<double>& x) const override {
+        // x[0] = position (x), x[1] = velocity (v)
+        double dx1_dt = x[1];  // dx/dt = v (velocity)
+        double dx2_dt = -m_k / m_mass * x[0];  // dv/dt = -k/m * x (acceleration)
+        
+        return {dx1_dt, dx2_dt};
+    }
+
+    // Evaluate the Jacobian matrix of the system
+    std::vector<std::vector<double>> jacobian(const std::vector<double>& x) const override {
+        // The Jacobian matrix is:
+        // [ 0,  1 ]
+        // [-k/m, 0]
+        
+        return {
+            {0, 1},
+            {-m_k / m_mass, 0}
+        };
+    }
+
+private:
+    double m_mass;  // Mass of the object
+    double m_k;     // Spring constant
+};
+
+#endif // MASS_SPRING_FUNCTION_HPP
diff --git a/src/.ipynb_checkpoints/matrix-checkpoint.hpp b/src/.ipynb_checkpoints/matrix-checkpoint.hpp
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/.ipynb_checkpoints/myfunction-checkpoint.hpp b/src/.ipynb_checkpoints/myfunction-checkpoint.hpp
new file mode 100644
index 000000000..6c971a5b7
--- /dev/null
+++ b/src/.ipynb_checkpoints/myfunction-checkpoint.hpp
@@ -0,0 +1,23 @@
+#ifndef MYFUNCTION_HPP
+#define MYFUNCTION_HPP
+
+#include <vector>
+#include "nonlinfunc.hpp"
+
+class MyFunction : public NonlinearFunction {
+public:
+    double x, y;
+
+    MyFunction(double x0 = 1.0, double y0 = 1.0) : x(x0), y(y0) {}
+
+    // Match the NonlinearFunction interface exactly
+    std::vector<double> eval() const {
+        return { x*x + y*y - 4, x - y };
+    }
+
+    std::vector<std::vector<double>> jacobian() const {
+        return {{2*x, 2*y}, {1, -1}};
+    }
+};
+
+#endif
diff --git a/src/.ipynb_checkpoints/newton-checkpoint.hpp b/src/.ipynb_checkpoints/newton-checkpoint.hpp
new file mode 100644
index 000000000..57d4ebd05
--- /dev/null
+++ b/src/.ipynb_checkpoints/newton-checkpoint.hpp
@@ -0,0 +1,41 @@
+#ifndef Newton_h
+#define Newton_h
+
+#include "nonlinfunc.hpp"
+#include <inverse.hpp>
+#include <lapack_interface.hpp>
+
+namespace ASC_ode
+{  
+  void NewtonSolver (std::shared_ptr<NonlinearFunction> func, VectorView<double> x,
+                     double tol = 1e-10, int maxsteps = 10,
+                     std::function<void(int,double,VectorView<double>)> callback = nullptr)
+  {
+    Vector<double> res(func->dimF());
+    Matrix<double> fprime(func->dimF(), func->dimX());
+
+    for (int i = 0; i < maxsteps; i++)
+      {
+        func->evaluate(x, res);
+        double err= norm(res);
+        if (err < tol) return;
+
+        func->evaluateDeriv(x, fprime);
+
+        calcInverse(fprime);
+        x -= fprime*res;
+
+        // LapackLU LU(fprime);
+        // LU.solve(res);
+        // x -= res;
+ 
+        if (callback)
+          callback(i, err, x);
+      }
+
+    throw std::domain_error("Newton did not converge");
+  }
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/.ipynb_checkpoints/timestepper-checkpoint.cpp b/src/.ipynb_checkpoints/timestepper-checkpoint.cpp
new file mode 100644
index 000000000..3fd6ca339
--- /dev/null
+++ b/src/.ipynb_checkpoints/timestepper-checkpoint.cpp
@@ -0,0 +1,79 @@
+#include "timestepper.hpp"
+#include "newton.hpp"
+
+std::vector<double> ExpEuler(const NonlinearFunc& f,
+                              const std::vector<double>& x0,
+                              double dt) {
+    // Explicit Euler method implementation
+    std::vector<double> x = x0;
+    std::vector<double> fx = f.eval(x);
+    for (size_t i = 0; i < x.size(); ++i) {
+        x[i] += dt * fx[i];
+    }
+    return x;
+}
+
+std::vector<double> ImpEuler(const NonlinearFunc& f,
+                              const std::vector<double>& x0,
+                              double dt) {
+    // Implicit Euler method implementation
+    std::vector<double> x = x0;
+    
+    // Define the system for Newton's method
+    auto g = [&](const std::vector<double>& y) -> std::vector<double> {
+        std::vector<double> fy = f.eval(y);
+        std::vector<double> res(fy.size());
+        for (size_t i = 0; i < fy.size(); ++i) {
+            res[i] = y[i] - x[i] - dt * fy[i];
+        }
+        return res;
+    };
+    
+    // Solve using Newton's method
+    return NewtonSolver(g, x);
+}
+
+std::vector<double> ImprovedEuler(const NonlinearFunc& f,
+                                   const std::vector<double>& x0,
+                                   double dt) {
+    // Improved Euler method implementation
+    std::vector<double> x = x0;
+    std::vector<double> fx = f.eval(x);
+    
+    // Take a step with the explicit Euler method
+    std::vector<double> x_temp = x;
+    for (size_t i = 0; i < x.size(); ++i) {
+        x_temp[i] += dt * fx[i];
+    }
+    
+    // Evaluate at the new point
+    std::vector<double> fx_temp = f.eval(x_temp);
+    
+    // Combine the two steps for the improved Euler method
+    for (size_t i = 0; i < x.size(); ++i) {
+        x[i] += dt * 0.5 * (fx[i] + fx_temp[i]);
+    }
+    
+    return x;
+}
+
+std::vector<double> CrankNicolson(const NonlinearFunc& f,
+                                   const std::vector<double>& x0,
+                                   double dt) {
+    // Crank-Nicolson method implementation (implicit method)
+    std::vector<double> x = x0;
+    
+    // Define the system for Newton's method
+    auto g = [&](const std::vector<double>& y) -> std::vector<double> {
+        std::vector<double> fy = f.eval(y);
+        std::vector<double> fx = f.eval(x);
+        std::vector<double> res(fx.size());
+        for (size_t i = 0; i < fx.size(); ++i) {
+            res[i] = y[i] - x[i] - 0.5 * dt * (fx[i] + fy[i]);
+        }
+        return res;
+    };
+    
+    // Solve using Newton's method
+    return NewtonSolver(g, x);
+}
diff --git a/src/.ipynb_checkpoints/timestepper-checkpoint.hpp b/src/.ipynb_checkpoints/timestepper-checkpoint.hpp
new file mode 100644
index 000000000..9212f156d
--- /dev/null
+++ b/src/.ipynb_checkpoints/timestepper-checkpoint.hpp
@@ -0,0 +1,39 @@
+#ifndef TIMESTEPPER_HPP
+#define TIMESTEPPER_HPP
+
+#include "nonlinfunc.hpp"
+#include <vector>
+
+std::vector<double> ExpEuler(NonlinearFunction& f, std::vector<double>& x, double dt) {
+    std::vector<double> f_val = f.eval(x);
+    for (size_t i = 0; i < x.size(); ++i) {
+        x[i] += dt * f_val[i];  // Update the values using the explicit Euler method
+    }
+    return x;
+}
+
+std::vector<double> ImpEuler(NonlinearFunction& f, std::vector<double>& x, double dt) {
+    std::vector<double> f_val = f.eval(x);
+    for (size_t i = 0; i < x.size(); ++i) {
+        x[i] += dt * f_val[i];  // Update values (simplified, for demonstration)
+    }
+    return x;
+}
+
+std::vector<double> ImprovedEuler(NonlinearFunction& f, std::vector<double>& x, double dt) {
+    std::vector<double> f_val = f.eval(x);
+    for (size_t i = 0; i < x.size(); ++i) {
+        x[i] += dt * f_val[i];  // Final step
+    }
+    return x;
+}
+
+std::vector<double> CrankNicolson(NonlinearFunction& f, std::vector<double>& x, double dt) {
+    std::vector<double> f_val = f.eval(x);
+    for (size_t i = 0; i < x.size(); ++i) {
+        x[i] += dt * f_val[i];  // Update final step
+    }
+    return x;
+}
+
+#endif
diff --git a/src/.ipynb_checkpoints/vector-checkpoint.hpp b/src/.ipynb_checkpoints/vector-checkpoint.hpp
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
new file mode 100644
index 000000000..ca77dc21b
--- /dev/null
+++ b/src/CMakeLists.txt
@@ -0,0 +1,3 @@
+
+install (FILES nonlinfunc.hpp Newton.hpp ode.hpp DESTINATION include) 
+
diff --git a/src/compare_all b/src/compare_all
new file mode 100644
index 0000000000000000000000000000000000000000..0e677d6dad730231aa545e0ce161eb9496b5e4e5
GIT binary patch
literal 2212134
zcmeFa2bg5lbuL;%5LrU90*Y=xf*D|j&OsJvQcpn5%xHo@vgM+>ySlrex~l2w?&-nu
z)hMHkQ9{uuqhJZ!vW@L)8)YP0Hp*E-8D(r;+t}8#-@n4yXYc=<LU6x#{k`|S9_U*8
zUwfam*Iqk^v(N0p)ZF>KeS^0>>iEIm`rgP%Z+!pfFRzS0>yirot;63d<p=+cIc76{
zPe0eVm37W`2rv5Q{;Q+I8;1wUkD-M<Heny1qY#y{QUunzV}vhk{5cVhy46tt86%Mu
zKbk(PLXxmSEITOFy89IZP>A54@r~klw%)2QHl|8c$)0%_91p->wYq)lMD^0$d#dA?
z@2ggO)^F_V?eE*L5nhi|@2Q1_YOCE^I<io&F4gB3nzf~Rb)mLco3Ag`7pt}9rFKt$
zZ{Kk5@WdnWz=QRnL%a7JtWJz?IdHIVxO(Z9%OSXTbq4<)4sVINTHP@re!I3Ds6P47
z?(u`wJzMr5RNsT(dAbJJa&YgZySG)hY=i&)@t*!ifcuc}X#c3n?dx^D2ge5bhv9ol
z7DCemft&h9h6cw52Znk_`}_MxM}~Sw#)d~n28M?QM!@JF92y?2ZyXriA!?cYo!hom
zcaLwY4h@Y}x9z=j-^BRkJ^hak-eQs3?CfHFR!q_AOwTvO0t3B+6K5e1TVS+$@TvR8
zk+$Vlr!m{APxnmC)fOctNo%!wVE5C;_wIl__HH>i+AB5~-WKB8YG&F#zGv_LOFc<r
zoBBovkf!0jp^>q%zW%<xq2b=%AtbYJY@~N^bOfm#u5TRd+q$D~7?rN_>l%-!-9Y|T
zm*y7h_3Gi;k?K@?9y!_Qv|EyZvEGphQT}8NjvSPX+qQmcL(f#t*=P4m+#mc?)o<Ib
zE&HomcOQhZqf$!5Hr1*`FkP24!Y<R*Mys*Zs5Kkc)E7G<egxtr#iwatDIu1HRx}<6
zu9e3FD*dwE+Yjy%`DehxV!ccXRa}^)Kphf)d00!-Kz~}4`-e72q5L)V7yUX*wWY>X
zwbtp>7nek<!M;8%x0ds6ZmABTWUb#gFtXuMkYMF@@BZ!M`>PYX4<4Ktua588zT3)e
z|G=PVVu`y<laQ%8B6{NAW8p6aq*|2%wrk5%#;XUOx@Vgfu`T<@t6TPLuO7H;%f4!V
zPv5-`J9r<$j`s9PPKiZK2d`qP?Zn<~Ppa<NKaQFv`Cti&YC=!H)ZK^bvnZ4U{g+p_
zk8j(3>6VG=_T4+B*p7$|&D01`9e)bEE*(F(YwvdW_NMh`veBw79;r4PXhUjEEgw>U
z#Dta;kT5)0h~XsopP(viLz7YM84x>3-dO2twd<=>^@XMC%yMgLsnKp#rP-2f9_s6z
zI1}NlDoC=Tw4>CZwaU}qgMgxm30*-AsZFEMWUZfQ+lz`eu^wS8z1rUGKywG3vuw9a
z&wme1NCC3&2VgN*z#E4~Yf0>DO+wZr$7Qg0WP=#rT9+NW_v}76j;K&a_U@T@su;Kj
zzNGbJGjFqljYSKK#<Nirw#FY#|KPnYd3`;7kwQ`;v^Dpp3gsb>D3~X%@sEKXR-B|_
zF0Ry?%k}DFeWt!xZ%s+2^$sJ`&O<1xG!m*+??}_qLg&+2s7=+;-ppt_({5?{q&7?W
zu?7L<)APfUH!wOR#rj12Rjb<mSnDQ=TB(~5%S)fMdykq}3>&3V8X)b}MysKHlG10H
zA_|7WvfOF3W~Jl}L!}KNOx`j6%93Jv6h)a8tdSYXX6qy+&f3z_Vq<c7sjdZcw0CSm
zO1UJ;3h-2IVQG1>E^Xf;8vlk`YPfe`Ldv2wtp|4P&zn|huf~Fxn#7_;UphKAGSD|T
zHZ(9a(m&8QGCYLALjN!fJJ37Oi{7WduYSIC#S^JnwBMO(FSeJL8ZE7mW4-+oNsm4}
zczLl$mk?$LNoZpRJyr`PV0B?pO^Y!{-eP2JH%fD;Hv^+m!c0Qs@1?zelyZJIG9LZ@
zaIf_I$a#t0s+2ZImluaC;u|#qUO2LxnwcqWZ@2E<I}x`x;}8;By*`X=lJ0(Z)8NPu
z1~Gko=+{Sk`{C#v>mP)BYzRY|k>SDNp&@klW5dHc@UT=CD;rYQL=$genr#%wFa|+;
zBYN9#NvoERV|t|kNwTbNh5<<2)DPzEaI?``UhV0V2STMoOEA9g!0w5?I-(ojIJ|vF
z5B#OVYcHL24F?ZY`$mU{`>F%dh>68zoKdZc_R^gr0X9Ogmh_MmED41k>~d|l#`o{O
zbbQZ2bT->Azr0sM_w9hcWxCYo#G2FXWweUx2RDrk_6`pX4-SnE_VvSpgM(6<F)$qK
zA038S`!G7hu&{q{LProL4W&S`CmAiH@b_(y9y1=KVEh2359NJc^kgWU>yc*zeH)S?
zv2?3k3dOcoJVIlDk#p7n^$m+|)?M4sDKpu~j1+Gxomu=_(1Lk)-8UdbB^j`&+Uqw~
ztMLG4V^7}(5h8i6%_dr|XjCX=&2sF(fqm5j2lwyYBclQ8nY97H;BaZNeFP07+U+K$
z4^oLoQHgsX!%9cgGw<7r<jPPh@0cZ}$>iX`_>-&K4jk+mk~UrDOV#RftAX+;!(K~y
zuvygLW+Sq!bDog09t<UUaA|I+p@FUg2V_GsaFDFDTA=N6Q-}NLv<_#jm1Kzb;M!qI
zR)z8~FuEDup`=NJ7*(T9y`zKuXkSPA2S<m7dQtxeF$x(R>L2ax9UUGUL;3BiZ|ob}
zF+8{`I{0Av;C2i(_Z~PnE`zYNnu<Z9dEdZjKMj_r>r+jg_hpkj8KOyETdSdU%Z7eK
z(qCANC~1k>ePjJ-uFzIt;x*dWKh#_NSKm0YLkhT+MKPVskVdOAK=1Fzv>~5)NS(iI
ze9Mz0F_KCzdD4C56(VoFpbXj&u29^$X|W&JG%(!X*Nfh5psx=qW5PJxkN-xX^~eD1
zKGZ+lE6prAHz_WbjbZ~9FXL-V3I-sd2^-rqrvJvr&>Tu5W~$5ByL^V24sB)9R-5kB
zX0#udIgE^ZU?8;D!xLvio(=28diB=wJciXvZA{POv4Ku@lFmlTSkgQWY(kURH--+r
zZ*;VOaAa^89Zvt~VDHe_z`!tipuVwDw2K%4^hrT0v|T)QlDVXfx1?T5u1Wnh>qyPa
zGHswguiFQt%x3d%JRz;U)e7@Duora(y&j~Y{TS)iez;}1{jgG+PF?z=o<51)XaA!2
z#n8g)HVPH0PF^+pH=&RY!cv1{DBc5D2pC0O9l@|jOg7p#jGhKI>l=o}Bz8;vY-<_Q
zA9S7~TnbY#O0;Am4OQN#Sj2Ii)wLQa?$#<w=Ig*yi-1^1=JZJ~q{A!}_|WQjFO=7r
zFa}Q6WzrJ1SjULcW>;v+r<ZlICGklMA&p$Hlq4o<Wcmg+NKKC#xwNU3XDx@c8PL%l
zW(Fd96a(p`owgBU=+K4-^R6fxwP@?qFU^$|!kv2#Z4-MBNM~*99MYofKX`C=PhUQ$
zS!mRyaOI3kFV%5{WK&R`W;>EiHe~Vz9SnbVR=4jxv=!?Fh;lgZ#<%X?xpVx$!RnTY
z-8=Wl*hT%R(LQu=M-|4ylk#BbG`trJ*@wcGS3*xVHAuaAbA=M*r7H*+<OQ6jtZPXh
ztz+#)<ZW9QaC%X|C!Pph^48x*8a|}z+cYvZGK>+;z~JaGCI>?!y`z2TpGF4z2QX>C
zgc*~D`uR|JLdQH-L?oLRYlks8Swx&VgBiiJ@0?(1X(eQ49U9W!)za=eZ;!bRlI}ZH
zu6r5<L`_h%CWkB-lnIqoqbf38mTmTpZ#y)x<=}3Na1U(RF<!+|$D#3_zH~}E({4^z
zWv){1bg&i?rd@gc@ctpHA7g_$*0So1r0+YpKeUm<gFR5e(wWaABfDh7nL`qTjTp59
zw0TQDF_+#a9~_BsQ7GbB0wxD>Y23ei8w%^51G}X(=0=iAaoKLHKpZ%rC0t@Ov7rgc
z<IFpP1LHfZI}h~qNl~)O<i$2`QAaj)87ahL2aL{Tfm344W--m>&I10>TA*L#IVhGE
zs#h;#L2{;HE0VoZ&_rn~9C>CSmE#-7hPLm>#~s_p_w66wwgtnep1yQ;%?lS=gk|MI
zGRiv}Sz*UWFJEMlbeo@zwDWH8@j)NWI-maxY#QwCAH^Euu*|jlM@NUo&>W&lVI_EQ
z6g~DZx*pW6(H#T2PHuKZie$Qy+ZD+g7}%~2bSNIk`m{3~%KIo}tjxf4A+}G(7gqRu
z<!Toiw*BKW<wemS=<6NnmrlZxg>t)n_l_N|eo2+h+t%9rG)lJizy<Ny;y-4%1H(x(
zt}BiM(o9%8qOGm|<kO$5J{X<Q^$rW|O|%e<;IYbFXhXRXk<^=2wHL+=A*!`~Iti4L
zn26T}YY{&vY#Z-+h4eYtP~M^C3CIe=ur@nVmu(#<T2RNxp|hkVO-6r`mlkneW|Aci
z%M)p8=jyA~nP$7DYu~a4BnsHG(h+Xiy1V+6@%;zTu=Vtz%N1XH7?RT@`_j4?E?Usu
ze%Y4&JNm2JcI>WhIdExDUtaC8n^%>5&MTbg)2z);PS-RgGE^zHOlYsEWqJZ)G+TPR
zVHu9`J0=<EeMV6g`mjKSRg<yaL3BdBy#phC*cKTbmhNX%8jY=xVTDa|GaUop`?UcK
z=%id&qbJG9mWY#WvCVO0THT_}oS{u)=vRja2S-MR2F5T@ET15aLTQl`iXc_&O-S@u
zKW2eg7Q)KhkSxey5o-i{LH$_b80*Ir1`Xz*tPsiWlBukTzr1Sd=t9eVSmKlMzu3@J
z@*0&*+EJyXnY5PGs+nzq6;`405;Cz5nT@tL@4aMpB^5CliEa*YYH5!r$@hLFKG44^
zW!w7Mu*B(=2DMo?b0h@zM}3!L>+bE<9oU82qQkYkHM9~W%|RGbVao{1^-?uLA(LTO
z8e~udSR9@aSya|K^y|pain=%DB0_toVN6rEYZqfVxqp1;ZcOs`SJ6%F*e!!qsb}`A
zj1?sMXeBLg?hvySC2sBt-H=6muQyW%`tvES#9uzemEvK2H`MTTso}i)*|Qhx@DscD
z(C7lTNLCOrQWqmwUW%Y-@uq)JN|WV+W;2^uyi5ge_h7oS`p}qc>OD(LXp;m<0t#oo
z>~(0O2c9xAx3(Fx+o|?+T^BBDQ`pp!CQawtVN#+KOJvXX@g3D&HdeH}gKXPXh=y|6
z5Lc`y^WS8@P9Mlu#YBswU5LgSQj}$x&tymwg;D)9HfGzcT2lt6&Bl~2Bj`GuBsfS?
zZNluTfA9i$X2ls>)z!<e6I!+1&}vWBU9>MM(MAHP*OY?>sdD+YI`*aOt!#}0)7XBU
z5?K5?`1RekxO0dXw{y8+LT}6Z`IKHV2veGTdMxJ2HJGe*bVmh88wMtdoz8u$5Yp-7
z?OIgn@)2_44dbUJbu1Y|NR_olVqicjd03mpb5=;DhFiZ5IVifxAh2&}`}VwbvOL_k
zeP6zvJ%B~=JntYuB8*2oXn*=Qj3JJ+dD12(Tj{d(uF~IeJU?gy(R^&8^G#pX(uE5t
z{CO4eNno7en5V2q7%8^4VGz!oc&N@?8{7PGxezN`iOf<J2IkOdND7#Hd*731knpWJ
zkb<(fwAARqO4$gOC1l*2x3#c#+}6gU&_mJEp|n&qQ}5ddK~i#2-DRZ$BSD-oxEzyB
zoodR8)&V^#bLn``Sy&*z{=~%iSxL#z6+K&&)j_TGz;O#49YRUxtJ96y#!|IYm%}|i
z=f`@^*hD^5AD`GE-H((EYx;D#{=lU;ys~9yb?>2r`wn3{2O%WqEMujvqELE%#5s{m
z@o`+Cr_Xx=vDN-9+qGls7p<)!2rVbNw<O0=Fn$A}qV7E^|Mzw!UGvKN21$kFY1{!M
z+R3m^tv(>T5Xa%KTD=PAEiQt~N(Pdk8w=WQ$Up__;h4*fg2=krC@kIEKhQsd#b)d}
z^<vEs<F#Iy(5*@fWrZ?2H;@&vtf!EIO?AolNp&vV18*^0(vjHYGugtB@rc)_1G4$D
zW$XAvKB&kG47I9TcgW!}Z&5{tWl%OM^w}UywO|q{t~~aT@@y&b$8~Ci5v4F~m(99z
zFXmDdqhVB`QsrxXHV2UcnmmKd<BBNiTk{Deeejfx4rS6Q*4CjR%JzXnTV(_-r(HC2
zdpGGag|8tLSF&83>}qD2m$ebPC2q2%YHi!Q2ODaKwjJCpi%yuV_Shn)RcbX~wwpI3
z4WTubp?idGSt-dP$mpR7*&*YG6D?QVyvDUv3UX|aygrR>l8w{Sc}u=rgDnH@0gEI1
zWcZ<~hY|I_Xb%+d%$J4LEMWx;iuEjAQSr(f@$K-ow#(c9F1eShUT`5}ZTOv+b3|1r
z#`(Icw&nNKjE|m`S1jpUve9I8JW3a<q%2v*3VDpe)Gf<I0V^ps1Td2odgpNr5w~v_
zv*nGd_qF*-gmg+)C#4h0BQ18YGBJ{|MHQ{amYtVw!4eThyfTO%zx?2yE$F%8jXPO@
z$z#dqg0e`s1B-;xN#sKSK2a)}e=$N><7hQCn#>Mwl8w?r{-q3@S3$|li(Y1{F!Jpi
z-hwF1Hi!b1%1e_^#;`Qk*FQFjIXv2J>=oi@*cev4`*AvB0Q;U}H~}<(;y;9zJU4RG
zkY~vs&?BaK9%y2zMxtMn!fQPW`XtT>_{+4LEEXnTQP(eHx6q7)7U@1%Oza+dwrqHa
zegAvEjVfyqvNms}Man%k0kGYGvr5xd91xuL4FNq{9Hvp(d0FZEv9c!ivUUj>=MA1U
z)MF!3Kg~}9OPR(X)@Q*ZT5!??s8{I<$S6+N$^qkH*=@%uCp+Yn9k&VDA*=Oy1X){a
zbfO2^Sj(eH#ktsN?48w`&Gr=bTkHs~47c)jL&D82V>H%Usw41Jd*Mj6j+H+TEJv=z
zcGh2LYgcSjr2@reR|;)tRrP4AXm1Vc_~qNi_sK{T6;CRAKKDfdv7t|H?reoOE55@~
zR``NSs6xYo=_Cs&nypu5f;C;8Y5Q5O0bQ5Q%fI9o;?3nJeKslvj~kK_X`6$(Yj^KY
zt;v#B5)0zzSY)i<gFhVH#y<7FeP|7KY&nGXf6w@3w4-+cf)&SYI!2H~Hc=a3g+@-=
z<b8^+C(L6}p;_(BqnOCBMa(D-Y%+@TmE&-HS2VOhQh*9)_iKx~&DJ-DiHlg<G|XyG
z$g>gIF_por3}mw*lXU^8O;Xb1eg_Rt-bF~~1j{8O@^~yEF<PDR0jMnvLPkE-SilJf
z3@GIggheVs<NB4>E*u0eDLyD9dGXl<QPP3hf=$6J`6~@mO&kx`9cNT9$q&<2jEO0#
zoG%t%9aX2k*?AfGqLCOW*~ElGUE2rAHfau%ygjJ<#Bwkk^F9m(<xq7`Up}{yfk)Ki
z-TQr_q?n`K<YF%Vp<B%=Q#Jy|h#@UxI(3)n23Bm)sM)b0F`>+k)3HsXg;Ni8J1C2j
zcxvdZC9?>#Wqni>ixBUmV7EbRZL=|H&Do6NW2+$HP=&OMmUVcb*pW&nX+=wnDDpgc
z{W@{BhRD`NuwkFCji8(FlV@#mDNEGRdgIVQ+I%-!b9fP_Y&#uC(&O_CKGo5;K%_TC
zW!FK8b>*2!@>6NLHIt0)v|W)MzR`j0+ojnzU)zMDH&DE~^7tR+z$-0RS4*rbd0^LG
zoVP;l%(rlDVD!IL5(lDl7QT}#y;?MPj~AY7t4%6E7`=o_b?;9gprOwTjBY@R!DX!A
z?UEF+tmzo&m&#za5`H!?%lwB2Mc**zu;YXAxxQXKlq*@{ZBID9UOb+acd%}3#F&+b
zF-QohMgwaD(BVxuwT2z9dz^yRHx6NxOQVJIqo!8k!k$PNEXc_>si2lIz6Xr`-z}G8
zQ@nR8e5^J}jmT$*emLY_@61eW5M$?~05x`AE>Uph{g31ESC##uo<7MitN7AGjQTi5
z8jCPp^#bD68}B&e-JTmcTL{5`Qu5JEpwqT}TMll+M)y;&3W5pyw%~~ZFWC~6`1?3;
z+ze4s1Di^^w<l>(j-^<M$?T0fs3a|UvSB72b7%*po#VDM>q@nyHl3uL+kiRi#q(F!
zisLM8dhW}}KixXCan!+G`^UFz*X2WLxvf4$ON03wUNYB8h-Q&3MTL!`+!uL-tQULa
z&nD{_C|7w&MgHBpqpAb_NfbUt%%c!rD?w5fFtAEql9Ezs6-D)yV_r}LtxsO?a^q)B
z%xFF{-f{VX{SsUfV!5hqZ<ed~p$){!qO6AG{a93(|2NKb$=J#i+WJ(yoAfJohNLMH
zL)mC&JBB&5&LtK!)nE=Ov6(G~2W55H@?XYei_5L0#(ce6TU@Li>0n8Ibfm9;LQEXm
zN*LHyXNP5gW!9J0f(8X~rzi6B`40p{OTX!41}BPYov`yS;~9N9EFA~r1ElFAcza1+
zL6nJ~43XsAgJfoC46@RCU)L9s)?FGWUeuJLXEQydJ)R2Z9iPr6a!X4GZ(}YU=V(2T
zTJ(Fjggvn#AJ*@~8@(7fNP}g$15IFDZjnkBx)3U!aKw2fH78h4`o(;h)Ym5+lhsDA
zCs8TCZ<QtA)Q~l>T%TB#;b1Vt=E=JEgYvwV>&YwB@^tJRj@n{bpn<n3vf{HPq|w{U
zD2?~&T#Q&TbQO6D(d&u{twZ%LGn{PIH*~G0N_Dh1F!j8n?~X}khwR}~5O}w?FqqR~
zb|1D#hV`_Dbr>j5VKY4|$2NeoY7c)YY;jRS>XJ@W25^N=R1%Pkd}M9@kgR43*KDS}
z5o+yTX`uB5n7pZxNV8I&^|u*46m7BX+byRZ`lVsE1bL}V)*SD{2_-c0GKZG3YlF{l
zL@7A31p#?eQJQ4SE1TG)!`RL6wYubIDXg4%_kXY79MJbUY|Mu2K!vroH7fn`1^`OG
zv}k7ZY_*B<O_G(EN!rXXVzpy9GW;<i*%Cr5B(A)@2x*IHwg~*Iwg$4vR@CA9PI=w{
z4MZozY)qYMsIP#f9g1Jx5S@*aMdj!v7?~wyr!pmO>kGYJ=I02pW0ua+m+{g&X6JZg
z7VB>D-h#aHmv_i0angIF1DAneX^N~EMK5Vh@ZwX_384ikR3yo+&>mAHV<nqd+Mdfg
zo?Rf3)fu6OCS)jTt&-X{YW7M;<6YiWElrtCa-)~eWawbMr&#(PDzgN%6iR_hhtZ+9
z$s11618VPzhNF65@1gzM(45H1ojonBsT_x>`U||;+>hcgN}(;nF<Ci@+cQ}3$<F5v
ztp6Lx#lN$s7M3e#&)25rPzow%caGq7+WE?POY=Rr&jM>;^OeUxzOt>d?fmmAx)x!3
zkXb(AIu>MpWuhWu*UF*Fp@~X$8!nM()>kXl@zussrMlzL9{k7=Qxu}y1%G1>yJMg~
zI5Iy-w?LR4RH{2C_HM<VY84f_Qa#i<j17V6{(1+mHU)U#%84t%o5f++`eMpG)Ixfk
zFFIilRbEF$BZwnd2M<0q<vnFfb<6&pn0vq<?!Ei4ya6YMcC)SaOztvnN0+X9gx#69
zU-MXM>&R{ztJ?LYsX6f?mZYVG38NIbFi?>R6BU`Tb6_@cu}7zhvE^0O8Qk*``M`dx
zR>n%y%9*iRfg7t8n6X-c8L2hZtk;l3nU;3(NL>aCbFvrE-6z(JpThew_wZn(XW_v}
z-GX1Nwcd}Ct66R3@fB6iII+q(FH$uyBNYQLQZ4Wzl>#qP1y?528l5`4ur{4*sF_`@
zO;4AwVjV-c#GW}f(lTd8YUa#HPiMA@k)wD-l^}#GiyT3Vk%L)`9Lz%Gty(d5;T5Ad
zZj?i&m9h&8D7T=2atkW77uoiBC$o@x;T0kWvk*0Sg^0l`MB7=O<aog<My$+2%)%{1
zEzCmP!Yo9-T1+%p#mJReh+MdZ$c0&mT$oYhjnYOB{ZLc_1;vUOj&x8)6usgoX2nsY
zildsSr9cZ$ZvUJYM;&t`1tNB&M#PPjiMWwUunH-VapLH6UKDv?Mo|Y|6mj51(dxBN
zO+<|ivOMh_oFilytD*i$;WtjCfH9)jjS)vJk;F~26ic!}U?s6<;Zh9(H`XFBV@(1x
z(gxSCELEkI>C~5UL)h!vY#u4Xq-bEpibl*RyK-)%XwHlj&6%dC-xs6mxmyP?dgK}0
z$r){rCOd~~3)2meuFj4*mm5uNXjOOYo){OO4Eh)=V#(3{2>JjqJc0SBj0!Nkotl$E
zl1ZvoXBO}>=n`&wnY$|C&)4Uta0a4;J>OoD!}o>Y3thq^a|*$`MA~U}^XSH3Dvh<X
zw9qQk28Uj70HmOeuuIYkcB@P9Qt2z*Y`M}!`<1TgUFnoRQrB^R$iCVn&Rj>?R-5d^
zXlkm8d%33TD-CTZvP`c{wbNkjj*Pow?-`v?5KHPq5=iD1%voiY%rw$KI^{@MGJKCE
z&#^vpB?^JZ8qLiVR1y~JG&fUFN?3(pO;Rhtn0cTgEaDBn!*Q^PU0p~$<mF_Y;e@14
zU%8AH46BP%i;V>|tx0(GTf*g!3vJoPkNv`ph>aG;)bav3hMpom4&+y&=;C+6ms3y$
zM)h!GY0hS0_vEL|?R+gU)xtvaNc@aoY!S>R+Tf0^I1FHt$AYQMDJ#ig;iMUCoJ1R8
zrP*s74wRHR1WC)BGKvaunbTkel?r7}gB6r2lsO5Olrb<;+-Xl?LcF+$*Qyh1%2eGl
zuP$S-P{5XIiPZs<Dl0h224zsPjhAGEveINbE3vZj(qucU5G+Y10<l(HI3!3~{e@Fd
zi7USZDk#KNAAyp>A(-_kG)Nk#pb<An8j2bu<rS1F6b=c-R*LcD)O_6DOv(|)s3=V8
z;#Mc_Ep(ufX11~7yjD(PSLG!7PU7Ctb`;lC+7Ahg?WZ`6*I049%1PpNPF!@9m8jwz
z4ip;-W1yt}Q=ICD094>CP?EpKA{FJyG=D7^DJj9y4o8E<#m*Q7y}00cu%c#E^gLXN
zZqyrkz%uO$R!kYP%bJve#aV)BY8Gb;Miy3D3cw)~D<{ohu*ks5;XtXnXj~KZfK&a1
z!NpX0sfNNL6^)ffFFaDxScPC|DL|m4^_i+Er$jO8oIGGrHSV4~U{N`4gDhadiYWu_
zRAN@()U3i_?Uk3BRam6Eu~K^pk2E({Ay{fw1R}F4r$n)WSv6o$wW3)yU{SfEStVe>
ziV0&f8Rt&{CPo!Zsw*oosc=%YjgwePSgFd!;XsLY)Syc17MB6Rq@A)7?SzwRXPhKr
zVWrv`hXW;fjUZ`OE2F3oXS4<@s8q;i4OUR9kjWB^jh5hggJEJsc(W0el^9Vtsm8`h
z>?5pHU*m9~RGrm$bTNek$f<U~WKju{Hs-=1?Ua*73>Imp91hfoOBf_KSRXPc-oKBZ
zXw27=-brvGK^Vysa#X!Bb42gCjwR{B$^s@}n1?0&Hp9MN^6%?SqHMNj`+Czj+o@6r
z!Dd!gQV4{Tn%Ovs1%;KG**F|1RcEmytKHf3VyX!YJEhNnS9qwIa;`~)TvHHn4Fyjh
zZ?~?Dp9f5=2%J1F7u(^ro@6$TGh&##FRj$&#<fJ)!Vy_sEn%f`STN2D47ufLD)t#S
z&6Av)m@i|ed6RR?0;kC}9j;E2u-KMW2DuToz-}i?3vzLEbzu>U3Y~bxLD^Vf&>i7C
z|I=|awfe<IUpPrg1%r%I7(F8hnW8XqM#Gw<iduVV{i$hE7HPucWeG#0Wnr;0g?1i+
z(){Qoa3NVPngUD;mS9p=S&6d3N$qBwq-+Q)Rn|BhDAjJUozyLqgtT%ggB6rOX~t?W
zQc*&YK{XgDDZyy+A;D5Lm-Vzpoa+l<#S2b2dr|EyFDzhzG-2av*F==yBnO0%gurk+
zjz|XWjL9GpB(;ZdQgaw5$qZqo#xM>CN=iF|q=Oq}6cysZjRq^IR4DQqte{k(&`U5j
zT8ghu2e2LB)QrMlwUw6?eSMD9mQYl%G#IHZ!Kh$KutZIC6mi}HCQ1q>9hH@+D4bM7
z<0RQAtW-baaG)fw5hTrPWfT?Syw+d^l?r*S!3s(h@>+ti(Ndgr?@NX5eJSnU0prJ~
zr)KL*`0hZwQZ-$|TEtnZd?<p|@A){Z1Se7t*A}tKH4`s<Pb;q@uNpR&=i`je4vx1c
zufzzU+QAFNQC#&odp}q|qY*bQ@R-4dU9vU{-a;EYY|ON4eN(A^)$ep|sfMp};5bz5
zy%;AC`wsC^i$M0Kf~rB1MoBqIsc=qQ29=eR3FmO2*w_d{+7y*Z8%TMARiQd9L0A#0
z&j^yJv09%h;3Oj@Ks>FfgRv4DT`)hfl0G2^@xq7*^N<uJLw@+CBYtJ1DlWte^zcvC
z=M|^*-B@u0q@2{4A|`DiHBf3!36!>v5{R@zbx0E^^+UIg&`D3$CL1{G8jmp{A}I=h
z1^uZgAP8$;RGx}LVTOo!N%MI*3zW@V;62|*ih)s3O?YHmuvk51B^5%&vw0D$VBh(^
zRL!M2jx&@r7^~O_gr&WOklns0H8bgYyTIu*DauOJR!*X!aAK1vE{aJFqJav6DZeyO
zF|O1Y5-7HX;CK=<Gu?<Ae1VC!f=OFt#o4D1rP@lEv}$OeR9gu|+Jcp6i<SfjEW)|K
ztf0-*(RI~Zaid}^JwQ0qOco*32OsXyvvj$HIb3dCA~-#Wm<Pvs3yx4&<q^WC7@?f2
zDT#1-0X<WlWY5GM;LJ>i=JMbqW&%vG9J-DhSpCFQolCEVnocv$cxgT<FDVtuNn&ia
zlNmqu@7qb&Y78n#8YpQAELf_NhN8lxyi`kP#SMl^OVpf?M=CS(wIo%5q@Zw;k`6|y
zoHCL)!ATWU1_dFd$aj_0S}p1Y7Adw`&`dZ5$*kKdS3xX1rP?JEwHcg?NVSt$nVgdk
zy?_QG?RcW5VOTq!sA(W-AP{}3T|3^HpTTV-sdm7uov>2dfkU~foYZz;k?oYjffDW7
zi}87`nFYO=1FM~}wd_bzk%K$5<P3ar@?d6Rc_|*DD()6AX+rQ|r!=5^2DRjzi=Vs?
z?H}6Ucnk*bbO>S$GPMRuZLO@-*v?7}sl3$O&ME{;435!Kx8A%nl}<Zn4&z#jq>)rc
znUQ8|^GU;@xEhZYloOXcV-&;0+G?0)8m2Hwo5QQQ;gW@@l*}#T0wT<nN?5TTSum;v
zIXkWiftzGd#Ep#~*hw};+_J!B>c+#7xg!hhcqptmNsk2J#27D0iL%mUI4e<0d1(Ti
zRR|WV-l*ZlFbo%`aA@erYIQk@h&>bWndd^>Yz1aqWiw`{EM#&f%|g~YxV9#(fRP8b
zS?qPD&`f8ZIPYBk6g;{=)tK+{)K&E(c>PZ{b;=`bO}9$YF5F_`ThpaMiy<dFi_`JW
zm8K2MPJubqoWb`s;`JX5i&H-JtBa8tyP%k|i}_;gve2{jQrTdahF&TUy;K^ySuPvw
zGTFGVs8F7uH`t}2%Qb0s(PXJy_EM?rRu_W{zf2eKOT`PnG<+AM<7KUK`LpGTZGm4Z
zzl-5pT`UiNx&B>j--4CPvP$^n`jnd=;Y;n)UM#6yC<?+alMjBW{=zQ{zuf8;gZXrQ
zrZg6PrX(J0snz2S#A-9R`bu6le95_S=MuQhco>j#OT(hLMO|(PjK;SMzg&^d^lYj4
z&UCpl;CBgMs*vqgmXsgg@+`^Wm8Hp<{$#1b61TE6eRY3{B;yxzab>B63f3=gU{qHI
zO9e&&MoR-MO!rS0&AEaK(Z5h^(v4rH$wH%CbK#eU?{tZ`(?t&WW%_ic`%Ai>6;x30
zi{pVQ^C{B^Z>*Hm2ZRT|JpAxrw<pA>^qEeVC%`XFo$yOjAsJMfab0r`ZCSS`y4co?
zSg3<5OZQ-1w1DMFF^^(erW-58A}`E>{lF|{kT44&>+|yk-VD~Dl4UHdb2Auu$@}Q(
zSZzi=99<R|A5w~6mM{^ki}IRTL58u537%Q))RHxMmm=I^=;rkN>Qtv7y_vl{m$bX`
zisAIt%dCp9=ZZ!)cEM1>ZkC5`7BfXcV_mH*%H?9{`C8{Hyna=pqx%$^BCL@Vr3<s5
zH<-oZA<SaPQsZI0qa-FUi_bS&B{6|n4B1|pD=`{O(3~rg+g_RPTveik@yn#Q&}Fdg
zAsx3|m2-;)OhcE(*(w?RXy~#SuP&L{AaIGDz$~U@xunF+gIN}`MCNj{D6_p-Oci(q
zi3?b#j}L`ubrfcyPz$qA{TFIeS9LnmUHK(;u}2P<L@J^VPj-1^8D5;LB1-tBk4#UO
zga@-r;F9!CPt!`a8wagSQ4=t`NG`MQ^mM12B4tKK@WWlCFPDo4yXylbxivivJ9c@X
zG<bPnd1<ZCS})k`0!dpfywd0}K`+`C%+kQPrl%NqWws>W!7P=qGFy^5Fv|i@HBl$8
zF3)D2k{9DOcBwE~2q>00eW27b>QhwK*j-|nT`E-x?5+=#sx-UQO{LkTQkB3ii(w8O
zbTI<qmK1tn7lqH^{qzzM;FgI1yC`BFf=h#o$Kj%IW0$2z`qwh~;C2bF*G;4~0Ya8b
z^8;OSnRMZnO2;R%i`fk!U8HNbTJnJLOJi7W&MlUy1pab~9hBWoP<i<Blr1-#rNNus
zf-je}(5Sp%m#I@6zG88rEFeCN>$er9S=gyfmy|Q*mWk=iEzcAUFWh3`6Yg9w@xm^#
ziLgroqg5`658RUYz%7x`Y?cHCvov|&7Y1Mp*g2kVbPIlUH=klh3pu5kDE!h`yUH$2
zW@(9n?8Bw950~q`s8^{_83D62`QVqx7H*f|C3@q#;N1e3%I>CjSuQVj$z|}%WOvJD
z1n-g)i_MZ;2D3axrMZmIU944BNfyi7jSl#wDe7Xa<;jvt1!k$<WxbYkWnBW7SY&y!
z+#=}8O7$oo0G4-@%I%^`*#Hyay9_YZr=*0+1LbA3tc!+}(!k5Dg{iCNO4{1Yqbv>P
zSJES79^D`6GTO5TONI)WM^}l>Zo0#x`$OGyN0sXS&^_ti?4~<B$|T}ioWejGypo`}
zilsQo1hY6p#q$4re8xa0SBuk2opNS;D!_u)Yq+5kN3d|-pg6H#Y&Yi$l^M)pAF<e8
zEDO0<5>n5lvmq9RTaspDSBvu@eV}NM&g5j-2CuS<>FboP;z<8rocAlYF!NXa3cY%H
zV!Eb9Jc>&N$}L8?RJxd_w^Ws^i7CHiok;m5Ya_}pS&VajQJv+<5>tU$7P2IbXm<-C
zm*qZ};s%Yfi~BRiE^N0bySO`J?DEhhdovomY`4fgx~NmOU*u18QK@Xl$e$=vOIz@w
z;jQH?+Fto3%VW+j<N)3Y#9f(7)s?>CVg(MK{mJPqZB8P;Lc5Xs756EE-(ay7$^DAE
zPmy2u_(scR%CX4mO36-x2sO_x+L-5PxoKoMt=gGs6m|qetlR^((nYHJmFYS=)4woU
zn~{5z8?BYAC%a@z6zrbEU=G(!#=`Uhh8WYb6<D-q@Eq;#*}2C@;oIfe!&v|9`lxx{
z!;{@(l}Ee9DoYYW{d3D@-T%r$@a-Rp&nj6lci-kcJ`3NHXAk33gDZs|Lr=4H?}#x>
zDAsmiCRKL|@36-mtKj%J7Op^RBu9@MdgeBM#E$e9IEh%iB%O?v1t-xcgN8N6ODw6Z
z^e~pQlDeb3wC{FSAy}d&mV~g_9w()RBjgEAv~JDts12M{Jup&5TFFa3I1)>T-IS9g
z8bMel9sHGN3bCXIYY`+#YHKE$>PW*@dZC&&T=vQr-mTJix~fYxd=@RS3Z9;;*A}X!
z_pYgkav!-wF&3nkDl#L{n~&W$l#%3$a*~HS@>x84oxLuvpW!@yQk}$q5$|a)wDpso
zRovn@nY?+1t6Tl;5;XI8Da~JmZ@>=r8jl|QjTP_Inyuyd&5H&&3v==DbZ|OTjik}U
z9RRgfe5AP1nQAR9risz7peJ$J@&AN1yI5ODPQi6%@rrKxK3yZ@)vsPo4w~Wvp2;C_
z#mM{Q4S!{F`IiT&1}G~nox)18Oc-e*`Os8H7)3pWTb3|fFGv}PyJ!;w$=$Tn;B<tS
zRyAdj@(7hG4@RmyPDbH-m`QYc3Owa3x01KQ8aPrp+rowJ$$c2$VtA0$wvL{as^c59
zi9EcuO-VjnEQ4TiAv|0xbBBwC?r^cx9WIu!!$rFvE~fnOLLupgi>W+ZlAzV176sOo
zy^&e2Os)#KGPx$?%Dy;Y@?P7O$@^tj#wF*<B=fIKa=w}N9?crwNlNmhN&T(jxG*Ur
zE;;fJQ#=J%oID``s1LC~$-#VMC51a<#T}gSk^-Nx3c(UJd02pBxb%jQagvAhfP9n*
zO=Tnp=8csk*pA+(b=QNXNw$D#nloOK8e^uZ&UhsOOB5_7D?Rt$<f2h13B{sNEDL7B
z*kC1QF0pfy`q`#35~CW2jOxsIG~$n@MzwJ1>pmVZHL3+nM<y09F<_H>d4!So`$%JD
z6;w7Z>8wmv+L=iXdqk|Z1}*3<+(hx@?jj61llPbvCrOY1Ty>3?sIRP4d1oc6D=$^t
zS%qMvbYIfK;GyL0W6`_N!WfU$q<4_*Nh%lmWI;{2y^7UL-bIG2{<!1=k}dm-rUZ*r
zlsCFrOhG|;qniU2)Jxv+hIa7;M<8j3^RmfXbQ*-Un=EK29J0$~K|A4aAj)FWrl?H8
zQUz6tniLc%>XE9^n!Pf)ZdKcZ*wQ=!@D?bwoCZowr>rz*ot4-{d1>A{s}L+vywDyM
zn<L{;9y>EBgT^CW%bFq!NZOV)L>e&GS3bs`Tq-Kp($B?P3BpKn!Wh+L4OMu_ZMb0I
zbX`0c1xK!ukFpRPEK9`<yhcf|fK#){OP*<QR8C?t=fv5jti)W-;XsM0u+&r2i%DV~
zm5DnA3cM!XdMYq6vrMk(!D?CACFe0axmFGHhe)POLQ;DOCrP|8l7xa0+f-mdL~2n9
z!ZN9XOOQe=X+wh`u`vPTRRzF!F-2f8Wt~FOI)$_)tGFVjm^!*6%>oU_ZL+dB$$W8|
z2I55X)oBullAYYS(884llSk5}jlfItDGSKy$@y{9k;_Pv5kjY3MIJm&PzX+WnemgP
z$(lYcrH{)eShbmSC83q^($smtLh1rPO<m4T@-4`wRA<3C)ft~sowMWiAZX61UTWi>
zqqqT(kjCUh8aENpmUp{r&FXA>DZY-V{AQ#!u6w92CEqx}cka>~VT?i7L>M!U*f|NS
zy)cDdBW|`9oW<gtUG{Xc2)xklG*)GmOg}#tl?~jLm!f0<4Bzx3A7!MmCHMNt)q80>
zrkuFc2qP&M#)z|6I7wMB1_g=N;SeCX7gaE+nZV-tw8BgO#wdIFoL>1C*ew{o$QYX!
zA;IYqIBt2nT@Ij^_9X)a-2YX>XAF}?i@=M^ea=iXDB{Q2l(Un}irH~~<oqP#Vs>fp
zI9Cw(>gBld8G{mmAXLOWSTeqJ9_ua-r>&0%WUVD&+S*#cRNtlL#dshP-CC5sy^A4h
zx-B7N*r;IWkd`rJ6P`#11o}{#KnX+16IPly<0QEOR+2Cov&QNOuCLUSv}U{{djgY`
z&-qCi3+yx*5j#;c@Y4iE?9$+cq!m==0wog3*vcxZ$>!EzMfJEWNw8QgoPaI;%#QF&
zho<V$#RoV3){~FY;G&IY+(9djji8J~A9<n~=eGq(2CW$@&FjF8b2?)t2F#gpwq@MJ
zh&i()XhHFU-bJ-}xUCU@Sx}k=-5xHjWX>#VEW`1F!pQ&}kEY7u@PL2Vt#~^c#vJKv
z+!(lD1*_D^^{C3a56E)7R3rzSW|FNy=iuN%`f{RdZQxrfu}I_4guuh4bApVSTEw1D
z%AK*23<Rq&(|}px7Dxm-m!EfbDkCWY^6{v+bH&~j7^xiLkO&GuZG>!qrKJUow0J8c
z$$oIiB!v=!3uY6Wr#GP@R=(ufSV_5+K&%Sif~t?PGJFTB1R|>>FrFaCT7zHSHi<{M
zkAD#_meO8coT|%bhiglXc9NqD^{M5ia;u%%jNZDl94~ToN(1QU53{r8-GU^BEEf|m
zM|Kf27^kCL%IL2Svapm?>B10IP7lUX0Fy#1m>OqgC215+T3C#e6kK7Yg~d1=C@CF<
zwhf1s%a&O>;FlK)@hJCMk`q`s0Dwj-$#~_{i_`c@V!GnxpG}NSCm&4g)YBC<`-&ok
zN*3iLM6xJnjC4^>c*%mBFggoKfnHj~+tF!ExH*l2%q%tJL*?NebjWEYV=^%CA;*$r
z$mbo?2U`Wbg;P*mzW+!M78J!bDx~PbWOB<I)LKjzGr=hs0K7P+E=46`Co6LJ==@5_
zx?sjmR|YdKtqo>uULC|m(2-_9aU~O&)-mP8RZJL34KqeucZ8GFFJn-UxMx6s<c@5`
z1x4tFYz@S!aL=HDSQ+jaBv4%0ffJ~kv9Z-`cecnOl`UA(u`U@eRXgJ)7BXh4dd4dT
zO!S?@%)0DC+NCxh`B`f7k%^@?AAG?2QZZ2Bcmz&Z#dUsZ5r-^d0|`!wnli{>#!HHu
zvQl$7D=~udQe!!*5G*#;a+j%!@Jrij^(go0GJaU@Hhxf#a#1a0AQo5Bb8gEyw}-5~
z+&YX&Ie%WkxrHx)*p;wyv=;+#G{AATEO+VFgkP>}*KQ3P8|l)mF{*OjI4T(tx0*J-
z#hnpw(#8)AYWKk5CNKNMZyf0i_vik(-#APmNcQF5Bv4@>gR35B9(1HPdg4fOCg@0V
zCg@0fCg@0VCg@0VCg@1qh#yJX@FUuGrC*MoYPLJeI<~-@3b>6;>V&)WyViO>QF%D0
zm~-Ulq;XfO?S&q7+SN}OWeHkR-V(lU+Nrx!#Hw=@`&!rt#QGpk2w_5|=f$SLU4SOl
zmB!+do%)+v#i`fEillt%$gF(E2G{Y|t21aXklD7-U-Ym~D&tDR=F*V`8AnXln@e)M
zak_yCq-iA6BwUp<IVHNnF`YT)G6#0(mKrj=l^b<3=2GTZHHRj0I!`2=St8*?ypmk3
z&evNVjO^8Vat-#<j0~-D4yoohBdT*$ioy&&Yd%?@)thgFTcilE0`9Jixmd%!avnh4
z>fx)p_E~Q=SQTO9O3zjs^X~THs$7()$0lQ@=Jw*U&yiCf9U%z|pFLk`U<)CUkTHuA
za-V_({f1E-+j6UM^>V%HyAg}^1+-AeX`KQ|o=NmxKI{WX*~8c{kgXsgYG!<79YZl?
zwft+#xW5-~9k{O>9t(o#XL^>AKeH_@hQ^6PRjVc5QuYxNmw_*4jTTPgO4iD??&1lQ
zebw2aouagc8{Sees=BoTke$*MryK~DERZw2_9$5Lb*r2)U7uc_5-53%XRz0;xAcqC
z4)?-^v$uNG6V7JsNPF4JCQKRR;%@)?A~MqJ2?C~t!+V*CU!q+0NI}U3y&xG6cRiq-
zm;hhJJ~EHD0OlGpIKX2a+z*_)P}&?|2sVukFi(^*y^JM5K3YvS_h9fTNl5Iua3oJV
z%B0Rva8Rz^)PjNiCCnH6v-1FQ^dLvk7wqlGLFR>5RkYbauW#)Q9CI1R+8A)Gje*13
zm=;zNkgSCnY1WfkEqf&32~n+NuV)cgr$Uvi2%!+*(_hskl#ljeZBeE;Nhm2*rC}^Z
zD;nP2crb@Sin35%8(QjRqAE_+CsZkO7|)kK+$5bOK{kKQyp|SZQWg;Atth~AGCV*W
ziI2?sa<BNQBj_k(7>5#5%`R%_6qveRQpT3iW(i*!?-I6j7A5S_z=je<MPg>8NXpI?
zN%*-U2|HILVFyJf+wG?IQ~17tYScNb19Vls)H7GCi+514+&?H<?i~~^_YR6{7OKX`
z)Xc02Ggp+@LBW(C6ieAbp_E;wh%Vo%<)W~#y9`>&*ky_!c$p$#mni~vi6S`qQDPF|
zmZ@U=5?$1zL>c9mXrufRb@cUcN<T(0B~}q`i6UT^r~z(?65y7ofZ0be4`dEgqJ*+b
zv=DxY8p1BoL)ayX*t_y%3^2<SQFe(U!Y@%o*d>YxJ18P|`J>s#=S=i+EY&0C<!Yqd
zphdzCN+jH%L&8l}kgt$fbEBv5ay?=XQYQ6EHA?(awGyvXx5O(bsKvO@IH%lPHRcDs
z$Rj94{Gbu>gF48*f-*5LS0&{JMG|&UBjE-m5^hjI%5p)6gqbTr?4U);4{D_BphwEi
z6+wTE2}{eq*`}oiZ_0J;zsme_P0M|Q!lm9p?^55OeyMLrh1AG`ITL2CB(Z~bDL<%{
zvV%S;TNJVVR&ijS*ugwS=A^YHTu>k*?wE;1imAE`E@LK|klL!wkz~H0GZ%B{$Zi?)
z<S=Jm_F2>tM97hf#U>6N&SvurUzx$%nleAjmSB7Yx6+mkFP-^hPL=PAFj=T<y(Qpe
zB#9fPn^o*8g&3Fcx!~F&-g>O->cEQZIALi)Rj5tko1#FSN^NSY3X|Xn2;MFR!fvYk
z%-F9iNGe2kr4&n#PFKx=MMh=FX1F-!?AM;R{Y+)chN?MSge^@Q%Z1oNw6dBS7{79v
zqI`Ly3U$SeDUniSiqoo{uU3Q{Qe>YyRA<dN$a5qg;{_>^I9Oe49qG|IU=16g75TxV
z@~cT!2NV`6`Wi(F#Ua`nH3pIlh!uMynE+j%H<pX=Bx_(7;z<@35(^@~^YT}nvFwGr
zgDHy;S-Ze@73~LF!HL%{jA*RN5JRg&Vs!@;RhPu-4rd`gFieW2U7*X*v<sFq5gN_~
zzy`)Z+Tky0SCVOAX;+qO;b~Wv3-PoI%e0VRt(iu!V5U_vL+$x_EWkNxwf*Z}wPhUY
z#H_l3OCQ>pCe>^68B9>>Cv!Hu+Bqp(Ws_65r@dk;P&gJLg#-k}1;6syOf4odOs`Br
z`c;+5Blf@%nI2AFQ(tUXrYciXndE22e#H_BVM?X2gVR-WzzWI`Q;MUBU#WijD^jEy
znizG79C4^1bI60@Qc>n`)|~kuV>E<S#LVfEBug@H$zb=+gjx0&({&S~FEij%EVFPg
z;>+&(Yia^&YC%=9QjrUXN>yqM5rwfCeo+1NS407LlGP=OibJKDL!K6w$}@+vB*|cC
zl9ifL=5$G(WaU|s)tL#)k}OPBQ0gOQ+Ng5+D=GrGis}-<;!qXMA^M0*rJBQ8q9Pco
zqEb`QoG!^#RGz7*&P-UQqA*=IB~y?+iDp86pr-t)aCJbmP|?vS^bv;$HEIk<LMhT8
z$dCf1GSmSXLPdsAJR%N}VbmDV15lEvBom-5g0WnLwFt&?A)YvS&{V;%+=(GS5GcPY
zPaRN5s7N!4_{AZzj2c58$6LGdBQpH`TyuyFFjR(8c?1rXq0|_VA;*2?2OnC1mEpig
ziOezTR7MVHF)CBKFsr|aPyims$9>>~_ssMMC$YsX2e6Gwh_=)w`PDS41NsRS{ft5#
zafp6Kje*D8)!Jc1FAo1MFI-0&b=+o%Zv)HE{DLfm>eo%tXExB2>ZXVN)>nI`+t}1X
zm9#yP9$lah2&0?eZnj&qd1$oJ3*y(hQh$&JI7K0>>Dn(E^2{kWJ{S{bhCwBe?yJBB
z2TuBE+bTcW-DM7uYAmx(0I*Qz7Axg$7$yT^t=ye^h$f3|TU2i!anNpw4q#*JWxgRz
zlmOo~M9Bn}Ha@ExLPZCw8A>Dqs~1WXqE=X?kYCMTb?B2;;{|Jd7l&%B)SebirGvoP
zcm06^a&BG)sRM$9iV2M3IdO;}qs9;!_!7PSiWK=&y@^qm$PtGMGKV}UE)``CXNj=o
z%9Jk3>MsNe03R)={(u9g#h?yEAXMZVg)DK1bfd<A!2qQhQKBlE%Osf5l%rNtmkaS`
zL|CSZ{NhlP{fbCA;bbD!B_hS4TA4$%5SNNHhqE9Ijj#Sd6r3hW9S|f`<QT;>;t(lD
zje*nwO6ruTD&{f?mOABV>eS^zJaxh{RhpIjd*fjXFmtSz@zI7#fU>rZnSgL+YFK#}
ziY+21(?UD=Y2s_EAPd-j!}9u(O89#DbfbokdZW@#Ri@kcUz-g1QhCKbUv3{Q_m7WP
zvX78!15j_`Jr4On97-Wu9H?W6qdhHTTK*(h3xZ~46GAt4@Kx*z{-*TDoN9I9N&Qm_
zt2<pa2MneR8DWW|DZl!3_OL%I875w0YoYcah(dV`_aj#1%i3_uFH{w>pk&2<jfXF5
z>wF8%8yxsnw*4Yj0rEJ$jx9gRvA3iZN-Bgcsu)G&;t*ww8bf91)0PT!Q}(PsYN@bJ
z3=di=<WtfB&BheE2srR1Y5i3>@`Y#&SB+t^><iJxQLAKMgEp30Mp!CU=91up^nhZ2
z4Y{TSO~DcDU3PT)O?H7R@}sAW)q%7sMG}S1*stiK5UMEkV45&xWZ^{(VKnh8#Yn%e
zY+qH@UzOxvP*#RW%D$GY4w0078Ce{VB-tCjf*ihm%wIf?zH>ZNkG^h<{iqsx4WFFM
zU@KQYBV&&I`^Ad&RbfOZ>vQ3O{0qf+5v_th3?Pt7`3AB4;8*rIn@5DoCpC?jO_d|Z
zwVf%cQywg<6i>?zy!@g->o2_YauBtZxnOp6h#+@B19gc+cQ^|o@wra@y084G7@-gX
zA|jL^G^jkTM4>*aE_{O*eEagQIrMS;%C2H5gX%B|_8nbehz#^K`t@4-H4UWG5gFFk
zI29Sz*EltX$iT*}ea}{ZO$Oe4RvDn04yE!49IA&>V?ai$M@|e^a8^P7u9Ba5v9%IC
z{4=wF-EVolu#!#go#wBN*+*yTQ?mk57ScDz^rNx*CD@98AU6Ljth-=<>=Uq=1KMVv
zd(9lqLJAfe(gOQoApc~mkz7GNbXU<|T)kpP@SJ40X;>~@nZ@$bl=K<qTEzuH?luQZ
zfsc#Ju@)t(fUV_<zNk4Hj3u|3^;GotH=mwSoKTP=ZO}TbX#<&ud|R~Q-!wHM+3K!g
zcOYYpBPGmS$lA=|tY)QwZg8oBj>&qj#*Fq|4UEAjEBXr`0b2guHS8=zVH}CVT!<ob
zI15qug?9}(k~E*400CPXRwq3bly$t~fJ^-A8Li5@umJKFnpmVqkAR5_2Uf6rv1n()
z>?jCA;8X;D^$&fWTxTV>p~(@7>{hhwF0_W<fR^2R*67%cPjXe6Txe!DljT>BnM;z3
zp_g8@rw*7#FjCmDlamd($O}le0whb!rOydVj3a*X9Ed!pOJPFwuBz-Bu13cWXEv~z
z>k05HwZO59wBWGov*5^-_p7qN$<*;{vB1e9@GG#u2~qgnR*g>PSi$(Hf(x$XS}VEC
z3RhTNi9>2~T@@~=lB=oYLMpv$NUv?G*yT-5B;m$D8)FVwAaks`3$`$pbam>2#5%sD
zZg(s>K}E~1X3Fkf66sbsMZCF0e&&KSb4m=ED=>pV#HOB7m-S2$ewGo;Qe`)W_~k-i
z>T8RdFn1zqb4k>hOCHyd5_RUvn269X9CC`J`ZYi<ID3IFW1DDyhfl?1FY09>)OIEW
z;xPrs9|mUn3-LM+SK;P@(&`Yw?toZziN@}5mI}m`J;KKNf{{#^j?9eZ!ep(%p43GK
z^Hcrgc@?IyVt5EY8y=cNwbJ3CVi%*sLuI%ST!aHSsXr>ink3;#XQtG2vCC|fVac+K
zYlNXP^l5F+!18CM9~9)VOD`zU<Ce#;s2VR1s9Rbab(ElR3@s0kv3kODDM!jq#mbEn
zwYL>MBvBors5@Y9b&0a>a26D{F_@Pyhn8r&@kMNAE|r)UGh?buFK;4LoXyHSjw{Qg
zN?zZ_k1m<Y0V=#;A_QyBLa^uzqIbA}>U%7pGCG*YE5<dPaFl_D{`jw?Q+SdaN}-d}
zRdYZeWk`;Q1G==Qm*vphyqwi*IO)kw3ePXw{h=)!JhNN>(Bf946_&V!A_^f83^JoX
z?j>3X&q8RK5a=OA1Hh*ITrEGil_Ok&k-H!<yXr#C9wA5%UJ^$HAUYt4F9MMl;;tXY
zpI<hSyCl-=1`16~jwI5|OC!yJNY0Q(nuEwoBF*lmh@2K>b~#0>-Lulh<-cJUqt$Nt
z-UnQI{teew;ssAkrEu6#{$$h2&mC4IfGkO2<fLcz6r+-0_=#60u{9=);3FG<SktSt
zu~LVh`r+D<N*mWxB0_k$qX*{??I3Byk;NSBL<UZ_#}*i2)iH2<>40z##%+NmnG%D<
zQ#M?%i<kMInY%6u&d24hoOw=Qo)bB9|MeR}fb()!?tgw@o*y}L{|kcu#@rP-^N<@a
z&I4SW$F(VUUKj#gm_PP}z<fgNi~_{YJdT`uQSQvWFOHZIH)22W@ge3Yn|?bme><1(
zjKF+G#LT(>1O9lEP0lTd1BJR-kwS)Z+*em*;E7YCi<m&-DE8tk{_3@gzW*RU(%>yj
z&0*aYN1)qNa?1iv(RQ!|gd0+-Xi~AyCN2{!p1AkKe)HQ;u+|9{ZZ@&s86!<0>ee<!
z0NO4gsNzOMk}j7TQHaMDYqOZ$`cACxw=c_eGFPFN0k7Z|Ur;HoIE@U)lAY}rR~zf@
zl?5!2VXaI~`QxWEmnB4;Atksw1fKC#BZ6ed!D&AIk~yGo@x6~s4Onp+SKJ(_h(j+T
z7ngQAxRzFz_vApnH1Y7jwbA&>tl8d|*o0sOViCURTI-9*0UR!sHG8b<`3)q&HIp;d
zn7Ic`ngbX%2CET5+nIYwHxW=%oN`Zy5sfOl6U12-iQV;)1(VT;dz<X+h7V(k)T@{A
zBE)p&=)i%-Gh_hLD?PP0xJKk)xV6L?UOFsCBrt-InU)MB^ao19X{JyItRPejVAKLj
zzo-mNF?^twj27%yZ{ScYF31!wbxQvfAxIBi5=8_MPe2k`1R^hw)}t`JC8X2{eMB`^
zj@ngSnK&KkX{ctU6K{{>9iJv{zma!#QID(m7(I%UFemMI#t5Dg9&Vp-n(=KBJ!3+Z
z%!xGS&eh<CLK$1^>24SA(qTsBN3wNM$eEdB8Nj#%9lW@A5Q`xUSSoC)Q|Vx7TwfKD
zcQi1@gQu-ubmnB5uD?2PHCHlnl^rb@t>RRNSeaY2F>e`axf2O69%6w51=vWBwhiLW
zu2YEI_E5Mw0aI^0rPm}F5r4Z90aSq&0s&%o5Y@%a0;u{3ft9eOqCfha?PLkhpVVy&
z#cERVu!n8WLVP48Vo~en!|{sjY*WRL$5(W}Mt5M;X)4M-jOb`vG#Q0jzEk7W7>LC4
zEssUss+p?bjW`f_Q$h~bIMVj6vjh{{E9KdX<Z|*JClzGSu1<MCUwIbdOpN3O$$QVB
z@)k7+mI)QwtKDG8>wF;LHEwgOJbh(bv59KA41NC^e0}R0G>h0{0!Jj`#hFUya05L?
zMa~NP$w8##NNZ`XE~$qT4g9<l`8<HuPkFIgCI$L-G#p`CfX$@}{$}(?S|9<iybzQQ
zBdbc0!2+dpfX?ZUK4+yvc>bi84#iSB)L{=>=@3R!*z&W8<-m%(!-11=bvPEWZmTX`
zji~s0!x>c#Z4pD1G?(a^xe%Q>CBn>=F%jQfqk|vmKlM%u;oyC-O7@0u_Fi!IHgI?c
z7!F$>iVqEHUyodY-ty9|{lX;r2Ck}VE@-L_QPdq!NnN6*JDdfT@Gc8(e8J0rXo6&Y
z(2?e^o>7vYp4ob<j`vY20%U(pXk%K5jsOH>fW3^9bXxqSpAjf~ZTMZ1pH=)^)oLGZ
z*%3LsYTL%fL)MlBhc!bPTU)&VWICS*w8n86Re!dE696!cT}rcQZegL4orZ+NDs1*P
zr0yK)d4<YK8)?W6M^>`8Q}LFf6w;N@daPv4NA}j~icOGkdteI#CVVP+TDS7C?<p)%
z=diS;IKgpPj&>cMlVg~xqr+9?08W$2pA22`%BsAmDzB&FrBrzpRbD{FYp3$Esk~w;
z|NhJWiF=*=+|xe^a7;;nyN|6@{_dm_4`=;K!QCHS^I5aNy|=*4-@X15-+E@Ha<|j$
z$vd8Vjq)=b==Y2t3g{0B|Ag?*37>UT<%Z`UXE?||hw!<C*Aw1A_&mZvushB-{}BHs
z3V$KteT1J(ct7C-ggO3$<{#p}jPTP4Kb`Ob;SS*y!y($kgjWe4A$$$t-ys|XyW<(=
zAJX$o3V$QvHxqsf;kOcg8)1(B?dBiizlrdB2)~c;2Mq_YA0qr=!XF|0QNkZ190a@L
z<K`dq{UqT}5x#@)cMJ!y-zEG#!rv$S1HyL_4uakBL-P;%{)EE+l<?08|D5pY&q~{s
z2NLG^A7uU^{)Z4ggYY9s-lGUVn($)?|2p9w!mQt!<{$KXEa7trpGWe}Cwu|njf6K5
zzK}5Mx6k~8eg_CYh452J-qQ&GCgI;A{B**<O_=qont#x5l5m~y9O0`7w+x49+Jui1
zeiq?p6MhciAlMzxHUFUh3n=`xgkMPbMTB2W_$7on{+E*f%Lu=m@a=|!zMm!h1;Sq@
z{58Wtjjt2_2H|fKzJu_$2nWIL__p~6eZNQePI~@_gnvZ%$Ao`E_@{(fpP!k3&}ZGV
z)A7tPgpVbB9N`lPpG^2P!$FPv6Mg{U9>Ql5K8tV=?2fa|Kcw#*!W-!M^9Y|$_yWQk
z32!3I`dn!KL7%M@ejDNKgvSZ*AiR?>$G^+`L;O!7yoYd&@HF9B!y%eE!VSV#626LX
zlW-91j(PJB`nL$T2_Gf=9Kz2h{6fPa+7}UiG2xdGektLX5e|ag@pAJI>A9Zps|epf
z`1OR}MEHY*KSKE9gg;66Q-p6P{8_?ZApB*+A=zIc{8hqVBm8y3-yj?WyW^YYAME*0
zg#VfF-6Zed2>(0b{~-KJ!v7ax*6%;fKj^paIca-)9N`lT2QeoSK8f(jgij%SD&Zj5
z9jBRp(65*90O4VhH$r%n@EGC86aEdttltyNKj`;F!dnTCle`^-cM{%3csJoo2(x}q
zGXJ389>O)k(<HA>c!uyS;W@$$!mQtw<bM_6CgFL)Ey8WW*BK7!|2@Lj6MhBZR}y{|
z;a3xW4dELIbNXLP{%;`s`-I<OIEZ;G;kOZfJK=W_ekb7|*c~^Sf3V-X2)~=~dkDXm
z@E;I<AK_0E{v6>i8V+iHiSU;Re}(W@34e`n5bTbxn}10EHwb@|@EwG|Mflr<zeD)D
zguh3a_4_{g|A6qFgnvl*M}&V&_$P#aO894le{MKe^SSAI#5%&q5I&ahafFX2d_Te`
z5I)gx$iI^apG^1^!uKb9CgH~#4(WXy;d2O|OL#ru4TOVWcbsSbAwB04zJTyX!kY<i
zBfP_Kh;}F8U4(ZNzJ&0T2nWILm>~a43GX4i*KkPxQNqt6{A|L{A^cpz&m(*-;TIEr
znc<MEmlM93@E;QXBf@`7I0$yf2h2aD|IY~j1>wIUd4Em#ZwTK`_|t?xLzwmZtoaB1
zzCifPguh1kn}&nfy9oay;eR6h3&Q`4a1iW{e>VT1@7;v|gYbWny#FHH^SrdZJCpEP
zgwH0-`aRbCgMQ}{K9BH5lDCQQg@k(v_Yv+V%=!(Of6#B3@EGAIki3fsUrhLkgs&i6
zBh30unt#x*PI!)<ZxFtc@KuDHgy#vfJ}vVP`dm$TiSS{Pw@Ua3;cE#04&i4IX8nHG
z{DXcs5`HV;caXey626J>y9mFV@Oucee(yE^px^rm{}JIoA$fmF_|FL6Lio=K{{>;z
z?=Q_i==axzKTY^^B=7Ttzd-nlgug`i%Y<3Kub6+(@2iBrM)>Q5zd`t$gin8dx_<CL
z!Ve<+YlI(6_#uQjJr5=ShY>!5@WTl|g7BjW_YgkYa8Tp1gda!v9Kz=kUQaj(cE<+u
z5BYTg;R^|GC3)KjZznuXcn9H~gjv5`<{$LiO?ZOvUc!@v>xM%#GlXXe&(ZT&5pEKm
zC)^_ZEW;uGXA^!7;pY;59^vN`4uakB0`m{{dlBK6626h-y_xV^2)~u^+X%m%FzfdY
z^AGyHi|~61zn|pYO8A3>KScP$gg-)<_4}y#2mNj%{I`Vvp5*-l;oAv+n($``f0i)o
z_c`+q`hA}87YKim@K*?bop9v^>3DM;;bRCNOZYg##}nrC+>iWEAbcX>lL((o_!Pn%
z->Kw(8sYmBet_X%?|#BVgh%Q5F~W~0{2PRyK=>lUoSuu#Kj^oG@OHvGN!~8Py9r-H
z_(_B(2(x~dlK&pUdkHTPzMAkN;SS*?!pnqL3<rB1A^&R#{|@12(DTnEd_Cb;5x&82
zFw<)ZzmD+h3BQ5x8wm%&?s${=hxC4s!heYHhY5d#@J9)Mj4;Rlaq|!Hf0FR02;WZf
zK27*Dgg;C8bA&%nnDzUD`3L>JO!#Yrze)I?2>-L;5Y4|3{#U|x6aF{C|4ujvcE^91
zf6)IwDg1vC?zuK?-_Im`7U8oAbNr7r{}BJVgwG?qk>qV6d?Ddp!hMAM3A26!<{$JM
zCOk&?2_)|#!WR>MBH?|6pG=tb+fV)n2p=STi11SgUq<+H!cQgqG{V1WIN0mA313Zk
ziJo63yh8Xe;Z?#%2(!JeG5?_7?-IU_@GA(vn(%84hiG0$`1OR}K=_S>-$XbFcE|6V
zf6)JrDEuE2{s7@WA^fL=|BNule~bBt`2UjdUlaZ`$@>i9&l3I|;m;HP0%6wgi{>Bn
z`wHQ&6TXY^F9`pO;SkNg626=8zY+d-!v8@y2zJLW%|Gb>UljiI7pCp+0|`Hf@UIbm
zFkz1WA?6?AKZEci2|tE#AK^j6A(|n=!-Pi&j}jgu90a@L@#Y`&zlg$LO!$d}uOM6_
zJV}`2pECat{|w;<;U?iW;b$8T(L9Ina|u6>@bd}3fN&7(j%&?7=>K90{}RG4CHykN
zFDHB*VUGXz%s<5cO2V%p{5q2NdctoY{6@lWBK-S=S-)G&Kj`;C!XG01VZt9H{0YK;
zNBAEIe}?eq4F@&9K=_M<zeM=Ugug;K2zJL;$^UDFzfSlYhJ(Ex_@Z<@_Q8Z7M)(ng
zA5D0(;h^Rg!dnS%BfOpPIN>1J9XrfFq-Qtb3Br3x-W7yvgeM745uPT@`qj-p=r>3B
zD#9(o&m#O>!Y?5FBEl~<9MpOl;g=J>k?@-dzlCrR?2fmZe@O2;DEvDK-$eLbgx^j0
zJ%l;__nLo*|NVqNMEIj5?_-2NPWU#$pCJ56!mQulnt#ym?+Jg4@OKISfbfqDhiHCG
z_$P#aO894le@-|E&KxgJ+lyljXTFu=2p>=QeuPgTd?Mi>*c~U4|H*_;A$%&~(+mgu
z_Ygjt@HvDx7!GQkNB$ehe-q&g3GXBPWWzzfgM=?5{4~N(Cwv9r8sSO8b;BWjGvwbO
z+$7wl=dUCGR}g+R;nxy=1L5B{9Q3=9{NGCcZzKPAlK)NQ{~q#xFZsWp@MkFeXUYEy
z<o`wT{|fnkmHfX!{@*13Zxj9=;X4WcnDEaCuX{;azmFq)0^yShpGLTs@Braq!y!LM
z$p7(#FCx5;@BzY4A^cRrzeTu8_}PS?XE^BleDZ%G;g=A8IpOOGzl!h;gkMkiO@#lD
z@COM08R5Sm{8xl;CH!H+A0zy6!nYCr1mRB-{#(L-NBC2O|DNza5Wa)(w+Mfm@OKD*
zm+<!pf1mIV2;WKghlGDb_{W5QLineIe@1xSOR4@6KHhLBzxN~m69}J3_$0z76F!CT
zsfI&*r;&dT;WG)JMfhyOk0ty#!sie^m+*SR8wj6A_<X__5Z*|56X6RD2YYNLyoJJV
zCA^LBcEaO^gZv$YcM{%3csJoo2tUbi7@zDRyqEBGgny6l^@LwxIOzXM!mlFyYQnD}
ze1qYj?`sLaf$$sY`8SdOn+d;#!oQX9+X%m%@H+^<lkiQ3gZ}R#{BFYUA^bkW!Jh9Y
zd@JD(68;e34;v2pe2n}*PWU#$pCJ56!hdTx$p1USpCbJCg#Ur?9fZF{_}hfPL-_lI
ze@OU8gnvr-XM}%Fxbm{Jy<SK77{bRAK92D5gzslK<o^lee<I;i2%k#$G{W~M`~brt
zz8>;FoA6@^KaTJ@gwG|sp6~|3=Mg@i@CAf78V>qzBL6+FNb_qi;j0NR5MCtQA-qI*
zneYnX!-OXYUrKnD@HK>w5Z+Ab-$HmR*=rl&?S#h(?;yOB@Gio;3133^NrWc|UrKln
z;k|^fBm8@WuP6Kp!ml(O+Ot;?el_9O5Do>gi{l0g|60PYBm8>8Zy@|e!fzt{J5)Yc
zt!I$`?-KqWgnysp-$?k)gx^B=t%To3`0a$>LHM17ZzB9I!tW;h9>VV>{0D^JNBI4O
zZzcRe!XG01VZt9F{87RmBm8l~w-NpX;ZG9&Tf%=w_)~=cp71{qzJu_$2!EUKcL;x%
z@b?IRpYRU|-%0p~gnvZ%$Ao`E_@{(_M)>E1D=$y`mvw}XA$%<1;|L#5_<n>>AbcX>
zlL((o_!PpY5<ZRa{RuyS@acpfNccg7e~s{i2|tAJLkT~O@EL?3PWTaoA4&L8gda`#
zF@%4ea4+FL!u^B?2oDk-B0NlZgzzZgF~W~0{2PRyK=>lU7ZZLW;VTH&2u~88B0NpF
zPI!j!Ea5rA4Z>FvzKU>@@I2ub;Wpu;gr7zD*@T}%__>6iNBH@KUqJX;!Y?HJBEl~w
z{1U=1CHykNFDHB*;ol>CJ>gdnekI{o5q>q{*ATve@M{Ubj_~UVzk%=@3BQT(?-RbA
z@TUoXhVW+ze~$3y34ej`7YTof@RtdHh45Die~s|h34ep|HwoWC_*;a(P53*6zf1Ug
zguhSt2ZZk={6oS&BK%{*KOy{6!apPYbHbJDsQ)K?4B=x5A4m9j!uKP50^t)0pG5d%
z!lw{EmGEhV?@#yvgnI~|N%$<nXA^!b;l~j^hw!<C*Aw1A_&mbr6TX1(M#4N_`tQb@
zOrQVmXxHLfv%s1K)-14Qfi(-PSzyfqYZh3uz?uctEU;#QH4Cg+V9f$+7Fe^ung!M@
zux5cZ3#?gS%>ru{ShK*I1^$0vfeUGWbTi>CgtroA6Frm8mp+T|a|l0=@CyjPknmB$
z&nEm_!p|psE#ViX_)9;0hVK6#{gKh0x7qhwN1g6-I_LDL(;J-L?DRILcR0P<DVyu`
zx10R+PB%Nf-06bTYn|Tc^cJVLJH69s<sByP45z(LcR9Vn>8jJ~oZjU0R;OQbdY97^
z-)VAtoQ^u(=XB2LQKvUJz1it)PVaDfx6{*a^7K31?DTS{3r??fdZW`@oZjyAPN$W3
zdHS99I^E^;3a6`1uXB2n(_5W>$?08APkgth-|48+eNN|`9(8(y)0>^%=JXDycRM}(
zJ)VB2o1I?nbiwJhPH%L2i__bk-s!aRUQfSME^lji%>ru{ShK*I1=cL^f5HMiyM9N<
zPrIBhIK9E?txoTBdirh)KkD=fr`I~Y+3A;@RxYvd>z(d%y6W^sr?)x1%jp?UvgbBC
zopXAf(_5V0;q=4_3*YPXa;Ha~-sJRlr*}K;xzwK9<#fU64Nh-$dZ*LV_gMH*r&l<=
z*6GbozvQ&C*TS!Ny3gsV(;J=M=Crce#<A<2?sK~8^hT$*Ilas28C&eR%}(c>Ugz`{
zr*}9#ajS*zb$YqeqfT#fdb`uRo%U?A=XN<=aC(E&Tb<tN^z`i(e$?p|POo)(v(qm*
zt&Cgv^-lLWU3Ge+)7zZh<@Agl_S|Ntb55^wdW+LLoSwMT!uLA8-04xLH#xoC>D^9y
zcG+{goGv)M!Rf6|?{s?lZVNx^^a`ifI=$KHmz-8EvGD7i?sK~8^hT$*Ilas28Ben3
zHanejdY#i-oZjK|#0d-E>-2J`+{W~SvG1H$Y8$Z;?#JTq{1bnquV-G-g@3dQzxQ~%
zD~sja*d_ej?^(Q?Jl-Gt*>^PF8@li-=az>b^>|rMPnYnU&$T(`g%s}<UHA(whr@67
zc$t5+OZc0ef4;}N%b&ls3xA*cbNI`<@UQ5?udGk=ch19|-i6=Wg}>m>W%--Q+1w@k
z6|YY7Yt^5>t_%OD%gORF3xCv~WBzqr!r$>N%imtN^R@o`iQg{g-|lia{2g8RcXi?4
zc|)4s>pb2wUR%!Z-B8ZIfzq4F+1w@ktyFGr^ylyB!awSAvT~b+zsa9t{&ii#-|GAe
z+|Ivz^!K#>-rj|OR~P=x9xuzOoM-ka@Dbm=`u8w<{$7Pep!=P0Ql)ZYA@r%I6<GIy
zasSGBm0x>M1(MIjQ&M#*6)DIMe#k@d`!M{Sfj{|og8V${(Ur<09{KQ-A9oJGDLrSM
zd3NP7zb+oxKe4dtc-pBKNW<{o@$UhpksNdEamNp?FZHTaF6`?c=&fw94kZfnK$uzJ
zP-S>zbS&}+&eMbI{|U!4D_SHgx4zN(!za!EP#GtG)XM5f>y9~2;@Rx}@BGwH)PKW2
zeb>URJ683*^$qs?U5Bl2{K}&FpR(?_<Mny>|1*F7yMJl^r>;9*^Y!Qr_WT#F|EbEI
z`V)(P%ewn1-t7KgbN_dI<HyQ>YUKp;e~mrA>#+5auXq3FR8Ca?ia-DF{`_~Yx95i|
zC#nCfue0Zu_L}||u9}>B<z$oZ{<WIfXL#=W%D<{|iame5J^z4Vd;Zv8nw?%)IaU3S
zy8q8#VDVmh@eh=LZRIqj6_@`PA2I)5zTD`AmHV6g*P8q%zufft@EeT&qVfQf@BWv&
z|Fzef{jOMdy83T+|M5|?`<p*u{ui%%pvCY0)Bb$T>0sqS7QfqX!TIw}2P(g2@l*c2
zVbbE+S$XiWn*Wr4k37NBzpL^P_2>Ng`b#Z+yDJY>|64tO*Ij6GdwyVczO?eNV?_Q@
z_y2P*zi<1j<<FBVXQ=;XE+1bt`%YILZt=VSvp!~WpZ-ZJhm(~@=<~O}+U)<Dw;TUy
zUOuKOkF@yRfAe)F_kTRy=x<jZW%0ZJa~^2r;`4uH>8n;At^O7F|6ar7U*+*%U3rYf
z|0;|B86I!j{TD00Zt=VSKQ`_8j{7$&Jr=+FZ~Yt7>v!D0RXNk*cmG+J-}(o$-+bjP
zi~p4t|H&`3^8ZYKzFj%n;&=a#db%(BV=G@5u6wM-@BTZze%{~XnW;R^;&=b&Isc+Q
zv(s$l9E<-I7XQ&dG5xpwm-&xX&b9d6|Hc0NT@Nuk+<)DAi{Jg9?Ee4se)GRz-3E)_
z{r}qAr@<?%9Q0Mrv-rEz?-y6j*YeY?e!r-4f%<Ru=Z|>3`OKi%_ag7|D(?TO^DN%C
zf7;6VHth_hgs1;ra*_F;v+hExzo~cS2`5|n&Rf@8>i@wL&HvnWeWm{Yw$bFTU)Nvi
z|A#NJ=QpeyDE0s4nO46~TQ^9W8GPQ?EdO?_8!Gkx{EWrFYu#|E|M#|<{dTV#DfNH4
z=kq1&Moay#aQ`Q*EA3<p&uo5^mA`L$|8a^xkN(rjPvMC*#+n80g9W^N{lLrDwO+o^
ze`@(U>f^6pxc`d#qyMz>=l=J9z16ED?vMV{p7-(BvF_jR{#pN7asTU`|8l2U|9R`{
zt^A+p{11NK>L>b7lkfh|cK>HO&HB&H?thu{4?4~I&x-rcWPGPt|9RBMM>jbCRZc_y
zc^^!@7Ie)5YZh3uz?uctEb#wz3*0sNh>ENT-RiVw%5avh>zsdu(~N&_X>UE1mpyk~
z7k=h{>mO89uMDrzH4Cg+V9f$+7Fe@@Sm35Zk4*Z9g_`v<o1Ip?zgmCQLp9uH>{CcT
zcf0%F=yd%x=6`zj+^;b2&D1|~@Eeb{c#e9weOdV9jL+fM@R|kIEU;#QH4Cg+;Qyor
zj$#`(-ub@*+b%KYxNoHJ?0>8KpYHwV9ULCp!Xp3Z;62B~a@X*h1^!=YflKb6)R!xK
zJhwTckGFE(^Q*>rzrz0xA3yfEyjvarDw~Wx!^W{koo3;$_!a9cm4lwHZ#=-#_kE{7
zbJ~Bh@qfeV#ZI?4-R^X!(@UIY3S8>=GN(^-`nyh#I(?4Q=R3`wf1%^+oxa}b+nm17
z=^s12#p%;dGQIz&<G*(Lo6i3&r&&B7a{rGz{b#5D;`DB(|L*iZoMzAe((!*eJ?0dP
z|9Gblb^0);XE=Sh(?>Xcq|;39qZ~iR>6uQqJH5o|gws7v_c`6~^q|vB?o%B9meb#M
zdWF+Tr_Xize5cv-*E)WQ)9akR(&>-f4zG56gVTR?{_7lP^4{S1ElzK8`aY*OJN+Z4
zA8`7oPH%CV$@{9~Z#%uy>Cc`1qtjnF{b#3lJN<X3nY>>*KIT-**OQz+!0AJrKGNx<
zonGj)&*^~EA*Y%A5yuxfeWKGXPPaK7ce=}I_WUJ|C!Fqa`bMX3bNU{qf8_KQr+?}6
zZ=8P6>4%+u#Az1a#~gps>EAnj{Ap&N+Z}(#=@Xp)ImeltFF1a-`@hiXbxwP|efqJ7
z`<c^!a{3FW|I6t^{JDoYeYn#szDGJf%jtTj=R4i#wAX3B(?O@1oMFe?oQ^x)<@6G#
z6HfOy&7R-q_$f|*%juHS-*x%|r!RK;GN;!&eU;N2oM!T0@Ayql-|X~lPT%G9eNO+_
z=?9$tsnc7W{<+h?behHUSB^jI^pj3M?evRIzwY!D&(8-seVEfnJ3ZU!2B#M~9d>$=
z(<eIJ;&hwSai=?-W_s>+{NfX=e7?!)2b}(e)4y^0VW+n_{adG*yia;NHtlk+bh_Yl
z(dm-Y6{o9CuW_2mdxqn;IDNa*o1DJO>ARi2$LV{W{(;j>-uoQ?q0<jI{R^l6)9GJ3
zz18W5oPNY<Chud8|IX<hPQUN;hfaU&^rudL?(`p>X7YaF_@ABrtJ8mT`b($(>GZ7s
zo4qrEZ=&k{{<vWgg@}p;5u*rJWJy^A0!B8gfJ7E80ybSqp-bojVG)8NR7D9OQbZ)K
zR7HpjQUx_CXcf^Ys1>)0TS3&Is6|2Ed(QdYW_jS@@qP4J{!j8zzWv>E?lR}zxpQZd
znZbJGe6TH;1hxa)gB?K&*csIIcZKc++Q30z3U~!L1iTWogSx!o&?CXC!Bp^Ca4dKo
zm<twx)4`eGY;X=Z54;7`_0NZ104@TTfJ?z;;9cNy@NQ6-w*vYea3$yi?*;Dz?*|_M
z9|9}Dhrvg|$H2AV<KUCvI&eMs47dS&4txRJ4BnF<`}bqu6X1HV5_|^ShJ1RvpGEox
za3i=Ke&2#WfIox3fcwE;!2{qyP}g%vYm>D1SnxRTbg&ti2u{GdwIy^b@O<z>uoLKo
ze_v=D*bfZGtb+$4{R(gxI1;=XJb-+;&=bIkpx(|r=t8gvECt=*E#R%-eDF5#c2JkQ
z0D2L)1S|)afe(Qd;3ME;pe}DM^g3_@_#*f+xEZwJcyKA$FXs5rANn%z3UDZRB{&SU
zgXv%fsN0tbodZq)CxUrkK3D)2g1Q_RbTL>8P66HEF06N_LQeyKj#(E^NBRQrPH+Y2
z1MdSL04u;pK;6F8&`*NTfX{;g@I~+?a5MM{sLOj5`gO1d{2crO{1W^M{2HtUb$Pp>
zcZ1)6d%$nO??4mgk5j>>;A!CL;2EH<ry2B_U?SKYYyqAP?#BA+H_*Uw^Ej|I{1Tws
zLhJf2gtmZIa3GihUI7jPuLSL&E^j#WNbp+F0cL^YK_{3CP5|@40<aKtfyH16SPD)C
zr+{uyw{I%+3~&~>2)qNl6D$Ys0`CTOc`KnG0@r}+z~{ghz!$-n!Ofs9?^Won;5P6B
z@I&xp@DuP;um;rSeFnV~{2crO{2JU19t018$6&rc4m<%&0ChblL7xmZ22Eg7@C;Dr
zI}^G&*aAEYya-GNdw@N`i@`qNCE%r?uBShA3OE=X23`dY2S<P-!K*=C-Zjvv;ApTE
zoD90bso->Q1~?165xfbU3*HRQ2Ok1ggHM9%!1drW;0Ew{P`5t-{R;RhSOvZYZUNr_
zb^fi;Z-d*xYH$bm5%>vM1AYeT^1gun2K)i615d$u*QsDr@HFsr@C>jSsLMYSx&?R^
z*a5VFUBK?3&fgQdA2=8s1*U>yz;WPpU>c~)b3kW;Ibbe00h|ctfiuC`pe}C?^gQqu
z@HWs3E(Y%emw|VKE5Qozac~{D9()Ge06qu40P1!Hpf`g-@O|(T@JsM(a2L1-{2ts3
z>hgbtPQd!4A$Stl2s{})1=RT)Lz}?Uz_wr#*bZzDb_6Y;F0V7R73>RUf#bmm;6yMF
z%m)j=LQt3Qf-VMc0_TA@gKr=%w?gauw?Quimw?N_4dC<O3t#|z5qt@J8Pw%(f_@dO
z0$&3Ufydyw-SME#-vIh#uql`bwgS6?-9anZ3+xT{1$Fs0=*z&%!NK5Aa2RL@b^hVd
zso-^B7MKG%!3kg<SODtsrbAy3&H`tHW#Fga5^y<qKlli^8e9WD4n7I419koDp`Qhx
z0|VeM;6d<stTPk9#^5F3rQiT?5O_H_7}WI-g&qNp2GhVIuoQHI)4`dbE^jvUeDF?i
zCHN4y8uWwfz-PgY;Pc>T;OF31psu$TdM~&S`~}<(9sqv_b^Z)o7ifTWdSmc(uo;*L
zwg6j#tw3F#8M-ZaB{%}S2D}y=3+_TYu7h@fd-Zh-RFH}ETyP?o4;F%xz+zChuM~O;
zI2D`@UJot;mw@Hqa`0|&CFle11%u$*;CAqRa0mDi_$l}q_&K;6+ynjq)`5q>)`-)E
zU?;E}crkb>*dM$c91LCsjsQo4W59GUA9R6J!5QF9U>WEI7lTPy=l1}6gO`A-;I|rl
z0;~j|2RDJ$;74E$xD)&m+zqN{gYfTBP6roao>>KM1lz*i9M@sY;JIL1usxUzb_KhG
zR<IY?8@v=81P%u6;3#l3I2KF;9bh_`0cL_(U^bWojt8CKRB#$N9lR39^Xs8!f*x=-
zcmsGNI0w85oD0qa%fP$9yTKKpANAe?y%KyD=|1Rt!A(fN4|)~&F!(6A2K0kZfKP!>
zgO%X3;70IyFaW*;ZUSEcufp}1;ot~xBsdDZ8oUNf1xJI|f@8q3U>fKEuLoy>v%o<Z
z#~$d};0@p$@Fs9BcndfmybW9oE&<EIyTH4_mEgVL{opF_VenD#3GiufEBF=|1m6bV
z1>XbT2dlvkz#ZU+;78!c;3wesU<lj`{s8_2)`9!M1K>gMckmFX9`3{Q%rW4x;Bnyb
z;0a&@@I>$=un~9)*cfaAev9M!xzOi<C*b&SK6D%K0<ay}9_$1rgI&Sy;8v9P7I-Y?
z(__Hnz~jLazy@Ff*bsaT<!k{@Li)*IBd{Op9{>&lF9!#ML&0I-Rp1D46nG6d8XN<T
z1Jl5C@CNWka1MAAI2W7;mVq~edi|k!3({`|=YzL_w}T5nFL(;#q04CkZ30gP7s7ur
zxCC4ZE(4c?D?lH3ANU}+3VZ}y4Xy<r2cH6;2A>B5;7i~p@D;EMd>woPd=m_U?||FE
z_rPj!2lx^AE%+VyJs1M_f<J&ig8RUqz@Nciz&db0_$&AucmVtzR8I`!dEi*^c(4K3
z5NrgV0yY6p1y2K;fr&aD$DI!`-?xB12W$zyv%z*qZv}l07(#wC^ts^gNIws{HP{66
z&iT-7z&<EH3A!EF9_$EOz|LS-usdi4dx5>dzMu{42Mz!SfoY%vOb0W-OfU<~1_xmN
z9uJ)hP6YG80?-9c0*k@h!3E$#a4~oXxCFctTnd(h%fP$9yTKLUJ>W{v2i^xh2(AJj
z1|J0<1J{C2fKP!>gO%X3;70HT@I~-t@B{Ee@MG{(@MP>CJE6Y>zXo@Md%*9&5cnhb
z6Zi|bAN&>k4Lk_`4juvxtRIg7j|Gndj|Wcx8-OQ*31CC;B(NoTHrNV02Q-7{g6Dy)
z!Slg3U|aA4FbTX6YzJNhb_A2bu3!(a7uW~1f&IZj;N{>D&<>6OuLkvT>Hn9b|D<yM
zf9sFui$@?Hfp`Ss5r{`19)WlS;t_~PARd8u1mY3+?~1@!oJZz^1z=&!`DIgFFFg%B
z13VLK4xR;$$9198p__q;U<<INF!<uxeBICdve5mK(DHIiPIqk*T?KnJ(mk8Rp14`;
z0nqu1=%meJH@zylCRbPq9fUpMHA(-YomVzR?(fy@((Tdh(Dmzjbh~wXbvt$YbUXZL
zkNXvAf9mVfKJ%-hjV+>&R*uCd&ucTSl6EG6HZT>e>ml~w148$M!bH#oKL@mDYy<9>
zz!;$cR-v34(0;W%52y~bzaj1Rj*)cVHNuosVF)ZAE!uXiuol$);~FF7c+$jPv0vhn
z<PaSM-RYw1eigg#H(|;FVF)ZgC|Z|q+a=mMR`S<?W#dFwp&t@Ph&J%tBi)a&{ckH2
zzY3GkcB-&!f^0`E>|U3oTPF!?z_KFImSUlP&XVOi(FV4^8rpS?Ja@@ceggNC?RVLp
z+Mv{DIaZi-JnDztYKXR9D&+=Yw;^8*?A6Hc>nDERLsEX(F_PbNoG_)o*xe_HHa8Gf
z=16)Kv@27zGh65wFZ4TwiCMxB%1c0cYObUQU^nS<hf2CJL3p(GCniX{j<y{Yy1b*r
z(>_t^tvyOy>)`j#Zr?u}Up?;4cpjIg3D4=$)PD7>z`Sy^u=dF_dAw=6p7->;rqh!O
z;6GPrgHAAsPK7q+iFQGkfj%%1c3rM!CF~a1gV430Q7Gjmf)+3Z{wdH7&<%RQ3NQdx
zgAU{mK_|GR9y92M-3wZgZU-xn?t~6Nd!VbK%c1>X6&QlO2D%P3O_Fvbfi^G|bb$$F
z;#UUk11rHGSPL3Oh$Co5ehYL8=m6cI6@Fgm3eb-90JIaj8rlOLf=(z#e8F<qt<ZMR
z33{|2=m)E`M*bS;I?z;t_<?$y#Tk!4JOc3u#3K-oz+V{w>$2v&u5y5u&a%GuLsx^w
zUE-Gn+Cewy15=T|3OWQ<PLuUp;&Lg+13w$I6AU7~61ooBwOR7jAU)x3(H1ZjOzDF2
z6X*&s2-bn-6_P&%bb+R>l0N`ltJCihe=Ar9`oU_@f&9iw@lOKnpd0kflz8}{t3Yd=
z<g5HTQThcsp;oj7^dmhLx*FQpFZmtwrThxmlaOu)-Cz)QA9NKM0_$K;{8h?L*(L38
zfdSA4d-*To=Y%%x7Jn~vC0GMmVNdu?@>xI!(#t@<*4R!D{ETm;{0itGSO?auk~o+T
zp#7i=tg8@vIdlN51+9;W-E>g$S3^6X-H(dB4BD^#z*?LyC;cw@?VuYBJ|_8n&{bdv
z46G5mbuH=vork16!!PMx=t{5#OnhAI35JYo3z!NfJRx=uw5@}j*H^Wc>pS#nO#0ni
z!WqKAJfWVGwEl0S1Lvb2&<6&<8qhcf&-nvwpab-PKClKfA1nDBpbxA8&3MkA0}Oek
zKWz(zUa$tVERyt8&;wS0LC}Wt>QsGxjq_j^bQ$OaE5RiA1)*y}8`6zDIZvrP73XEp
z7BB@2+$!V4(?@8UFSLU`FbEpAiQNpkKp$8Gnr=rqexV=bdyyUl%?scMdO!#A1)xKq
z*$aQr1NuPI7_l1*g%;2S`oJJ)ED}F6XaVh@3-p2k(6Siq03DzQ49yg~4?3XJM@xDL
z+PDMtgEr6shQ^BB3+?GEIsjb*8cQVI1e!q$=tsVqnE61@3x5@LeSbFp?DhsQ4;a|r
zZJ-AXfClz|8|VS+us@p@%YL5%y1;TU0M>%0JH+1#{@L60N6QOhJ_vzc?6)rL|9-Fr
z^ucb!e(wSOU<fp0f46}y&<BP<i{Af1FBm{QL1+W}y9IQB2KIkHbPZ_2{%!+3pdYLO
zP1wIZe%YUF&<>pr`av`HV;ktXLGrnvy_!h(LkGbc(1!ifg#Fn9+CdlS0ezq!41yuh
zJWkr-MY%rEhWWq_hW^F#fgX>#-am`F-2W6hus@f9ez02a=SyV2PXg_r8}xzyDccio
z$NxqI{Qu(lK(7mQy?++}H+t(|zm+vu7Z^DHTR<-u07IY&$A1Ut1p}a=kNcnl^niZQ
zgyX&qbb&t557vMt9QSRY3-p2kFa(-${I`Q%FaU<Ye|^ONy*29nGjyY@CyY5l6KDo4
zpdIuSik}18rPDz#7+NcSK4?D}0E3|STJfua4uQr^Xb)%xEuamwgAULI8h**|f%bwv
z&<_T{AXo#2Kp)y?%td=ZGiU*ApdEC8F3=15K)+5$JOj`{um%i)2Ig-QXa+5y9dv*$
z&;xowALs`IU=0`ojWTR6XhuBE&=$}J+Cc~C0zIG?^nrdb00zMtFa#PmqaC0bw176y
z4!UqY;m{iNfL_oC)}Vj=&;c;0?O+HrZb5rMGiU?tpaXP)9?%O~5KkYp9}Iv&um%i)
z2IgrKXa+5y4YY#}&;xowALs|m3*`4KDf#$aO=H}*s;4P4(zQMsH{kbykAdsJlVZx<
zg!H48cQpG=xNm+gI1elXZw7AxZw2Rrw}ZEV3&11Q>xF&cQT&dSKb{_s!2d!7it#(+
z60j7U9P|6*S(q1|#QwAnT>mHUUoO-;2`mDiK|LG5Ec|}?MCf*4d$1#z40Zv#fmW~=
z*c<E%+Q5F`0B{hP0uBb}VV<l*yM6<gBK;V|@1Z|wKK-L(b1LFE4V(_n0B3<WfH#3<
z;H{vp_jc%oG3na=M|lUzS^6iHcNfZ80s6rE!H2+y!PVevU=HrLcY^wOn+IJ87J*a1
zY2fwXY;X=Z58R4+{%D-y{_zOJBM^^3JOc3u#3S(E8-d%f4*2igg1_JLH~*yd%_79<
z9hA2nd=IP!cYq&*HQ-M03-Bwj7W@YM4h(@mfcwBUcrNz^;Dz8tU<a@hm<)CSyMaBx
zp5Vn`AMg_JQm{Wb5WEb$92^V|1&4uGfg`|C;5FcAa11yOOas%wOt1tj1t)`3KsPuQ
zoCZz@XMlfy)cp5YugCVx1ZROBa5i`Ycq6zRTmh~G?*;D%9|Tu{4}*__kAZ8!$H6DT
zb>MpN8Sr&*3-|`O6?_wX3k-s9gYSUbz<0s-!1uvw@B?rM_%Zk?_!;;)_$Bx?xEtI9
zeg}rYAHaR!FW`RgH}D{Mj(%<+c&>h4AlMo_A8Z3o!93sw+amn}FbTX6YzJNhwg)?a
z9l@)>5#T8B8gMi?1{?>bf$3l-m<^5xbHRyVK3E9O1zq4Ia4}c}7K8VKC15GI7Mu)D
z0iOrm;8buLI0KvsdcYgNIp93-X7E<<Ht=@P3*G_V36_I*fp>#uJQs2^^s8V;q`wBe
z1?-9Rt<Z0Q7bE>`=xtyhq`wROK6n|@tD!#tcYq&(AA_HOHQ;ApHp<xv{W<sr_$Bxi
z_%&Dy{tVWEzk&zAL*Ox}=Q!{ca0_@M*br<4o&uV{rr_ydGcXZs0k#BNf#-s)!8YIp
zU^}oq*a=JqyMWz5E9d~z!3;1H%mQ=3@t_mT1t)+L!8|Y@EC35Z7g!8V2B(5Ez**pp
z;9T$)@HTKEcn7!?{Iiazcg2*qB1ZdS^!+h95Tjp;(VJrQt1<eu82v_!eltb~WAr;Q
zdV7q1FGg3#=szot@pAreMc_tU|Gxn=;X41DxX#}cIvw^o;Qy^C#J46Mfp`Ss5r{`1
z9)WlS;t_~PARd8u1mY2hM<5=7cm(1Rh({nEfp`Ss5r{`19)WlS;t_~PARd8u1mY2h
zM<5=7cm(1Rh({nEfp`Ss5r{`19)WlS;t_~PARd8u1pb#Jumiup{|Nj9tcm|F|9^Q{
z#JBx_JOVra;Qs%`AN2qFAN1dK1iw8;NIz1yeSZZ1AC8cIq;h^bf`8o+(vMWmuSf7d
zc!cyLl@m{oN8qoFz@a0I$4oqT?XRl)*!cZhe^qGX<;Eirk3c*E@d(5t5RX7S0`UmM
zBM^^3JOc3u#3K-oKs*BR2*e}sXGI|Njl3_XEF`RaF#7#D6}6(B4@9R|-5afwI-bq%
z{jU91(rsYEM$xIKh~0m(P`AJ0i<X?P@}%f=ZTG(|`O6<exu=Pr?<>it{WOz)6u;`d
zLY?k>J=(wKJ?O?#UU}2#`n{)%u4@vVuFI=vefV^3*L0m2?N>E0TGxFU-7cN)kFxH3
zDL3$%lovWRx}Mnb>@oHFOn={B=TC_#w-)`O?MI^>?L3;_Uu{oKm+kcr76wzJx8K(*
zTL0DU`FEG^=_lK3xm1|cUugYa_9OQI(Ltow^%Q-icH3j@!KKmuj&7n&E27h5%PV_7
zdjAN$6RpddNq)<j!qm@U$Gl?3{$@JD{1P}jy8eo{B!42(t!G5rP3J`G*!F5|K1=*6
zWBg-v1?HbB`0M<d-oDZGIX;v2xjq(}YOuXJ!yjbe6UkqRax~o^N_tA$==yc>2|NFO
zy$M^zZvIH<Y$fF+?GRnz{rmZAV&a}~Zge}eb~KW7SIcO-Zs*bHZXx*`=IH!dI~zu)
zAE~@V#L@G?-`}ny<&USwBk;c%fs~l}+@E#${l~XEdOfFO<$d??{@QNU>paZsI=yzg
z<V$_?@8{S4amFJMk3cvAspmx>7eiPlB*dKGg>(F|ziRtP`Tm&W{vRvFFlv*eoa(Ei
z+ne(BU%TH|c9r^4E{?AEkGB7){{P^4=uyjwJH#Upk3c*E@d(5t5RbsWJp$#uW!(_^
ztJe>I(Uw{-IsCe(%qHocYlKNL*Ioaj=ERGQM<5=7cm)2>M<8+e;pg2yeZ#GXuczV&
z>3@3t@dD!!_&*qdy5L`XUFx3>8NRR7zaP-wx9aaT_4kwdd&K(h>Gbz&_+D0j@2S7X
z)ZaJi@ALlA@7@0C?fHuf(BB^)>HAI{w?EnpeZBRM=KKHkuX<I+rE8PS`_(T;YtJUp
zfz4vC$&L0)M7r}8Nw0iWsPk#N&aeG6P4L&{>ioJLI)AL)ca3~+<Q*flUoETy?Qcjs
zTw{d6Qn8!1$oBa0J$Dtp#}4BAYfH7*?bu)4`y`)^Z$ft|uY4Q)@H?Vv{7%95wxnzS
zqcOFIlo#t~!}aa*3l49O_5XM4P`<<|VT8~+R%qLG_;{3!i;in>rD(TLSiK_J{ztdZ
zhVKFW_`Sj(&Hq>V>v0%bD%+Qc-*p|azES^J92{>PKF&uh_rJw(y1~CAbmgBZbW1z}
zQ-!AKLh}@)$IM4bn<XxKo{7~#*b`op{Y=kORWFOy^O#Q8`D5p&*!k?w%CGB-rLJFZ
zS1h%^PWO~Zd=e2i=QPokh+h@rr}tw$PRk}p9BO(r<M>yBjv12QceAA19~Qb?e{jC4
zIhD(e9ge0|Ql71+^m`Jt*P6)w<*2U`+6H?Kv>*0_p5k8xZGo<VPKB=1<)OaBo>IRD
zcGDxGE1-iqA6SEY=3Y`?3Yc2bT*fVQIT!$ILDR*O&k8y~+uUO~zXuEqXuvuEZOjw9
z4Kx;u-2)xa>1FT(JzxMdZiXEUfW|FI2R&c_G;W0*^nd}-m=8PX0RvzK;!}q0^@G)*
z(Ocq@1lmD2Sk_y{hYz|641tM#B)<)Gf?lorO8!dd8Ze=+<g<XLvs!T6Q=vVe%O?3N
zpo3r?Xud?sNdaA8Iq2&r`2*0kpvflrte^ud1O1?9faI@+HZGNXNuV8cgFdhd3=EX~
zA?U<@lHUe8LDL}d^FmjGcDwjjfr(d%uIMcBvOzn+z=^Uylur^r_ZsNU*iX7hzH%@C
z)`H%#(hh4^@pC^Z`K$@Tig9AESch_-76z_EzB`4sXC&Q`Cfb4g<r^g3?vQl*bE2z2
zXS$>(yddc{&_+Yio(!=YFNv;$c0=3Ym-w>SO<Ce^1<Sx{FezK?KG2JNwj4?Kf(heA
zr-Bt=9hl-2doAe56<rP5Cy1^B6DNvxf^|J4-o9(4--3B!4?)|;NV=my(i1Nhe|sUy
z1wET&yDMFiZW$~2Qo-OPNjDb>1E957v|qDA)&&8u26Ue)>BhrCQ#p<!ZG{e``%e?Q
z2ikLn%u_xvsMAqijV|vI$!7+=u$O~A&;h%#So~{-2>q~oV6V7a+Eon(kX{MDAat-=
z;+A@m#KH6^+5uX?nh8=~CAQav^eU7WLOYCRvb|=|55H>o1)xKqu^RP(>afl8p#{3G
zk?5n*55GT)WoXCISOLGIu@d9rXbiybsMPU13WKm8jpeBKXpCJ?{Z%^nfQ+}ls{DAl
z{}~bR+=F!|Xsi@%13h41`LR4N{JUH2bII|iz8%@3gIO`@^$szA43P5@>(*%hn#^cz
z*baaG5?FzCIA~~nH{!SqcFl6cQ|slT4bXE3>|o$7(SdS_w+Gq=dXR2tKV2?p0}U{M
z`aQZGpaBM!N_`&C(B(r1?$ma)2im5&6ypLqumt{~4K%<2wlj9S4P6fGF}?PuOPe0=
ze|pLPWPxaxXPLy+hVd1^__FDAXhRd}0gNk~9%uh#bN<`1+Z$s2g5zldw0*Xuhmh_-
zdTMK|Z;)P>fcy=FiJ%4k<>yPf6YCvYq39G9D3ki%4($SC>#IXOR`^>{zHUbn>Zt;4
zU^VJXfp(xBL6m2Qz2YQkhYjVr;BSS0B6KPkfPXn?MR~E??LzsMlcoH>dR#cszQ4Mj
zKU_ZIngCi6k0j_S#L<Cq<pG^wD*D0vpSpd2I3Ry4Lm9@A1LG_S@$)p5ab-cAg7B*X
zJzyE)TMecn?lrKx!3va9i+a3B4_zzuIIw>vqJA^_#Q{Gn`p1uQ0!S|heW>4nU!_h5
z%TS&b`75*?+6#Ls(yP%<6WUXS?Q$dC44n!cyWMt_YlGdcx`pN=7qk-$p}x8k#9j++
zhuw_&%TS&j?Q}uw-Zr5<TK}ieiT3)@KPL2#7rF-9nF6}8T`AZeJLp0=|0&z`FK<V0
ztbc7yc^v8M^2YG!=g9h|%J%~LdkIb5UPlSOH^BAniYcP)Zeiska{Z%rhG_5g!cc;I
z4`H-Qh(7N)SDuq=^T|5XxEJe9Xb-e;zogsl69%9?4?sTz`-4K`VNj>%i1w_4UxhFL
zKhGmb?*l#xt`-`P2?L;K4eV=S_rnf)9*6x2*q;=7ZiS!LPr+{;{GNs#^sI-y682|c
z2R+Y<_H2OPM)*AkKhQut133Q+JuLl{i2kyHPB3wj^qcN?cN6Kqx)X%83t?Y~=N#Yh
z7eDV<H{@sx9xEQ^R`s4VZ^l3I2*e{0k3c*E@d(5t5RX7S0`Um^Z$zM=up}*el3|>U
z&CPbZI_IdrbFy;tDJdsEw}6;eI6m2>n3-8voTu1{64j?+$Bg1)#q_+~@dbrBM&@Kr
zHac56TP&T27|9}y<Ss~u?hIPAU9-FVL03%aliayWSEAPEjT$+qgY~>{xnxwI&X(jZ
zmaapH-7Q^Iy*;fxl2!ex6+MzIQM6imvhHc=A?ct_?+$;>9#XEwYU$4Y-Rm`%liV#i
zIjVg4*SANv>u)LfyGs7#qmj2uZy%G}Binlz-A%Sb*|i^t`eM_q6gO2)4~d7S^dqGs
zAL5W~g+?5c>ly2Z`s?i|zbB0kRW8!&>(S|5q@Sey$ru;3ol?H;kItQ`y!vrwN#>zq
zardBMY!GwQU)pXNMXBNO)CB{vJC8EM&|2rSxGA@k6PZu9Cu~>MC{JClE>GLF{+n^%
zxf>O$#<`5}E*R*#y~$!Wk}aJ%Ns(Kc+=H{#Z<lPfVRY@;Mf|#Vv67?Y3bVdk$zH!-
zV)Mi0X*=5YH|^4Pw5y9n8uT~q!j7M;+Cz2g_9=2Gx}aZmySibX(A(L?A_4iEa&`Sj
zC|7T{E?39B3*r{LJ@xa@zz#jT4H#r35A4ug!O;EO#fp9!*de*wfB{DL<gQ$#A{&%{
zmo5V$#v$6L>(%_5_UP@<L_E58>&Br;?viZjp)%`yu|&9zXxIK~zv+tku?Ovs#hFs!
zMSX-F!1NJFzet!>EbIjPxgw1=U|*zX50ivE<ag1*LVa}oni$T8j)x|Oy-`075r?i_
zq$j&{O=eep9MR=zX7bT0qCOo*6sY$<O`VVSPrcs~_5QE@bi1_H)a};e2GtooWwZZg
zyY>E2Kc3;I%hUUVZkLWjeY}vM$FH6*w1546gA9MO|HQPb3kHtPujd)v&iZscA7MVJ
zPmh_mbbGbEr*5xRA|*%hi2gx)bR0ExJajplvE}RiQrrJg>iu9Q>d(XY&dScqF3C2G
z{2^kPF+<oF102%m&_U9(CJTG_7WTn@P>?-^6WU9%0e1stqj#UaY|-u2<404cYwGRR
z@zLWkxo1y49&28Q`eMhg*7~@l%aNmq8t*a3k@|6j@^m{eT<YgTovwMLaZmF;ZG-lU
z?O(k;nd%!l`ea=#?AT72jr86KVE*NjuFLDtR~*~G-V@tXP!jE@{p+`1%=Pn-w(D`F
z+f|<q|D$Q?UBlo-vC5NAi)HmG&YhO6mdC~=y+pgvzAQE7=u;rW#z>zgy0Az{YjgUH
zhd+j=QG{`u&Z~2^{>~D=g7Lz>Xh=Th#bT6~iFscg+W6D3V@bAKmEEvoR(eUgVH6_X
zF0?xb%mR}xlzi<FZ#^zFyP{kjXB|h)Om!lWqXq#nSq*xjI&WZ|XJi%@OrRo&DqKve
zI@49i5h8NBqE63IoyO^EursNAS5YAq#8eqFi?Y+%pQyD;$Sjug8zPsh=%jo^@*~2J
z^OGOdN2L0QRA2F=BI+V0=Tn;Ul}HZ}xqL+~pGba0_;LB<N97Z#e4;8pBQxKnidQUj
zO(jmtE~2i=Ey&7tE9PhCXF63M6UmcEj*2e&L$NqpHLwU7ic2`zP%I#OaY<2Ty0R0g
z93quNq;iPGt^#6KsiYUsA4=zCt1+lpKm{;WMy8ZoKn_Z~GKwY=xdKHhj<otuooBjK
z%Sv(#S7`~4&>Z|hq@kWuoXG*qnNpNX^E8>A=|x1|6N-_)7=DwXCu<EuZgF~EL2150
zbUD+B#hJOeiWzz71rrrB3)ChlX6260Em0g_l<smW<`quKE>h%ziKPXZWG{B5XJ#vw
zx?IX$QYht>6pDXIp`@p06!Q2;&*0{&^X0t4Otrsd@*jqg?at1m{%5NAGSzkx=}^N&
z`eaU5jib2aNO_96`RQ)bR1A~;$SG7oCl+P%Ofx>agm-vyrncnd7H~X;IncEIvOh4@
zIAy8=bBhajKr=aAX_cOb4Wr#lZJCjl?dAri4FuCNXjmJ{n`bn|V)`S$I4wORS211o
z!ztP6+}_;DS=nlHjnaam!aP;J3Nojcq!+18P~$jzd~Tr{KO;sC=ug|1pIuy>K0e!+
zT#}xVr?#|IZ5E}c*^AQ0=cgNKX|CMNv@}Kg<^7qi+-&H9#36RIm#O}sOzKlTTD~D2
zBC=kOLV~vcqZ}1ej>Vnq>d?81I$u=m-o+S1!BHR9$z4H<P#vrX;XodhuUltIr`=!t
zNO$iV)~a0gSI5LmS1Gv}Zfo~6+R)ZW$WPC7<`!hDxTNQ2DMMP?M4qaNDlAG59h%B<
z>OXKKGcUKG)UDE0gjG$&Q;SQo)iFj=Rk=tItLnGHVscad1BVP!`HxY5NB*Cs_5u3n
z<3;`P73X!yNT^TO=fRS#eqDjXe!bS^#gaQ&<)yx+Pkp%}kE+%B&OBzEVbK5d;hk17
z{YsWbF%4Sv;f+=-!1fhkU}b?W9GCg{q{g?JpYsdVjy)L@T|W$nJnUF{oN<3jKXW~U
za3YYFHev*gV=PCFbY1UIb~DnkzQAdnf#sE9$&g<{XJxAyK<ziV1(|uJYEhD1kd;fv
ztK1xAVM;mKdBr@B<mRXYk1~`BsQ)=VJCCy&L~_V3D&nP#OLjwJN_tU2u3DtzW@Ymd
zEjQoA6JvUDaW+km#hIBrp%oUWNmYF=>(9Hl8b`Usw7-`Wm2!Gcx-=xcKo&lVd>u0*
zR~;}_k|NieS(wjD8FihLH$bne3X9m?aN`dwYt%SRFQ%?ZOH(V5;u1wQQ>rypT3SIV
z%|mHvvXJ2Go$1Afc&q*|E#Z|@Mq#1yQuQl0ny@m{C0^>-n90X|I%rY4qBX5VjUTn;
zq`5Y={>{!wFU>1al=G1+tjDqnOL<<)rh}LIs6|_Lk%~u7ULhT}X`ZKKHP7d&u2bv9
zLTOKKf%J?zxUxO3P*#Zfr7}_K^A*}UmpTxuqub<kb%1rL>T=asEy^w_rFx2;a{MY*
zmwB^Q`FcHDT#{Zwe(E4zst$)n@swQN&=O}Z_hX5(h!<`pMYL*B{WsN>ovZQ_X+5mw
z3F=m(R2^?<={h;LsH9Y_)Fu~_mtjnyK&d!QapuyruHv7eB3exG%FI@a=={R0(!6Z5
zA>+ub;zHxeOmXD;vkNi{X^qW6QTf#<R|lx6d_1A!Mb^}U^nA4e8B=9pl`*wQ#yd4i
zeR2y5ODS@NDp2Wa6GW;0E~ZE*mK0KU)gD?UskqbeRdt1m8z0fsqKkDwVF3@I{ujv}
zD5ILknQARDOEWu9EyUIFDu<eoHko=w)svB%R-y(Xk2}=?8S3~)c0L#q3uJz$xGHH(
zPS4{V#hIP%GAqqgla|^Y$gKK{!>ihz$A75tlTQOFAL|jdzi`jxWvA2bZ{!r1i(T27
zG(KpVrp8AR*Hchvo?PfER{Je4&uARv<f|S{SKkv*Mk0-Srb=L{J%mU*3Xv8DOm&Q7
zs!2LsjR$3Bayd$KIYcUlNaZMUIf`5kk;)-bIchrKauhpLc|^)jr2L9pz9N@TL^_vC
zc4{Ay$|b6DGc$NO$E5tE$&ac0nB<q8OT{qRPiab^boM8bKau<kdDs%kok-1Ma(<;b
zzar-+QhuW3m--~ET#hm`m6=J03@V?N4n$fqWEIg-T+Kg<R1c8~$}Zw&5Y;GWok=OA
zVb7#?kfwGpRYi)NQIXq2TDfsLwTCpdhe+)Zt>~8VsYs`Xq?0YGB&I4!k-Cw|_0#uN
zR6mjGCsO@xm(=f;Gg;DHzarPK$n{gYiU--b9h}bX$fvb|O3zQ0`ty@jg*jN~5~%_r
zwS%>)fT=2AstSl%(6qjy@6|Y;BIhGb`H194B)_~up3#{q1C#1kYgzgzQZYm-hBa*;
zrPKBiY5Rz@eUh%u4>+C4>qMp9+#W@44{2%-k=jF~_Neax#ZUG(*6b(y8*BC}l=(zW
z%;I0jmk!jVkR|0Ra=D7+U!)>T?I)@XOx2L_>G`~+OqI^m>1joVbE=Dv=uBm2DtoTF
zj*y|sW2$tfN}oW3Nqr{JU}CC7A{KxXsFPVEoo5YY=dC76dY(GnruH&b7N#=gp~1o&
z=sY7Yk0wlIXR352rx&WV6Me7B_2O~}f6q!y#N`nA-W8fgvP$RiPox$Tsb#EHe=t>i
znJT`D6b>f*GvLoBWMrrQV2VGvktR1H?>9u{##*^ax*AuK?nb(zY_5>nO`6(W#G4DM
zIIzy6<2Tnwq(6vMF>AFwOjR*cRV-(pd>+a9<m^+lawj{tlSt!Uw3|uuoYJ&AGHE+V
zlOHZG5qZ90s)i_XJ&GI;(o_$T${|uYoG#_4bT`u7Y8{Y2sZ_1uggIayU58PlLZ!>$
zlt~q^RuwQ+1x!@|!Y5QMLip&on@1hYROw7rkWgKBA-fvO!W=M9t>4BMs5P>p40J_0
z6p&UVy9|6qKK>9X5JYMxYt>GsYM&y<N0H-0r1%giKAf)NBk69WE6QavCYLXl%|uiA
zN>f2hRggOTs@m21QS~p#?NgfDN2G?ZR{5DKKU4B^JC){k5~-a;YA2_wc1pS%>5ACD
zg*ni9bUso*2S%o95mVJL74ywh%r{dlT&*z`^UYK`n5fTG%rjFl&rHQUlZoRDkv5b_
zIasUhVycESRl_rB;ly_CM$sxVoUS4xRM%I@PZgA@uA?Y-rj%dAJ3OURV3=IK(p<jk
zIrgU>q<o58K9R~NQu&HpzKS6GQzXe>k^PC}r$~O%Y$mruY3fi)rw(PpkK3ivslzCp
z+a=SnT0imOgQ?s_({@lg`4ee7<aAC*<&&oJ)kLPUF}WQ|b2&7@Q8_Zv8EUD^A9aex
zA2k*52i<B+l4ZEj7U^wqo%}j5XSf&&!5KQeNYck=7i1Ty6AE>mrUQ*fKIu`WVtg-9
z#H%zuPgG~zS#<u&8Cywqb>5)PNY!-!{d*j>*?i(g=LK{=-V5J9qzxK%C1t^|;dL#?
zTdiYhyJ<Z}^J2cbHb)<tN2xt(p5t{{TWp}}ZPgQ)4^*6UhKPS}d|`7gw$Fw1q7h=B
zisP+}iyT9)9?<!W*gNPiQbfl8jYl9Jfp`Ss5r{`19)WlS;t_~PARd7~Ap%!Fb@v%m
zOm(r`x!bU|;zZK=NwXhcKZ{Q-^pj-|^ci|B+4U1>Z9h-kOIkmPHero>KWY6$+Ud^R
z*`)Q8W^ZXe`~uQd_ey=;TE5TUOuFt9ea<`6_K`jDe$mMl`@SR{fF5_v*JqJ-J|Om=
zA0Nr~$_GU|FX_I4?2d;-H<<Ti0_lWRq8GnVz(3_ntq^^|iZ#!Z-FR4ZlV<mE`zoM^
zpZxwpGTR>!d*khQzD2qY`lPSt^O=h8QL+De>(=AQUfo{qfPVYqKD<3CtHs`E<SoyV
zJp{e1^?Tgj^2fyf`r5z=WKZfS`Ipyuza<@nE}PPi&#1g>#Xs%91Ug+dYW$+tH+u69
z(k8^?;P}={N!!+l{ou-Lxj)^Vr2J89&*J#Fu8=1zU%MiG9Ql_$F8*s59J`aW*&_a*
zTQ@ByT?IX2=8VrtyOPD;`-3O>ibi5*(O*}7G>_~7=rwbCm6LXM5&Idt-{bzYJR$WR
z-+96_WcT9<?Z?$M8bG=l_72ya!QY5_o)rJrF5L1O*^{0Uy|6Z~CFvmaw;AJFlXkBY
z`&pxAHz#d=T6Ds=&7Dct;Eh;y8}~FOT?PAz_u6kKomeUUzXosM?GHfj-LZ5i*&Q3i
zeq!qCS4k&q6z!RF`*)=M(7#_b^mWpy&xzgLYyB0Zjps$5bARp_k`>SsFIcdMv@am`
zhgYA<<2B_)(Fadyw}$K?=ohj+<?ShdN$gWTu4cRKWzlQz*n2Yh*FtaVweeKa-c4dp
zJlD?t*3F_PUHkl3WUqnV*SE*9q-&SRc=;`{(cPpiuZn;F;THr*S3{Q%7(~+WREho9
z-gmx0I_Wjh@1Fer52Woch<^F{73Y(#gC2t)+6LiY)pK|b+1;;;|At|gaD1z_h~8+m
zbR@g$4bjfW<}@U2StjjWefDx555eW4-E&jhkUep$_<y*s>}S#e=wI%?IzZa_rr3RB
z2J`;qxKHvApLfF+vYXx#d+~Q4($5YJM^N;tZC5QO?H?@TJvo<u)@UTWEq1qQ!Y^!x
zexsoORisnj5&H+#-*SA7ZK7>g{m%Pm1@v|Ap2zX?j*#*{OW)m$^4qtI|8ws?a~)~l
zyQ00lU%iQRirVc=idEJJY@|cbmR$)PPg}Lv+ca6%jqKhJL?4{f?`G09J4By)=oxOW
z<s;Fl53b!zcF)J6zj?Ik71F^^M7QkpH1GdaHKL7ybt}o9xKs3j&Fju3?fhKy8=r2w
zk#xdWqTBD-_AY6oR`lbY`tKlFw@dV{(awXUQ@#=X^Bd*AkuKjOy1{i@zaU-nz35e+
z+`?bTTlR|nrp22r$nN<;^!3XZ3?^Oqh3Km`EaNZW%s+{Kz4>cgzUybv4Xsb#O8(_J
z(jT4PPuoU1@fWebb4uSPqyx}R7v4FVw6jj^kAC>m*`!VTMNhu>`|+eJp)cIDsy%7{
zZ(?tCU)R$}rydY}>Gbhukv0yBKKsdSev%c?OZzS4?XCM=?5X~ytH^G}8$o7_KAq<e
z-yyM&y?@{JWG_EP#(Qx=Mi<hx<7NArd>-QQ=J-|ojU|u$O7;{({8w&0gXg>2V?{g8
zT*v#b^?1=EyMD#T{~G9tX+LrQm7Re6#sNNFS|&<;8&=$ZCY5h#AoiD^T+G{B4SiFm
z9ef4WbE4SCUit&iC!RdXKd{MjJbwlg#6GF<dA$F*8;ZVt=Q6I(e3IzlyDu3<^_hw#
z|IORp=lwBtvgma|FOLUTBk`Yi#ldytpLnw9)E`?eC7m)&{L?1c#*ucOBKFgUx8U($
zYAkyFn0xqmUkUwVlOG;t|4+rfui*+W=>(JL{s(;xNc*7+ooU~YPCZrZJEy-$ySWj<
z8@0DI{B<npil$;e&?>~oL;Gp)f8F;Z*?p&rJ~8yXjdaQxqCb1C8Sj7P%|u^x?Jaz~
zs6A7(WA%<*<nK)sow8=pSEQ}YMIV>6_IA>ivqYC}UwS<0gj*y&%lDu8HR)>D-`Yga
zR8#w7OY!e@>LuLY?pC6^ee)8Jhs1M5FU%bF0Qm=?&2R5{inQ}Qv2WRKnMS&@wdjE-
ze=wP}<9yNOQwMJ)ZF*M5^RC8Yxcv!j#6IiRk9j^yZ7X{7dE>q(f8zqtjx$<sAz1<a
zm2D4edy?4GR$SPS?7j;{PcKiHK{}<K=*Nrl_)2*Q+H?G79$)1biG9U}`8=Ogu8?>Q
z-k-zkv)cAzzs}T#k7wQvqPv~`vzf}bb`*Wu5YIiN%Q}gEWp)Z5?<^M4bBBF>0okje
zTYca0F4CT4v0w0P<<+F^zlwfz`>qnw?k=JqnL4&5X>(W6eIIbzNmoJlyZlt1e;oHn
z`_mt4&EqYxyZ9e^b`0kaKu=kE*W;Am*+cB1^FDl^bizt(|C$ruB3)?}yXh3?ucRG4
zMc+DZtcP?$FVP!6SnwL@RG;MU^^S>;Uw+s>Ir{~k|57g&|KE>m!t=AyTl9@f-P<X@
zy^rXT4YDdp*FjG%N#XI}>nrxj&$db?d&(uE`QWB>3rbX<w#Gp9d)Q-)swMKorMAW(
z))jg3MCP`}6|Af4^;N9BcWVD@SSKtM&G$!l={#iMc~ZXI$13-@QHtE}Mw+KJrRn}y
z`uwB*;;r+yHHx`@->(wSo*jGgXJAjheUk2@>|*VrZkWV}?yF4hN_R@ir>!xK^9K(~
z{<g+U)`oh7IZa$`jaj0tTF++fPnP{NZ4mtclD?Ue5B+Xa{o<4FiJ+82$IYuHI*U;L
zT|0S80|}xpnlPQmZ}p|3Ta69y`BW8-@3YEsdHmMAi2l3bhRdit(^aTHP428n%XChp
z^nQs0`S@IYxwgxl7TTVchC42h@a!q$c2hp{(6B$<i4o~fcVI+my3+y)&9~0(OZi<_
zM&zeEI$&4z707S)Bw=skc4g!r7*_8eX*Rr_uj1pQe}vdK`pVuR|MK^>|Kz9w^SWNl
z`->Ip!L+o=xD`X{Tf6P|F_gdTL&^Wq_@V7cS7W`HmWDe&(B5G?e(O#4B&-+J?;!an
z5HK4(z1w;Iwp=a!rRs|+;Gsin_;?V&dNOJ5y$&kRg!P;9k1BBQitl)S^J9IfeqUOe
zn^%%skT&S@Ap`mMrqDw!zmm25;xjE%{W7wM?9gf$W~q9jbXq}-PL9!?V>JE#KBBxd
zYgiYn-!o^^_qCa6g#~F@*^_fKl~ljqD=JhWQa?h)?~F+oWfzy`lNI)?Z1uCu!l_}c
ze$C2OYOnfbS$c`p60Pa0U;gCnZNT$o2<z!^eALeXCK<+4BVXa;v+Y|wK6L!lH^#~y
z_E%cn@iDB^i@biQ{TqM!rQ9THk77v<4=UAylN;>g`QD24I_=-Csr2g=^|KIV&z;qJ
zJ~gx~B=yg4`-6jY(vPAW`vP~9uE6<1t1p`H@l(GM?){2FK0XKV2Crw%9Nmcg^&95$
z8$LISbOPQ$mNxR79;8#>l=)!OjHmXHHr^6_Z=<u^B=sBQ64nm)lTLX@?3=$_#OGJ~
z&2tC#ZsYyI`>xoVUfz5I`CH!;J-yA^lStP<H{bQn$)ugHi~V4i5{^#=>Ob%5#=IWa
zZ>sF(XeIrJ`V(?Lev|T-y)XF(zBP*H1O3LlVO!cBLw5ZpJ>Tb@pCYZ_06DC5&jHf<
zje8%oc#e;E`c08nKJ&&7vIjnq^7}4)hwC@hh~EBC6?L1T-#~fY-t)gCt=~*}!OBtR
zlh$wcD_FPxO49mGmS?oia*#H@kn-NVT0L4)eJY^SN3MK=w0;BTR9oW=(!Q_6KjXlI
z^GK&)J-lyOF0a@18z8@1UO1ENNjt=Uxa<4}Nt;fR`DVcr3wV842|YXWlhtHTI9co;
zr~mvJX+Lz&DK~O|8+bG4!Tj$>lHHCs4nDi=C$`r?-+W~vuQyUomGUY_oX+#1>qOC?
z?%%kX@`qrz=1=&Xba_*;KWe-8Bhs~}iJtZQJCBg|o-Vpmuf*}B^_wq~uPf#Lt~o>O
zW7n&NkNT7~6TM;N*563$HzU3>^VfZ(^&3D-yR671t=|mV|CiO%N$WR=ZhvptV$$vw
zQr^Z6xBNode3s}HU(M$6V;(5_$FEoLakL8d6NbNeKlvw~Eq3p|EBJgg0NrTlYB`^3
zCH9Xl8T}mjo6Zs4ZP2l2k#^t>r=#xN&ik8w^XWOGO+Cq8(OUeSwmU0G+s_w0tn-E@
zq^r=rc4t)ccui?5_Mh55yPNF#O^*kz8nc3Q>Um=KHo2JlOTPiqW6R?62LtuZUi0!=
z@~`YF{z=~Krlj>7Dla~9@mSLO4U>&dT-BDefj2p~oN#;<N&RN$6LQ{LPukv7%4@mK
zI)ii_boIU$3rYKWiQSak{w30(i$&jejX!~OZ6DFQJ51X}+S^z3hfAJZO4^F+rN^&*
zd;w_-)=%dbCh`96=_mfnOK)yN_N4xz-<$FEg``a@MBkot7q5?luz&Vb^>t)-bQ8Nd
z?XzB_gG)slwS9ShNkMy?AKHG1?A2Hg?0N26-oKJk#s5Ly=Y0MagjTnwO_n<jDVJev
z9JqKPvFcj!@BQQL+}}0NiC#WucQM(^o)>-D%%?|?P8=)R*Eh{Z+H{@hr(SBw<F^ue
z$t?3CvKtv<Ket*fEY+t1y6Gc10n+wNvEN#2<9MfJi%uI=Fh$+6n>HMW^a&k4nM?iw
z)Ian1xzCbzjuZc5FAeg--jOD{)sn>JWcOu>p8LRYJl}<M`Dyv3c^R2JCzGGL4<&bU
zlvZ|Uj6Fi%@JOR{$`{N>d#SwQ82>1(>{&7P2;JzzNn@xyb74ez?il|F{rZCOJYQ8s
z`j^D`N9YS?2YJ4%#Pyugf{6u%Qwq%bz8Sh5)|{8C?);LES}&Gl<fW;baMIXCtv}rA
z#@XD-JZjZ?tYB(=Udr)w@ot{4{H4<V)#WRBJlbZ6?t4pTK0bsNi00qvrK!7h)ICo0
zIcK1)6Vba!?6aqgxrDTJvFOTPBlvhxc8BN|%UX9MySrSpx?ioJBzt^zQJUN_t8PA0
zzuc!gy5!@^bgJcIwpuY}syk-seyif#jNH835?&pu-xcPjtLJzX^F3XZqtI27o3EZ-
zfb8nNpJHbkC93<?D9u&qij?a2&FYS)h!l0-mA+M%i%{#q;wkB_;#@57ptHhSjX(8c
z?~>fE>_52CK;GUE&YvIcIf3UN(@%1I-tyF2cavlF9MO}rGu1-5qf<YBM((HW+?@+k
z|A@BqkkSof>oJFTf2w>-){Dt6&U}-6gUuzL3r0-f^<TM7%3smwnTBMyT`Ky^t{ZrN
zvi299ySYUQ*=wK|y_?7F_dF`)g}&O;itLtw;_p80V=rmXAkhzv>c;Drq{~DnRqx>S
zND%tuGu12F)F)}Rl(+oF6}<j5UoQUV6i>?~dlmFA8*(lr9fbd&c5Qe(x*wDL&m27G
z0<xRei2iVF>mH=5px?+U<>QTOt=LQ7NLfPm;3TPU&qdugkPi68ermHTPay4lT=e)m
zn@=ZgdO~!@?)`E+TPJ$h^jbOfcv|%5W#8^2|GM>})z>J)NQa&g-T8%Xe7&XoS<$`r
z$iTI25dHd;=9|dB7W&ia#}6iL#e5z*dl{eEIGz;$wfk<lg6xTdWqZzga_2_U0qFbF
zCwxNMIYjKo1{?G7)ihM}jP)(<A$uisuW6f8NqaAp@-J+XznQe-O7S1M@xVi*6NZT%
zJ2Tfo+7JEXapu=aTV9a-4|h49$4jbR{P!<f#q+&!mFRVs48NWHE1;L2el3qT`*5+V
zHxfKR_B!ZQ9o`#4+BZV%o;SuXBb_o*bU~YUc>NNBuG;xr9ods!l=kdAfA<-r%SVZS
ze!^Gpk+xke`u^iyxt6r|8qvoWy!{SoYpUq|-k)zFT?0M*u`aKWE*mZO-$U<}k+xhb
zdgr&Fa{oB0q<-`8)O*REq%Jd>6n$H&d3_&*zBjo36tcU=iT(EL9<C)_u|@LV_SqmO
zY4derKlk(}`FLLieZlAV^&z_}P3)8R-Ol5o?hVP`U{z59*#i!-KQn1J&mX1?(fxN`
z@i^IiTgAWbm9i4jDQ}8CZ}?AqysU)(IUiPX|2Z-x|K5{+yMg=@vP6HK^kqKj)NIik
zUw@0|BO^z2_E)Fy`ACJ<Zw=@5QTba^-=bX!mr;JZI!sc$RxUb~_vbq3Yu@{i``hOf
z`@k12;rS;eSM+^L@8t1VK0)+HPi#A#$}?;-Umh6IV-Cp*Xj^9SX>6V-{`)^p<@HQ0
z^n?9w;rZH{FZNd38}j*V4fOW~)jU4S3dFwh_pd@!Ufrcq--O|Ncs*k&6nmY2B=4U|
zn2&-d%uOPHcahk~J-ux*>8fJU^LEYT_PR<$f7<9Gp8pa{MW3?s_4CO;0Nr(U+w(|!
zof6M4OAcH~+B8M{FMV{^6w;N@*GzM@C+%>HJ>#7#2a)zq6}|u7eZP`UohJI}taJF-
zWX_Q7bJq2{iR`}X#eSXZBHsScOwkj6YQ_CoK1=kE-(3GR`Bx$T@$)CFCSB_hd&bzz
zZKP{%5dHQ?rM#Z7;CQ*W?~Ju%H_aFO%Z7h1>C~Ch9&_JECy_R0iJp6QsElL<^o6G!
z$K&1Z5qs}}cYZ|n)CE%BvpLQBlCFcj#q_3EllILP|FTCO;`rJZivJVl!MuOeL4Oxm
z`6c@=68kr&Z#h6ZWwGe{8oa~t3qiMaJohl!%kL0-%irg6|Js&_el4(y*Gr)rq<+hd
zoh|Htqv)z-uk!J#W~unUaOL)LvX_;MUOnT1$)r7Zi9Ti6Yaf$NS}uCPD~ou3a^Efb
z)`HC~$!=aDde+q|dHgsRNPROi&XWCqq3D}G4K^eHD){U5YG9@0-?4n_9b|X<MEBUX
zWISopy`oQBxP_0;3HOVBcvpiL$?k^^JbNYYzxE|k-^K?lSCQTFh>Y*V>z8~%+WwH_
zKl`K4Cy=gqP;}Z2<s6?n*qg1nx-r>(tHj=GTgh(HDHWnmdV3A82g)B7J)!cL-^p%!
zMD*m|eR#g8g>HP$qhvN*>!p49yO#0s*1B5!n|D6M^SAREv7g(=K9BrsV880ZL7Akh
z*NFd;iUl)Bd)A8XKl+VtNhkS5FFW4!An73VHQm#Cldi<~fA6+0=IaCQ$Ho8t)Xu#9
z<|jmF7d?I)`3Ig7UDN%;m86~PM6Z2qZwl$kr$x8=`6E7_JJyTtJ2-{+M>~GMz_;J0
z(bE+um%1O8@5@ia-CF8=L*3n@pOr-R@#=aot=Z{s`jF0yNMP-D*QXS#$8M+_hw{W*
z-M6Fe*H<fi)TZuVQ}+p(^-W01sa;9FSuNmQ>A3Moo(EB!Rx(AdKWnX@ZxFuTD|Z&%
zHele%R98Z!Y;UwZC*t}r`8$o%Z(egV`TI7CKd17YdXy^nEAb8QB8|lTOJ1TsZ7)Rn
zhrbW{sr8%O-?dTp`pesV{}YwxMtS4x<G!Omy@BZRw0%{xj(mKy;`^ZJ?a7np7lex!
z9WGupp3y_~;CT*dc<h34VZSNQQ+hSle_vdG)~TfZe;Yq_>s93Sb$;SOWIXAHJb6w+
zMEu$sMFxG}7@RBLFV5e&i09{;xw1d;ZG7rZFTK4H+ox{WQ~PC^dKi}agbaz#dC6Tm
zcIjy0Ih@k@HowE>rzafb9rgRhbEy#Z2_BM<)?YwdI$G$XzDDH7v>NWurt<ozY>%|(
zm>W|&QvQUeWIogR&6KD<latkBjp&{~b&ni<+8Sdy9#wclXj|ht)`oh;Fs+wv$ll8H
zy<@n<=lhqwOrU&;pGbY9mUiX!aKcW}cWt_6EZJ?i{%Ty-;YQMyGo?LM&6g#St~^I{
z(@W>_{!yDGI=yTz&nJn?MbBIF7#|PZ14OsEbw_{7pWqOEX=0PNNQb709<u$+r%79u
zh(5N{Kwi(*T?y@(emB{JH;A4*sw4Mj>aC*RD_(RA*~?~$KGktQpKnx_iN3h8^CPkw
z_lj1xMJCgYm3q7=oe?1;#-rRBes{Oa_fqz{84@o}<vVaGRej&H!NdE%d!E>Dm^XeE
zrB{`S4v$B=BV6tuKYV?3$D(2Mnbm;%$9b#dZ)>=vf6tfxU0C)mkKNii(!T}jTfK~_
zbW^svnNfY(8rO?|mG~E^2k)fksH-ZfZ2E+?_(y7r3F(qT_0*#*b~pMDeS+tYvUyUU
zx-VQkCnigkCzA&56Ho3g?)tv*`WYp>{q(h{zF%B_TZj9?vnSId`S=sz&o|)XzHqeO
zFdlfZ*8}9}xmnty?Xoq7ae3*BezI51kF`sW4;cB@Z)7)lVVC>L!^aoVe2+c((KmOw
zIl1a-G4e#oaQk?=iWo0St5R^^w;o;*cDa8T_hZ)&z;JnT=XHeUJ5D1s-*Fw*d?&TK
zFInAh9Wh_y{^|Pukoi$ZhmOZ|`*ZksBf7r3U=J6l%hNp;uAg$M<A?eeLxI92I-Ff}
z{nkd!|0*DzjT6^2;rXd<gN*mn<~7>L1wAYJ_1ijMPTCGT&DZ<@6?T&On;)bCeQS#s
za_P?s<QM<&_Fg}5=w`B~JSXL&JiU2*JfQM)2cFly%Ovuz-4*E{-k|FD+gwR@?{2Y2
z#7DI>YQ3PeI=<1r5yv;t5&gsVaC_k&)xOB%e{_ASKd9DlcZv>gj_7dnBgUsZAt+oP
zKM^R#uI_{9=LXd`M?XJEhf6<4s9r~ur;ewQ{m)MjlKbyzKq7}cXDFh4dEQWcd3f$n
zSmWDu>I3@dZ`<{Rp|#$@wborwuh9kd8eLGY5z~5&nAU4-LB#g*^9`c3YE+a~N3v)g
zIbLXasp3tK6^Q6h))D>5x;}a_<weC?o|qJ_PoA6<t@9$<BZrKzUFpoo@<~UwmvkQ8
zhp(Qm6z)IP5$$Dt*!C(*RD6_<YQK6ifa>3f_V5#zqO>{!M(e2dsV6O|_VM$VBHAa<
zVX7ZbY(ISa_<;>k<;S*9J%LH(SI=LnpMIgk`?uJ``#1dS8zed$Fzv4!7_OgwcM`e1
zq$9VNbRM4bRA0P)-jgm)Kldq0*B|_%;w^7jiKw5R{1g#yva9+iHKPAnhc`z*FDhK0
zdW@`E!eqNM>FIdt{84=uRFYl5Ygi?r*_xB5P8->-A1=dor+Ok>eRgFpN>@KEs!zzF
z?{}igBOO_u(oyA=s2?BIXIJHwy3~`Vvvm;>+s{wDlILB8`&)FlzeR`p8~*hjqWyJ1
zw7=F7_3`tiqIA^$qMm#eH6H0nSW)AHo{SaQUrMX~qSVO#A|2UZqz}74$eVT|+d~gp
ziPltp^!k8xRQbw&g!1XhT#@C`qnDyJm9J8x+OKp}`AQ$Ye14LbJjW}d|M<CH5&g$H
zqW@TjE0p}<3Pp!247XPv$ix5Us0V`K!#Xdl!~XKbFnL~BxP79-?GqhtAN=dbm-g4=
zN&9OZu1{SbQ3vP<O{Ydi`sJY$sHx@8%lf7)X*6G-@O&rw5$Cg9RPcMz@*J~pd$W)I
zj!sJr^WI2%xcyaMmTn+>Rg^uvJ(u4xmcKA_{ScWy9RDY$e$Lnb5`T=ehx?<^?Xy0k
z@&i%!aQ`eG+=x#-ockny#P-Lmx79d}+TWCp+TU{d1Sgzdp5PX#RrZMZPT(gjMc9+6
zosl}mpP#@KVdr*7YVtqSE$4nJ$MS9L_Q(_A+}i{1klp%CtUWKL|K-VXDO)p+C;uAw
zCtSV1Dd}pIf2p-SpN}P>|K&Mz;r>rJ-E|T9yF*f+*u(uVI^5swe(b^5Ps?74^bhxU
zPh8)w{3+5N?(c2w&f)Rm_&L%Z?(dh(t@!)HgkNBn9kRZ`cphGT1EK312wmTxdVlOt
z_5M*hynn-9pCCFs0aQ%f%<=T2eS=+-MpFEY>1eN9fT(Zpw)aQ!^_CQT--74%)we%2
zb-<;R-G=X1V6Wev4e3wwIP%VpE?-X|$ImpDQvR|VqwMtoA9(d9v0sGiE7HFDfUElG
zJf4Oof1uT#6Q%1{Oxj;>fY!RfTI&wbS~o~*-GK1^p{6rcWt3J=hNA01mipTHIe|*+
z+O^iTYprY7TGy_%uH7&m`|j>LX-g|c$@PY;b{}sc?O!B%%CbS9kS@PU;`i0fFFZ-Q
z@^aC23uX@>T`^SjNk4X#{SDW{zJ1-@k?getrM%w!bLI}Y1$>oMJ&*dzQD*fFU-{BV
z`DGTSrB6v$57NUY>f)kG<Liy|$Y@+|l;=l7D7(Hs`AW?7&Jc7b^HbZo=sTo67d>Qd
zOS%&GA3RWI<GPauiyhC?st+)9eSo3s16=Qq{fl)(|A`LwpXmDH<vDH<3kL0v;$RQ=
zUwFL8li#9s<a&gk{D$Yi)$g9r5$(YV8^=if!?_~c6LW$m_9L}NogXUyi0q>4qb21Z
ze*KfFPAww$2hvg7qqHiYQtNv|l}9?VeA40OMeJYXnH#D3Np=zO;~g?uN7b+Fs($rv
zRQ;qQ>nDBq`uWW)5#{q6TB3F2dPm;a5@DxDWJb1MY1JP6;7oKN-s7T&kJu029)81%
zyx%2ad{An{d?WUV@yhma2Z%i!0PU|E5Yc{q@Oy+-SL&kro37kNZlBUlem_j)^(lUz
zOl14WO9i}s{IZT{AM1$r!T&JrQx+9Z^>0-Fk`8AV`{CoskK&Z~*F?lqKY&yBkA4tm
zl#Xn#Jg`%@Ps$5d7!f~pWi2Xxbfqmaestwd-j5SGA5m&#{8&fCk99<Q;9uV!_-h^A
z9u+@jkBT4Z$oP>CZ%#ye<qbX0&P@A~LX)~!=Hqbr^5&ih&2RAOH2;iy$lupSjz?j;
zyr{=>M)Nbto`B=qt6yBwlC%lOvmvgx`TN0y!IFRI+-s!%A)@EsIJFh|8#vyb_Qokb
zlD=VL@7ZGjuWwWAqPr9i`=0C}X!ZRty}|%*A5zD^Z<G1=E4Ja{-|z8N{QY&{GSSV8
zoACGfiO?4;88L^-bEb&B<Md{akxs<#1$Ry^K1AAah1gYn>h891h2u7C=|OfozQ5Wy
zMm@+xeac3OfBV)!UT@W+J?8w^_=~-okz(Jz?YaQ@Tm7;9AukwO|NB}m+u={C>eVLd
z6*d#;H3t#>D{my?e<K{i{UvWIdgbQcPf>Z^jZ#0SM)>RYSv=A0tA>{M8-+9UskrJD
zDz9pe`0MZMTsMiv&20584!1|%jI`%G$9&3f!uNNS8ZJF@`_wl-YX8&q`EQZ(_04`%
z27THtKFHrc+HVv4D_eW=`o9i(bC=gPkzdVBu`iiFiGP3TnJrr1tw%oe+0!ufQ=<Du
zvFB8r$G=B2V|%qd5x=j{cIQ0t*WXVj&K2FQVFy0H4#a53&8R<SgC1&gjC?;bU+m3I
z7r#L5sesmZGg2CTmOWO&?XAG~pLKH%@mF=WGi5!0ev4mwlV9C^Qr?1@?_Nnd>1?s*
z7OUT4(2J$;$yL9G<`+^$YI-qMSj&s4!dhNX71puk$qTE(c6kw1So4s9RPS?|A}_KE
z+vSB;VJ$DP3hSs1P~UAvm9KP^e<R-^j&I5X5)a4K<vc%_&yjd6dhiE6zpQ;o?C&mV
z&es>bt3<cUwQ?-16{1faI(I)crS3Gz-+0e~&q>=6@9_ASH*O8Ob?wh&FKZ$Gk#=>t
z*O>j-ycDvh)``95^3Iz{`|g+e8ZE8l`6`6=N91?8)O$qK{Qz{mHBEi5=ge05^zSzU
z`2Jr1exnN8>*~nE!EoL!<$s&@Id88G+aE4JGjEzIFG@#UA5nJodx{8qNsNEVv}k{&
zqx|!ViZhI?Onzety#kOw?m?B~=nt1!;!)N1{>h}vAC&fHMY|g-3p-s;_8Rohmg|ND
zNtZn={^9oV8_f)TepNmoc0QIjokjZ7UJ};wrn4v=wSDyFv&ij}H=jlL^Bd6S>?mqa
z?eh+j`rDsU#N*R?nP_<r8b2bQ-0(g$dUJz(V6R_b-163#GP2Ylf4Dw*gBt%EE>7N~
z7A_9DzPO0(l{c;Nzft+s?;4`=lRjL2d2v*@J@O{0_n+E5k=k2bE&a>y=c0Sq`G-h`
z(euDs-XCo^|9x}s6?XD3OOf~tx$9=Wu4cjg?axe`vzP2aoPWMu_|{dV-9yBG&3V0!
zCG82sj)xNUUcJcvl{dzP+beI5OQW`hZ)Z0icr)`CDlc)El+Sj0a~5t8XHBm*gx)$Z
zpVtqewo-pvqmX~k;j&8pPFp5(|GQHp9?$Q2p)r+TUMsrO;F@aE9+&7zm1hqjZO89d
zPW}3NzV=)>U+jf}$L}J$|8~)B61HZL_TDLaj%C?>q^(Ouk38Y6(WEQ!`_0ck{QWi3
zsSk*Kdd}uj(yn_%UvXboK0bx;`^t$OKVWU^Biq;Kp|NAhzw9yb|JZj8Ute}TDf;xx
zY4gcmtCmqFMeEex%%rV2ULWf4QvzvIS1Ir12OF!sOw~U~^oRQwaQw?&k^IMY*mE!0
z&09oYP*-&+={h`rDr;O@ZjZS}>}U6!z`vhN{aUo~eZNBTPfeHdAFzMQ{o(yi>_b12
z`NcL~?9I=b!{ajn&p*2Frg!=JjUCT3da!BBbE!Prv9i6{<@eu6+IyVnW-Bh^-#=7O
zl=5aJ?)H*BDM9R;YkG7dU3HS^4PP(bNjh+{=-W)2UMB5mBDzmiAI@(y6)o@W;#b6x
zn~^*yjjvCI&JcU)m^%khdJUe3)6-wd>-8Yk2cClAd_CCITKr!+<mdkLw-Md$=^cDO
zL|u~T-s*7|`DzB}K(F~y*QkD;wR;_vZ)-319rj-9xxS8~TW7E5@fPeXddy|}dy(DM
zP4qeQ>fR%5vWk9heM6ov{VOG21AO}qlD(q0*qxuO;PVUrD(SE8@7w9HYFOHf|B0r}
z4M=-Bh#qlM6F!~>Zjt<LjXc>O%k}e2WdAgJN_hhxUd+F3t;Fw(p8okRuHR`FdvL)C
zG>i?;6{1aT@2nzSi|3b}(|N}{((X^iUibgl`ws9bitha@wg{pD5kgTe2pB~mRD*(s
z5(!EPO(KXlAqgZJl1mE29vj3Sd;Bb4q-YfVj3^ouCHANwu?K4q(b$6pBUt`(c4l^`
z?8!R!|Kwiz>3ts9oO$P+Q)YH{c6N8>`UkB0h2S<S-%+{x5x`S-Q2C4@{-Z&z-$~^M
zGA~I5x#BA-AG-RWo**aJQTwwyAFv4IsthKNU-}Nnjc-#K_Q7LY<UumuUoQafg@Ig@
z%Xhv5iPQspUq?1&v^IAInS5U-h-|;b0NKuqyfa2{vP&lU#E$H8W}Ow#pPoJ@FlPFM
z8TNc5k*6lZ){WNBIyuN+HOhSBvx@wjB0sOlFEF|Gqit4yShAJ+%gcXJ$^Wt<*DCTW
ziu|e~Z&KvViu}4FZ&Bno6!}d>eoK+xR^)dS`CUbRPm${td8;D7ugD)N@<)pNu_Aw>
z$PJ3TO_4uU<n4;QLy<pM<S!JtQIWq?<gXO@YeoKs$t#8qI1n19|3kU`e5>UDPLaP?
z<eiHAgChT^$UiCa&x*WDk$+L-W+pf8*hKFi+SC4xxBp+2{JRx-k0Sr3$iFM{ABxPx
zKe;~Z<R<^!+xOIG;qQuQ*`9q^2A;o-BJZon`zf;3iIX(Ww<=ALtwDnzAEfZxDsnqT
zK3I|4E3!2xBWYa!p$cwY1O&W;f?F3=0k>{K1-X-w-+F0Sz&k5=7e$Uy<gSWrO<IvO
zZhsF2KSGh|q@9!By66aeUJgI@R`^FLavw$RtH{<vC6dO=vo3;y9Lw?_dB-cG;Ll(W
zxqThOaLzwgk^3vMHK-tIJpTX%AE?N2iac16hbZz;MdtT!T;Fg7AEC(BO#?~e`QsIQ
zq#|2`C?Wre3T_3Bq|G1mwl!X8?jy%<w343;<*Xmqf3hMcFu9*^yfuDGwbzHEa<L+(
zu<t$idUH+odUJIBxfpvrIlBH_8RHLquU{3Ys_I4U<?GYcFnk|oN6m6FW+Z?2^G&eq
zNw|i}9B)u?n3aV59IsOF5{CC9D~ZDQDoHhTpJFbTDRR9nPqgxvXLVurP&vW&kIGrL
zOxM>7+VP=slO4a)tnv~_6hwO+e<&Vzt&BVVP&}F8{d|+G^0Ml<KUDT9a-A(tw(<w7
zcz!BZDzcBs^~XQ96RM<q6tAx-RNpqvr*cz+Ec<MED)n~=9q;xdpWj>G3n_ByP>v_l
z@}H&U^+?<2Nzh-K!1YtyXV(v1zp&blKb0HK;q^7$DlcjgU;mKGrFQ*L+0Ss^ew_9<
z!{XOmC)bBlUleapaHqZ~?z^7y`}t;C<@uVpKU9w1Da-yJxID|s-(<&!$|b{iyr>*K
zoXe+M`Kws``uV6_Vt<cB<z^eF>pe#2@_40K{CGQFR8CgpEL%Q<`qL22&JQMkrpQtB
zdzXH`IadC-AGv>2PWVZdlYi#&Tv~n{_m9eDid<p)PrtuPc#gM6Dwo>wJgdACw!URQ
zAC)T=IUz{n@%(bq@X4<#mD|I<=c?lVFu9t`uqQofMF%T#v?6!na;lX-br&z6%E4b`
zxuluOlL{7EL!IVyj;C4txDh-)RIX9v<l{L$-^yQS$Aii-&+~XuIhrh6P5a+;E59#>
z+sou0itOidhLyj>ZXZ;xu+O(l3op0v1=Jop{#0(Z<%JgRx9{hvoMg*c7G7nSN99^u
z&bIJ))}KAN=-X_l&)7vgeiU!8`@gfT{3*=;x8EB0HsmkPrTNzlulmj6v-P9M>kZ=P
zDCB#@xPf#<)1Wnp>U{qNEV!Q0@>A`2pJVB(ROAXf{&YSgY6!27MOOX>+dnEd+j1_&
z?fRy&e=x8ApoKTt`l#G!>sxH$<#v3jTw}}hd(Y@x-k;L-TFZXr@hr6XReNN)<~J@E
zS$G+nkLl;5vi}5b-x3Rte}Vf;<q}(7YT=ExJyedqozM5M@9|=Jdpy_5?~7C9w|W0W
z*NbiVgWGq$mA}fihsp^ja{Df@@VG79J}TGR_Ob8#YPdeO{%jqW+4{4MTz`pGUeljk
zKb3v^9LdhVODw#O=?{#PmZSC2^=h5>E2!+e&%|*4x**H%ynw*hyDg^8lb1Ino+Sie
zW5;nbCr+J0XMD(dqB-P~ySxQFKbP(Kp|rxn{OtKfY=tOTf0W5q4tqUaJAXP^`Kgde
zFyCa!uxys4fvg`!zChrsX#q|qx-xSM$a+z%yai;#RGUt4;bUA<0<2#JQ<=<MTjq>F
zfIQd8<ZshKe&OXhi%(XdA`YZeb1a<7v;?vqE(wSAXrI|jWv6_y?>(7ZbM%8RcKAqn
zRCe+&$;(MA%;x)alJ&xvOmn1XrR5JE!4~%-g@QbEh#*5WGs*g2OraG`@}?Ke?ZHou
zE|UY~4GHES!O8dhMRvU8=#%-ub92)cWs@}l7=sj@lb!B7e<o<A_`o+e&-qpZ^ydZ1
z2OwlcE%+OL<n^gSvc#4hKv>+1IAG%ig(Mj1WE0YY%zQAB$y~j!Fq5p#>?}v-qtOnK
z_bq4$Ai7|arHuSnM4FCRUp%@TC+($xtmj9nIL)eZDlc3}?6R~_xc~}Dn@=jqlIN2b
zOain{Ejc}h*h@>aWMX5XJ)cU-&&(~dZrVr|3nvc&d4*YWknVX7C0KHS<A5cT_P8XQ
zGAy|$mz)lQzKqO_qV#NHo}ci^7r@rzEbFnWDCd*yTZx>Jolhzt06q|#ZG9x<P-4Nk
zx#?N?dAVc(39AjW)r9S8Wiol!Bi&jAg3IJ7g4HPUGZz;T1uPoS-sJaNiF|H$W{!P+
z5ScCkLEZ6X!{XbE$RZP@8Gw(l8eRT^v~*sf(0=mL^LTUj6=ddEE4DGZwccEw9bNK0
zGquOoNBE>g^4hWdEzHVv*2^I4P*9gxfp9M8<&p>Wg1j_8+g=YZw+Nn#^0SwGuT5lF
zKRL6okhhoILg(=+#M_ej`OnXfST+H|<&)Wj0G9_0payWcKbsKY^4xhcK9EhIaD2c?
zG=a;<F@Lyx!38p(@6XHeQKRXM0+&x>6AoM+rO15#!NwJRy_Ec;75OAqfX!zUAY496
zDUX?N_cwe#is$dE<hLHuku;9;`6e#2aN9Vaf8w|wnhfazxXkw(=5jAZ-$^WB9KT4x
z`F_V7KTC<n1&Z8Hk^3t0AVv1m2aC47$EtX4=2Cd-$n_6!!NFvX_g8QxlJ!WSD|R}3
z(#??W9Il|b3xN;UuK?+6vkPe#L2+^kASW91kyIuNNJ?_Hoj}G5wD0mmY0!TW8J6t#
zTO#yt3QlAdC$V7JfuEPVge*8|^U2cfqzAN&B}J0)Oo7!`+W3;fLb5g{-$y$zVbavG
zV<rUxQv%kMBENpdrWF<Dk#m}?N1m4-$WO~%NIGY$Jdo#;t6r`klSgotB;|+fjBn)^
zWRl;K$a*_Pq`wT1P7wM`l162xKO_F-<P{Xb((l%fJopRx$@PPew=9{q4Xa2?o;%OZ
zqOOMtB|D=tQeUJZ#Uyg2lrj`38M^xDlY`oq>GPU9ibwtghLr^9cpIvU?7rZ)7N;QT
zi^gC4IN+7P()@QN<XX?8V^e8<|9!8l1-y>QH;lOCPmqh#DE`fm^fHi}cT@h#v&UQW
zOBH*l{L&}qTUXMg->AH)<5yN3nwb3B<WZJf{yW9V_$(~|>$?UDtwoa-lI2Uun?spw
zIOSWQ$YdN5C`co(mymC2(}*1lXUACAuB1iOzC|$l$o8{BeZH#$3-<$i%X2B7lb5^D
z4hBi*;~Ac2%aD=aR(^q0kVUp{=b1&m1(55XH9GRcX-QC_e3oKgub6{@KoPru(F99X
zMqUxW1oHYL-_52$4leU7*7_B~3)1OiWhy}=-+QnZ)GceE{TE3Kx&{I>Cr(bBF>}o1
zWa|=2Wqvh<{Nu;WOcZ6<he4C4jG0Um1A(z)W+YmhHL&tvp9V4ixT&+I%uJllk^+G&
z(jnOQI7A=FY|jE>GnL7v_BllvaLxq+GiHt-Czh8U%qc2>f0l;~pEdK802$^7cz%${
zFyEGwrp}m|INp-U7erEdmOOdll&O}9<oSK#^cnW;8!2y6@`z!g{uvYJBu+ggFma0Y
zOrPkd@}#L#CRpW<OByphFm@t);!omp28rj?>Eme#0s*2AGO{1#2WFm;%;P!RDu5>h
z0<%FA7l}PYoIEClrvw6!J)VmM2bqL|F{n&JVatT?WT)jh*{SSgr!oluHy{w0B^5wr
zrvNHD1yI>3z_LGi=5$^liAPFGV0Pk|(`Zac`%6roo;Z#)!toFyicg<8b0Q5G>5qfK
zKz?DNH7f-;$XS`ibRP{S=cFx~pJ5HiDbBAdJb!LM#v)n(#htr8QHHxhLALsQTZZrZ
zNfTr;IsN0Uo60~SF=bq0GE4x>p!UzO>JzFADxK7K()5`DE)p54*A|IvH6%NM)W5=K
z@<ckpz}knH-zt#7q&yPr@e@xuh3R1JO~_B}n>}&-%p|M*TJ~{~*=LK~K0ATi#}k-6
zTqOD7{2+~(7Ej9q?aTtZJ&)t{3+>CvK-&+<G=r5tp0gpIBs*z-tT-x@<|oOd`8hIe
zzq0HUV7FhE!EV2{O!UPwW32k5`kDE*en}?!9hvHvWul)Y*!m^eDZug<&L7(zD9=eC
z=gYWpfr*LZ0>g*HGg2}iHECvG`k3((dHVx-{6yXbQJi#tq}{?5fypG^s!Y2qb-q@W
zo$`48!NCE8o%O#do|rsiB5CJDA6*Z87=N5g^p77qNwN=Q(LPHS?Bg=kNBNLn)E_rw
z2yI@hd{w`*9yvMxBm<y78aHt=8KKgcF`PFaQl6FHR!IFBF*KejWb&|K?18uCKdEkB
z16<|>(s*VD`3$8h+xhMDpVTL5?^1a}`**D$z!_hUKPitiH>o`7{Gqtacj8OS6XQwp
zllymGAhn;!cKc;GE6_cDgL(C__A+AF$YH#{ApD_2Ql#=h7R$F}>M*lUXb+Y@GJnJ{
znQzG=zoq&e3l7;8Os@Y_X7<qfpwBwM166kNi~5}NhuS}MC~MBpo)gCj^=ZrG41qJi
zlA-=secQ5#L;bJ}7H-Kj1GzDqO1fBkP)GXnnbRkZn;950WyVCSznC#28Pe$R$9EKY
zSu#tSKTcajUYBQQBiK_MKO$hi&Tq>+11Wz-A`INvkF=MR8GP_)`9pA0xz@#s%h27k
z1j0|85IDuU_CgU<o*>8zbBo9gNN!QFrG(69+keyi<mQe-Ao^gq7ML-0*7R|SRJMkr
zWP~z4@sxn|=2<7}xq~l(tkri2`96MU$}5nuaSXlR+4tg2cYs_rmddLew_OWz>3Ax~
z-FNB5AlI|?e}9;B%ypKWNb%)yYv+Po^%#BL(fytwYd}tB>+{d(a`aswS5#AcO2=iV
zfZX&tm9NdaBM#*FW2rp+yld_Rxsk0GpS}Lgk3p`VL-k$I{W#(Uxu2X%<;>aRz5qEU
zmCADmto;h)tTZY=xaHchAUCn~%ExUy{8Et1awuMO-wkhpT%Skf{dOE;>GKy*`PFfi
z=L4R#gvvuZr(07ym27>8gFBA<2=MqzDIRz34C{HWuZ+sK5B=x^z?0Z|(o5c7wjAX8
z+bO<g`D^Ea9P?i)Ppd!lYmh71_xuHgpIY|%*!s#z1<S2@h_W>_|2I1iJsa}Zvh{{v
z>Av+hkfR@`crMu$uCOTIx(9~zH!E+j>NjOQ#b4~vV>6^TvGw`*yw+>V`-C4bx%ulK
ztoG8pgYtR){h<)@<1(Lr+lMCmocAy2`yPJfeT4@0zQ>mAtSq3E%%<(3pN~FYu4d1h
zo$o)$liI;SYds0_!90IGi^<OOGAozx{WO)G30o=)&(HY19(m-jko4-3z9HiG$AIU6
zKC(Qb{Wy-wuHXNXob#3P<}2mRx5}HZls8}ezF4xyn(ycP>5=lu%)>*O+19Iu)oeeF
zw(V*jf_O%qOY2Kn&cwIw*f|da9=nX<cemg949Im%=F5vf8vGdFcDU2~bF8VfB)0zs
z#hrLQ`pz&v@cgBsekVX|xe~hqnQT`elkE<f=jR64`PuVLJHP$Blg9@Zt`g%9@&cdr
zzfgac?3gdqKlzS|_;JODuTKYmO0J;(466L}UXWwh_X<w^ko=@R<|VA!0eBSq-lyFU
zYmNXpcqQfEw{g|JAg5kS<>|hIteNlxw%+VP8*j4C@3JfCd{N=KSAGup<Jo%5lD-1b
zKcZh+pAO_4-<kI>u};n4wX{6@eFi9${A}5p#S&z8j@dXnryQ9E(UEBo9hug-z5Xp#
z=d6!w>*MR^(k5Z&xAob$)dWNws{D@5YhQ<=i?62sb$f7{^`Okp)~AL1biG~D7|73&
zsR2$r$-)x^mt?YjjU-F$iR34@>=K?Wp5K6r-yag0sI=GjwX6|jYMz6$_}KYbeK;~b
zWgMBFGLB5^!;xuy5P5M?p0i*AlkM}(#@YE~<J$RUZNn<~4|0yrN)^s0OLk6wpS4;M
ztVhiKh1H8d=Kfl%8QI+f&F`4YWZPUOJ0~<<4aqTp%8mh!eyYQfSv<Ktto=DS)#1o2
zzCwNok<%Uu$P?`Oz9(PXv=yp4_A1&wM;~^AHUAw~N@Xio4)>nS-vTR#EIGlhaA}{t
z)*krvEdQwq-yQ{W9V?IL=MmvDkH`<JDpMhU%ym@Xvpc&qfLz05o}Wj^k{$Kb9$4`L
zNaV+Gu8zxG9hdD2u=BI_1M}155dy1yI$up>`-@hF+h4ST%+`md`W@LSLx?vlzaqvT
zmS2(OEb;t=dFdQ7Uk=L!^Q#NkV=X7btYtC}j$A%j*hDHH7CI625t)<^sbcvc+tCsE
zWFZl$d{|gS!O2L;@t5F|KOpD$tW-gtB@6m2S@4Igm(81-kI8m@+v{mt(I?NN*m`a}
zVs?J5e<;i+FZTGX|LxXH_>k%}Cnnp?iRb6V+xdBgP`=}U6OVJP`wCHpE=7>7akMBa
zID}u!Z=IA*epm@y#6c$O!;t^Q`n6=oJfS@6NeRi%7NBDBWU?Iq8)pvNxF`$pv~VGw
zRJMzw`h*6@aUM_6KX^zg%VK+mCp+LTdA=jGCrd{BCFc^!PtPzuU}v)3zBtY++{SHx
z319LTWSdUQ7smS*U#Ji&I|ftPF<A7MoExM(dImZ6vNMR)*T08<Bk+GY0=>x%JUp=G
z^98oAZysdLD{-8!7hvOE+e&!dKzcuK<MU-aR>d=Ayz~(|Ua|Sl%eX&IDSw-c2T!H<
zS2llCJIOw+{Oe_0D}Ttr62EGMqW=mR*UJA{#x?tXmGP<*6#EZuZ|P_I-B_F6u#Inq
z#t$8DJ(~nydHqCfP~z8@zORhpu`*tz@`rlhBW0YgM`_1@&w-Zx<b7N6MxwRBExbxV
z-l7PQ)d~Wz2P}DD4%Z(GhxN7suu?ch?bk6-oW8At^8;)Ei<KX+=kMM12jZzGD4&g>
z;C<;l>jhip9eI5=3*HuDfk5$qHT)p{A$;Z_j#CG5oH~f()Il7l4%&EH&eF7V3*bfF
za{^>hZpS}9|B{_X9s?{W&MzP@k2&KJ=Xz`5WUZ-S`Z-zi;nv&wx#LSSTE;ULw}|I>
zl%L~Kehykb4DW*lf!usVf4-VQ@h^QzVL`!=f^0iLI!?+TLKgaDKNs98zzgRJRQ@7T
z19|xwK{B+pehAKAhZe?%R{inqIZ!_Fk2p63;|IyR&5H`onQz~*sQSs<dBKb!X#7e1
z0B<=y86?1Xd<p>O;nDmf<x3gd>?>%&J|17*fK@)j3ox8*zY;`n@;aZjv3H<gLAEtw
zR>}{iWn>gM(G|z{^!x*SsU3YCFDRPdA|LRU_@w+Iu>cqQio^m`oRr@p-@*k0R6f~V
zK1YDn`VGQv_ATLLq07w0LIBnBEnFzT6?a{ai^iYu7Z$c${=&kR%U@X7LiuESi6WtR
z-T$;=G5k7Co<_FF&(3X;&--`Y#MJmue5vh$JD#z)W&UD2gDao(|1I)K|KBoh7q7*~
zvOfpcpO$`3LBUcdf~tKMo?)A(l}~VTe&Bp)zeNsR;}@i5IL?z!P}NWPMUHnaI5~lx
z=x8`xzpVZp>7RmR4Ze)U**v-$AMm9Dtl0;A4_qu>=jVIq&-c(z_$}(s&+*Wo*0O*3
zX)Tt&2s%*G#Uj_QB|*qAd`M2w;vvIf&O)hQj%Rt`giq@T=ey$z7Yqr;lSVW@uw?Lv
z#o~J8R{ypnm=Po$ct&7JJiP{M<#T*ki+BMq0O1py7T|&}EofOk#c}<Bx1^upuKLM6
zPIf^?ZYDN9EutB`@EkJJOn-`hjPHD}<c=@&;M=z+YWrd3I}Rx2FG?#ohYaB|78kkO
zmqxyv%1w7pf3<vylh5t=H&sgc1Sjvxw#bKfX<OoFFKU4wOwS>W*Xh1h`(S(p@7V^H
zurZ`!pMwv}vc{Mw9#2jV@^it-6G~D%+rk6K=@1sfhmmK$EtSujH>y9LnvdelJrw6d
zY|K8Zb07xt`3G(O=PG%AiSG|>IR*c%^1$zrac%zU0S~-V#`%8Jw*E&v@c+rUHb3^F
z2mYLlYyNNXz+abf&HuM#T=VZ;5Bwb&*XH*cJ@C(ET&w@@J@9X3T+_eH1OG|JHT?(6
z^M@MVPR6zRjrPC~@xWtbT&w?+J@8R7uGN2%2c9V7TKkypflrljt$xyET#IjpjBD}D
z^1v6$xHdn#+5=x9<8f=1`O}9z@HH}Cuks)Bz}L#SHh=uAjBE49wI29OGOm^XjtBmh
zjBENo@W8jqxHiAO-2*?+V}AZs`TW-E|4R@2P`P}q{yTc$9b{aq|2`ggCmGl3XM_hn
zOvbhPIYGv?^2d7M2{NvgzrX{}lyR;8vpw)E4?N!kUo7LA|8L0cPxJ34nXloW$b7B*
z+ho3me=GB~@}HFX8vd)y*W&xM%-8S@9{5Wh_=_^G`PWu{zNO(&GOqa-?SUU6<68Nh
zJ@8I4uIcaLfp?Q}ExvIc_;?R|tc+{^o$i6plyS|!Gd=J*GOqbI-vdvTajk#8OvbhT
z_ZkoUDjC=M-y1#f>t$Sv@9iG=Z8EOKx55LzTgJ8cR(jy8Wn8oWIT_dN+au$e{x<aa
zGrxb+aG#8)oTxm%KEMOtU&giP-)&{w$JU#-@6QgCac%tksQi3d8{a-H<J$OnB7J_%
z{nz-DWIXvP#s6_p()$D2_;#cme{KA{!UO-WjBEbi?}6Vd<C_0f9{58tuEpnZ5BxD1
z*X|E$J@8|c`d8my_(aCF_-~TS*YM+Iz82pvWxj@w_27Ty!9V^Gsr_j6^R3L+@NZ;X
ztDl`7`1dldmETkLPs5LpaZP_e54?|zYw=C+z)zBK&AyowA5>J3KZq^&FsPs~BYi+H
zKQkk9!9eRPC1?Ih<4>2%*ZiB~fv3p0cK$E+z|WF#?ff~<179lRTKm7;122*BX0`vj
z&jVjA<Gv@A{&SDq{xy7!%-8zgM?CO{Wn6oI>RAtbql{PlsmveLdf+co+?hXJkV&@I
zqKoe>$g$R@fomPV{zS9yz3l7X7P)*4-z?)<s}%d*@xb4bam~LEJn*eDuEqBtxqi#{
zQR@Ft54=6a#rTm`e9-vu?^o^k9WIxz;fKk%W`B1NysHP^%LDHz<63-<_Q3nfxYoZ6
z@WA`axYoZ6^T3D5xYoa%=z))v@ycmR`}p}#>H4VQm&xNZpUVG3=4*JF%uk-K=qK9_
zMGNPrhOd_S@m&@EeAzz@e^cg{#VGtNnXlmsWSs9eWw-xa4?IW4HTz0D@QY+zvu~9L
zzEZ|D`|tC>@0D@w`c&nCKP=<g^=GXIeu2_H)azrl%-618kIQ&G+rP`MzgIo*S{W}J
zptPTlJ@D6Myg}9fnFs!<jBD|am(M>9A0gvf{7>@0N6EMr-?1`Y{)`fz1s-^+jF)_;
z@bf(I92u|sUf~ye;6*at@U_B!UdA>5$IH0Je^$opzg5bA!vlX=#$#3gD&_lQ4PPna
z+V$%_xqJ<ON5-}5SCa?+y^L$uub({dA7#Ai7bSkZ<^DmN-{>HZpS1a%X&(4g8Q122
zW_#eXWL%s7nJ44g{9dUCeua!{^MBXNxHi9crw4w!jBD|0l=~+QUm^3g_&wl(SIW3n
zzE5r+8vc;X*YqDK^EG^}%-8Dg5Sg#xPk8XZ^T5BBam~N|JmSBPjBEZK?18tHam~Mu
zGOpRz#{=&z<C=YwJn&c<*Yr=5ajpEVa{X!eESazQzfI<Ac!~#qp$DER<5f2*_n((|
z;1|ny%1sLYW)J)(8IPW*e7|*@2Y#yu{vQwgb{Y3gR`lN`;|bFh{4EdsO&O0;<NK}$
z{*H{7PgC@7^}y?8T(f_*e0|gK4`hDL1V#UYGGD_#lKH8pD*P`z@EtN<sn$=Ej3-Y~
z%HQRI|0LsD`M-PMyJfslZ68O==dV`(13d8lGOopUs0Th+#x?s!df>;)czl&|exK}t
zkEXaV{}Z&<9tjlX!Z&Jsg9<)>7C%#|zX?kDDxT<pPxZhj>-H5DrYqJt^Lu3*6#Hh&
z<!ksXxAF_n^6N{K@&j`D8a_|P>n>IJXKVVcZ531lc>IG`DEuWV-?jSe`A=>B?NZr3
z4Zm0`pM)P4uXk@B(WQ!g*UIH<_|-C=a<#%Q_rPzJ@#bq4{t)^8N5comc<IFo|3nY`
z1R0N2>-QuNe6)=FFIV)hmi^Q41eu?;T;V?;^J|tVc$EkKKN(NGQsF=Dfj=hWmDecz
z4IcQDGM>;yx&M341Fw<sShhdBJ^xedfxjf<+WGN;2mT4gzu^kY=zdsS<VPE?aL4=j
zy7H{jk*D_Yb(7M$z*GD9y7MII$W#0HdPwP9;HiCl)^cn-**@~rKE5OEH1Q9f+Q-*Z
zOt$~#seOEYJ5Bt9r}nW|OcYUP9mPJr-ZH=>p4!J}E&rtD;i()iQF1tV9|fTzPwnGl
ze<=kxcwbjOPwnI5fBB>mcxoTAgPz-urz*HzhJzpNM)&d5KKw7f5GBj);IXcJp4!L9
z|B?&fseOFMxbk_bh>ImSINzB@E{3P}@$tVX&dZQf9d1I9?qg@CFha!<7tp^Bru&xK
zIQxU+b*IvO0R1QIV?Dp%&5z>=BtJaYXxNwIsYLSmF5YD=Yi9i|{ntCy5}UT%!cCW8
zUvIx9r=D2iiqriTa`VVOV0laFUUK<G>CXN$6lWV~dEyzc_nSy3-><;_4okB03yacn
z$li21PWJcG)Wcp})D3HYEdgIbHlK1(_`ZkmnRz+q!oFu@!7^b(DFwF{`UeYn8Esg!
zQeKqnH6eq_-N=3``?P7}t9zDSfB3%dj7ECTHoi6lk9%IZzR(OMD$e=rcrh<O`enR)
z&|lpG4*Kg}Y*|0YG5wXZ==h)G+&?~k)ZYJiSH6B}?`O=F@1HdM3>nwT56HO2A0)qj
ztKrAVxb}WXyaztq1D_`2Rn<!TulK;Ok#Wubdpz*FWn7zof4~F3PsX+R`N{J8``Y~b
z<1$~vXUTjm{%6U!X8-SU`P%cTedPC_HQXoT+ViV@Wn6ncbGQe7fQ)PLJ3_{__U-q;
zd&;=hK92Ihd&{^M|5IdKtG_uOc#4c`^>>wwYw@|x1K%Roe@!pt{Hm6p&ujL7DDyS@
z?)K1suLr(L#x?y9%DDFY{$m-}p3i^ofqy3B+VlCZWnA;$C%<3F*IVZOzHhyZYxQ@a
zjBD+?y$9Y-#<li+m<QfL#<lpLDC64sKU}{5EnTk6f1N4g+Wh=n`T2_W{Ol$f*YxLj
zlpif$|Fq{5$uh3Z|Miux&)WRaLK)ZY|0l@yY4@-1Q@%6*N7o-9-*1!Gz{u(W`1j2g
zj(p!t7FQrET;`u!94Mk|PAcUKI9)<W!C|}6On7~d%*0t46x^C46EiqC-FY#vG`ld1
z?$K<W3Jz|4mQHqFTolX`Hb_=**!~Z;XS6dZI2iz^=Vu4S@ikw+D=p*fBG?vBAQKB5
zKEss~9Gryp>_ud2tjzSxY%)q_C$fWQW|850@LX65uE^P6*3b46<mdeX<d1>=>HdL!
znqrFY$M}>@)}>d<Z)@RH1L#n3u75hg;OE#+#`)IhJuSB|02?+Jk^O};1iT=xC_g>Z
z+R2!1eQWXg_`X6J-&e5lJ&bSRSGknUFXhs9?JIQ74++m=_<0C^4#O{W$4fe}`??Z$
zykR)QFLTFz9T|Ql#jXA1#*xjM635N5b{&V^!e%7S48RV3#BjQQ8rjP!aXQ)eZ^}%v
zk<qx6lsLLMjD^GgX+>nWXmWE#_EpZzARD5PErZi?=n7?Yf3qcN`PpRMlytI0Al*Ki
zFJDH=2R>|oN%ngtdz6Z|h>(fmWRd4gvgt31(>*k-t-VQEWHV;F1_k}(o)FVd_H0Sd
z%g7`fkEX#s)S3B;efBQf&d!4@2Q42qn5O$|s~ITHw{H%>=ILOYWh%4_iqpGVvP)=2
zV19OP2Jw>{K=Fk|#4fTEGr_HMFq7<nNw=V;I60}|wv{w!YxN7VS2fuM)N+F2_WpDP
zCIJ#Qc(?Hk5?<K2ne6v2?l4YqvMV!eI%<cH?54>qq&VyvP0A&1<edwZ#5TLN{d4s5
z{miZ2(#9=5Y$cu<AgdG-A7Q1*?1H>p7N0b}Avo;(nwe`k3DL9TN8HUITG{TmG&BOv
zo1N|ewV&={UXZpRlWdi1ZGg@<Xtnm63M8IR+Wq9jnMqT}2WHL)42~Z$VsKz6Yyjl!
zkF~)5k<GV;#<TS)y>NR!tE4eA0@G$qw9Y)f`IzM&+n)--y~_8(E&Z@R6;i&vpA?Fd
z{iDcwFM%1e#*!^CVWTs?RTPUq>?b#7=G4g(#|6etojQr^PdM(hz$w!cp?9(R7YDa?
zD)hj~-jiYxbiX=QKJdxbSz-naCyQL7INLfCEq_MRRI>M?WS~?&*-1}E75}WQ86`St
z-$HyQ=@}$Ec`DIB_5l@&2#|_9JuxsNne^Y2##lZ0j4`Jq21tXQ#rkg&Un|e}*<+@k
zG9)nWl!<{cGbUTn2m6wzkC`xeOu*Wa3btNNOqt30exZJ5OeXsPj+qdcI%{U~EOG{r
zmQR1MpBLF*m2DUp7&mot@}xxj>Hy{2_=q^NrJ$OF&kt$uSKKX+PqpXo-^sZ4e6ql~
z{=t|+yT3SH=4<#o8Q1QAXUg}78vhm<*Y1CkJ?1a|kons9e?R&DOe_CTnXlQOB=fcV
zyVqpCc7JrE2fsqbHU0xKuHD}@$hdZY`mKy>_WvQ{T734G@9(tuboIcy$hdZY^O4g2
z)bATV^T4-z;Ef*m7asUG9{ATD_yO|!J(~afdEikV_<<gHI}iLI54^nxey|7L!2>_k
z1MlL2AMSx4;emJez>o64`^&htzIdDmKF|Xn;(-tM!0(XzPtCsLJ@_j<_*EYGi5}%Y
z?ZH3Uga3jDf4m2OoCiM915fh6r+DC#J@6SG_;e3E#RH!$<58b0^K)}O@Hrm%SswU2
ziaYZUWa=r9M<!Ml<d6rYL1+BL=Woc$$SvYz-NP1fvT|&Olf$Kaz_kpHeFek-4JP9^
z+djax3<6FJ)L@YhxR$};7kSuk;Vtn!>@V`LzsSRW3)l4X@oQ-}<@rLUeErn$E0y-6
zjt?G^$6wm@^$wX|+f&iM$^&1iw$F^EY55BR1wnH6ol~@k?rs3%cV7Qw{*O(wWRN{~
z$lnWd^PKk|E8kMiue0RmD;hqJ;!gSG(L0$$p;M>)?N3R6abYIec_Nrc_N}w0Cq?^;
z$<$|hAvcn=CYZzI^;314^8VMAvV9s}s@k_8KX1NLxKMu6gNpw*$mMJJbuwOErtqsg
z@c((>Z+qZxQQV1tcELh2`%OZdxtP3a!TS#$Kh6H1<nlHAM;R}FNb&C%4}6!5Yx|Sz
zrnqB&Ft31Yyu2uL5t;m2$eXWS|8Wx){Rhd<Cp0{Y;!gRj@k6`Hw6{mF%P*->+LvE0
zU&DW-&v%^ii*iZ$$pj>sru37R%&rgu9wg@-nV+K5^z(}rSXJcUOVVIgj_xjylgR_X
z>rXrXMymetnYq0AXJ?YrsDMnV5e-iHWG9te_Kt6Q);YX=i1-qh3^MM)U*LwPpG%y|
z&s&g9rf*^TG?3|j{?j=;ynlelMtUB$Kg@zm@^Z1YcMaKwHN)E3hI+_wD-{r$(cXTK
z#K+oyW`15?4x6@gHpqbzTEbzAm=<xeMNEr0nPY4bCtJj{h!Zy$PM(Ljn%@#`?Qqiq
z-`c{bB^;(mTf$+78{U4k?=K7G@o^N}-yC9Y{f?Hee;R&~%=ewITt5fMd<`#^`I>$2
zdEgV|@-_Rm%X|%=B=a@<cFKGWpC<FQ`Kw$He31vf*aHvBxc2<M&;u`!ac%x)sRzD9
z#x?(M@W9JtT(kdX5Bw$>*X+N|1HV<qHTxftam~K<9{3Y7uGzOy#x?z?$k%TTPn2=Z
zz9bpf^q(f<8b8wm&yaDg{A>?AOUC(r?!5c)<$K_ZWt{K-Zu8%k=Pxz9Q06yZp!8oK
z%6tu9BJ(x-_m$^2HT(jZui1CA2Y#cBYxdpYf!{9US-lniAMwB+mT~R<uqR|Z`Y5IR
zr#<iuGOoQJ^@@!1{ps!c|HK2|B;#3EEB1Zrfp3#>ZT`H6Jbu;i?lP{;ukVoGU()cN
zGGBW>uuJA^c$184?{5y2%h&M!GOj&e8A@^W{Sx~A$#m-t7kK}Kk59DsKgY=B^Zo7Z
z`c3h`PnU7+{j#%UT+^TKfzOw5Ej|l8@Jx!k$H#d;hsQ^Y?>Tb$n*I46_+lB?>_6WF
zKTpOr`!4dpFO+f3{!2XY5*cqiT{(YOIXJW#`~9NDbY97~RGweb`1d$`c>bB7mcPaW
zzhB17W-InR>Va3uxYmEX=7GN=<68gmh6lby#<l+AJqH)#+rZziTBgMJf6Dy9I}RV>
ztNHi22fjnbHUGZ!z#C;;^Y0rE{A(GHy-M-#82SD|!;hBnxKf2b$O9iB<0V%r{NWz>
zP#M?OKbqiyC(5|CKGLZk_(U1k)<2r!flrcgt^Hi;ftSd*)_$(0IDdVTe;-DcZMVJ;
zt5LoWI~Dmp46b+Zi&ox$j27O1bbY^~T%Nzy#@F+heYE(0|Nl1v|3={72>crX!w9&3
zluODe&Zgf9cOidYncI#&EO03s<GW;aO~UwP=hN#<d&1h8Hz388OcF6ZmS0WB_+`xh
z4ulZ>L-v;{kINXJ<6cLMU%~u8gcPtY>9fPIaxgxYUropORZRb(gs^enjqGh?mEC&r
z*EPAPVD?wC`s+k!o1Yx{l{>rj?5`2p??L(DZ@)D{`>i}`*rIUzUnjKR-`@^@`)v@~
z?`=<R4}1G<67-Kf_nENkuV?iS9Y=?)mt7O?`fp<TVJ(S_>aCl@tv~8)di{d_JL;r8
zpM+b#pXrDApR)Zp(i+@<SpVg_fL{L&BDA;P|Ek%Y-Fp2OrcX`B?2l*ucO-<(^Y)yf
z^0<ug<Cy<ZB;#qj$A<m-mn_s@`hh=Q&h1r?nEh%#Ovd;Ledu>~uujr#%VPL)Kw2>v
zU(1LjVEin>{{`(nyB(po+W0G#`48(b-GAH*ox`r5wLcjDwExfC<4yIK5+d|{`;&j&
zFI~6Ol#k_C)3N$1Vf6<#Tsiqy;*I+c<Cih};d|JZ+g&o&o!xr<Pq|?KMIqQvmfy4D
z5B6_}fc+&x`{@!w`>7DxPu~c%pDH2#M<<)NpGqPAnTLeG{nQHf_Xxp$vb><(e&$5L
z{xa5n;QlXX{CCFJziMVb%&nfi;FUkaeg0zl)O4)>QS)K)-<6;6JZ(R4{l23A+)MX1
z`!RdfbS(a<k5K<fGxVjt{-2Xo9+xqG6Iq~<Uq5pn|LIqrUp-=cH6JFo7Qg&D=l)}4
z^3~H!^*1yB4<y6`kLU=evFoq3?62?W*#A@r_PZMEl8D+*27XZg;Qy5o@W1g8>c3^f
zMYo;jV!D-t*<U5p|FUW3^&chpKl8{4)c+jnKit11{#rEK)PLWhPW+-mh+mNPA8`No
z{4Hd&R^*4pAIYvIWBgiHf8hUZJ(d{zUn1Cl`1<hM-yqmuJ<Z(y<TL5{2k{^AUHI)U
zWATIW&wekphiP2bA69?S?EHa_vrS{;KW_X}A;hn32=R*%;urM~j9)W5f1u-eYWU@=
zT^k=s#M+;q#SiX3fBmtY{k@A?4#rpWVKT;VV%Kl5fAk1*`(p+B&;Kd>_D5eYTtALC
zw?9s>|CFD@Z-3Nb)cy`6{@1qs&otBei)Z%3_-F2We&g|9EQ=rL|73u<{sck)L%YrO
zWB#h?So=*7?DwUc+n*%Z|N5X_#_?0_#AM9=RCfJ@`=3GUD~<1el9~N5e>nP{HoHyr
zWBJu|%ziZ=CS&{*;rz`kh`ryK&-{n}bLHSF{yCyn45nYph$Q@7`9UFm=Y$YH#9b{J
z_uuJ%ANsQYg&L71;CzfBr(^u`_o)6}B>R&qJFJsgj)d`@94-Ha@oU)ghZsWN-1+ux
zSSc7E%de(m{02e)HG@trQh8j)_#F2-qWr$}`4jAualqA0+p%&`K1NW|F@6P`|AhB{
zeq3Sx{sh@R#hO3Zm+;4o`ZMg~{}`Wh{a@Q|{s6^oTg3dYW%k4MzofqL6Puv?f$^1W
zsEF~ag!$(aSL`&Nf39Qp!-aR`3!B0o{~BgLTz}tKJQ_X)cKu=g*E9R!`uoWlxBcKs
zCW#my%de(m{5m22wI}~z9RCI({x79%4txCLSo??f2m5@`8N%rL!~A#6?2?G_8-)1n
z3Yy1{ERSaOAJBe(x-tCmb8*!*3G?4Ivr8hzPi6f-?8Ef&8*lG)p;}28AIq<%WBeqc
z|2*xMcHgNyE@S*AR)5fccAbA?1<$V@F}|7)lQDj(V1Jj~GUNH<X2Jd)Cv-8seqi>h
z>6ra$K1}|*@}obZ*WaUv;hCqd?jCOYi&_1{{L7CW%bzmVPl&*U`=7yY^t{BFj}esg
z)~dfUq5bFW+yujD*B_>zEbnMP{~7(vjMrSrBoX6d`PFocUn$sM6oUQHg8kznV1Es>
z9|jKZ4u5Q$>Nl4$|D(wrAGAMs|1e`fet_p!j~HLghshYfUa<e35$5*$1^WjL48Q$N
z%zk)q@#c5Oz+)uWALf4?vmd^nD|>2N*yn$u_M!bJ*gxm21K=|1`orvR$fE6sT*iD~
zE!cB{E14u>d@R43j`6EzQTrkA*Irn2mdfKY#!nUIpYHz$&Oep1`6r0q&6B2#;PFzA
zSp4c9q4f{X4?BK&%l9ge%NU>IUPp}YXY=o1f9J{O_LrRL*ne{b?5_~wzbyp&eQO>2
z17C$d{?*KWxc<Do-$lmlCz{z0*Pr>no%k5m4zT*K6ZH3sHP;^}=zpx|C}aJYy=ppU
zf1_akgn8!nCkyt!Gc)}5`^sql3uB12MdOX<|FeYtw`u66y>9+Lx)b#up1<Y1^3^1@
z-nop`e~|eP7v2+YT^#oL8*ZQ15wkyr)j#;3AA<kIg8vD7q5q|<{-OVS?Wz5q#o~y?
zFI6~y&v^8?lT7(oel;D_AIIts?4P{B-2R|o{|6DU-*-4Y|G@s3r_Jpz5$wPBG4uE*
zvG~FG`InxfFIVHvWi0+>Oh1hO*M0Moy`C=T@gv4h74%OWXRg0O(0^d`&&K+>eO^b*
z{$j!Yvy08`uM+H!O$@*NHB3Lezt;K8j?fHTf0+Lztp9`g=S~-WyVv#quFkq7V*b~$
z_`&^SkIt_rxKOPmj9<#)2M->O{p098rhF{FnvUsL^I>vp@q_WS|AP<bzT15JWK;b~
zm6YF+5PvMZ?p{-V#Xa=?1IF*q|C-y=lwZp12mPm{J{$Ju-&M?hIDgOCv}l2;{WXl=
zju1EOuG?tJuVZ|8{ynYg+m}uG4U7-hkDkTv9&E~Q6726ZEi2EI?^{9ZAN=1k_=q{C
z{Ak7p|Hn_g=>=21pYfsomXDnFjwwHtwSO2tOx^v~OQ!s+`<?OsA(w5t$dq5g_;BI4
zA*G?%l<ynqoc}MKw{nOvA0sH~`zSIO%g7t^aPJ50Z}SB^V|luI#P~k)!~pnk{k!vy
zjmFo%D8`59Cr?jXSgPvfGN!*muzy&m!;POmL<{;?eDT@?T%UTx^w&I0{fGIpH@^MB
zxc$X2{c!*I$yKKeRrPWi)9)AJ-}!j+_vd2;{XfUXadp}e(;p|qFYnY_sx%@?!1z_H
z{-FQ4_Kg>fpTE^GKE%K0rKQH#pE|~e>tF9<g3mH@wF73qmJvz7_zi;pWeJmJAar#8
zJzl8)%OBojeEuZ}_5Wqh6|bA>Phxx+zfHWWZyQs7lTd$gy(Zph%1;*TzxLEGU>d{q
zhsEEQ;+(%X9$!h$X7?Y)k7j(haA#L9`P`k2KR@v^KD7U$74=D`{5W>~fIj$!s#V7Q
zR~*w1*Y9Dm6_=XoPhfl)|DSiyod22fV;^wFuW$9~w#Ag6%=E+fVdi=7!!W@0ht;32
zk8}N+e&;&l^T$=0OCqY@C9hjjYw?3Z{hjU`XgvN%iJ|d>^FO0;`8RI1Lt1OukLgp>
z|E~H=g!rd~5dTym{tF@y|FTr){LOiC%`<A;x%_vHe*)`&p#StA*0wjdS3P3(XR-Lh
z`1PzeZummwaT()t-0S#%m7gNSzh4OP4+`<mh(P@P?EMRv|2TBoTR&j+*jn`$FTDTp
z`|_ypufIe_+;Hx|^?&DiX~y?2SiID9EPl!C{TtAK(8nD|sXQ)Y{1{?9*bmpQE-&Tm
z;`!Ah##i%U^52!8%-RpcpdhBH+SGnOiy!oVkG#9oc>V;_r>0}^%M$EAHw62GLi?>b
z<5lDK8!Pz#L<IaV5&EA?bGm<}#*NEZ{8HKZ1NYCqgVI;>{OS?otNAb)<ChEePhMnh
zKc-Jj$MgpU|6hxM|5eO?xN(U&X+WZCH<vN{%Y^p3>4rTg^8D%%<Cif1VgBRZ;a@+e
z^0<ugIqr4D_+>)>J$uMu#{G93JO7~n&g{16AJ>1^3jN<lu?MWj>H&*CmS0WB`0+yj
z*ZqrY!`}Zl2>x#m!T$uo{$3HVzgg)2MxDIRA~o(@#^PTg^j}YYkkpUoSC1H9&4<Yt
zKe~-`|94=5x&2jw{a1V#e)}<h)pX4NSmr<U-!Em%Sg!K8jPYxP{&(h?9iSU?{b799
z%r1$o#ZM6GzyH2Fh&S%P*3zFM#Q&M!<}7g6-g@&-3H|8z*W@<TH|fR-Xa=so*7Dy~
znM)$3Kgi-ox<TK4V}Cau|GTJiO~Uk-GW~}W*5s)Fu5%@mM2wH+SJN?m1=HV!5Dxk!
z{YaI^WsJ{puVZWRtA+TzyX?zhm>sR9AJeC%WBTg^`~BMrx2ilYV|<Q#9b1cE$NF!0
z{xE*a!N%{8C9&}bJU<`1^NYRi`9l@^{sQJ-dWZ1-R~b3upznbTU)(?N{V(G7U;1I~
zw~W1i2@gKo-Ci>fD-7e8v-rdN2U|1AX648a<0IL%<ksR>3jSXkg8vnQ|8p0F-~af|
zbo>nUm+~L;`l}S|@3%1g_SdlZ!~FM&QCU}N70(i|`fpfE&wrSITEFVyv8H@1znYHe
zuVV2B`>*Y9Zhw<tf4f?9`|E}H{V&yAe~s|{+i|~}>sRB1$yoe+kJ9>s_XoZhFfhfG
zU&Y!ltp79o<?yfngW0R5qyDQI5gFsxvHFAYLkC}H<MBf^iyw?14(+{juNyxg;nI?^
z_{FjI2l49?Li}ok_#OTaj9(M$f8fGjb<|74wZO9kEdI4De(?O~yKR%h{{DW{4fOg6
z_7CY}ZhxI%fAG`r+wT|b|2+izW7+#l5dRamhu{8qW<QKy9-Q_8Tt;1gSo^7G@rUu}
zc}LEF(UnXRF@9qgXZ-X>p}GDBLI0*P=K3*v)pX4MWFdY%A27GSQLz8pCE>R}OK89T
zeaz3lCgJ=$Yh(D^Z;4?4*CE*7EZBccP5A9E7uwIRquw+=|I~Jh$yocv@~i3pSNRQW
z{s-niDk`oyS@oOCnEx<i%;!J;SNi#0w|@%v&+CZ!-^k|w;QH~(FKvy#Kl0McaZJB&
zUuXP~am@G~JimHG`D#W){=4#HnE%jm#8hw0K+H$4zgT`Xy|w(06YB5FX|KJj>g954
z=}%(%;l{1}=w~)_ed@8b^rtfYaQ?h^&WPhxy<BcB{l!B2`DEBh1zewcY%Tp|g8rMI
zpL3t8m&>iCpO^1-#PnA(`{BjS!=`1yZM^Fb<GW^dNyPXyOh35{`8xG~c9RR$O2YV9
zel;EA*E9Wa{!AZp-K{E*%NU>IUPqLFwDbHnsrFFw_lGW`*Ke4AShl9%e9R71KSof}
zF@BTK{^y<kO4$4FsQsM#uUnJiFIUXAMa=$WGWdb<58VG{9KLacO;G;8_)0cZY%RW@
z`42wydF_@9Faugkf2z=ayAHX+`1>);UNs%FKc4vy<A+-x-VL9zx&AP|Yi5^3jGrvT
z|LCcQg#G%PCA9yI7p4YWOt+FS`?36LI>s*%;@|0xRP+8zRfNcxek8k=+*<sg(Eon_
z@DStqbInjB0kgk`oqyd3Z{?I@%Mg02ji1X|{loh+bsr}`8E*Ymg8r-icUEG!_4|4{
z*N+#PQjF&h8(95yCx*}dws2s$?XM7?UmO|2^9#&gH63feRZKt3UkuytxiKn_%NU>I
zUPp{yBj`UN0{W|j`LpeJbc12A>kqTvHM2`1#;+ChXWkip{SAWtxVyryznSTW@x${k
z?F#$z%jg^F_!aaY{#E$(yEGNoB&_{3bam_>(eszE$1hfh->)x+KYl6QocoU%=Z3%i
zCNTeD{^iK?!mq!M`48>4{q5%K&!sT?q2qh*fRo8;9PU4~{jvTVz8^~d<F~in+4%E2
zEWetL=~we%a%=IEy3_Ut1J8FiUi6Ns{^*<N_yyKqy7`(B&zSPD{Azk@`LF81WK4gM
zwLgg8hatqTiM2n7-+%sr@vC9&uQT!g+q|+hrt$YZM%y2(U-R{pWoH}nF@lng)qhkE
zdj5d@c|mjgqsbeuF!uuXFPds@f3l$egvBA~7vdM6Y_4Ak6DnfyD`n>oe813T{N~TG
z0x-Ux*$?mU^<CL-n<*d5ucl-AYgzok{_KV3_QwhKFMTQe_E!k;zv@nN`x6BF%lCxe
z{)8jw`3Kkk?!(uls`bWYtp1Xj{c!!i|G4ard4BbX@zs2o{4d`<GS$NMv)8uQC%Nas
z$6vL={N?7ms>y7c`wxqM9P5AK`uoX4%Z%S2bl0Y*V*2%*?kO0*f%y;DkV7v#E$rV<
zyIZTLV)i#P`(gb5!smC7)|oT~<5#ouzZ1!JbO`MS)2F6m`cql|0qti;2<<0&f7*Y+
z{O9L2C;q7F<uaz9<6g&B<HyqHk6polr5}d<{gXP@f57-FdQ|0mSR63_OW6E7%pb0K
zvu=<nKgjAI#&3sozx!5GehN8p;oRMy{9FIzv0s_;vHWT}=D(T`lQDkWk<R${#t`CP
zCdB`=Uq&0pKS3BjmxU1jR3ZLnd~(~Drv793)pRU=YCcTH_>DsQpEugP{bTynbWDGV
z(EjK4FmL~{LjN~1y~A`>FPAa>9QQi58viER{$c!|@W_FSF*`8*39SD-f)KZDIt^}P
zTz?q9jKv>_Q=-$(aV3*PjF074(_4$5!0I3R@1G`*hGBr~57Qqb#Q(;(&EsFe`XA`O
ze>iUF8?MSpBBno?^*<2*ilKX7{8L!`q5by%YUS^y{>KUNfApXz<Mv;};t%l~Iq~;j
zO!Zd??f==Vy)XVjA^vS9-DBMTl7#p#S!>?@>xB46ui5>YY5cMLYC3lQsQEA%<7f4x
z{ck5i9QgH`WK({r(EmL1?guxT@>ALQ599xDo=6{Q%1=1ing83c?u}`td@R43j>S*S
zhsmwQuMpzjx#Yjb^M9DVYC2|rsu2H9fm>FqJT9YrcK*TrTmAAsdhq<}5#y`*Fd5_5
zvHlNUT<hoW3bzriKa5{3^gq)t9d@iMnIvL-EWetL@q;Y>(Eq1yyS9(Y<1)tQxYx0@
z_;o`2?Y4cz0?ZCff3eVhJ`SP%lnL!O=DG5|rurL%_H$ea?FZARreprA`7jydHwy88
zFl*ycrhF{FnvUtO5aR#9gms^)JT7B=j(Z(ji{B)SpB|iPzW#yl0O$Uv&4-I~Fh4N+
zqk7WoAFQ9S`&;w%6RL#%Bl^VGjL$#JUNs%FU(JWf7(Ygc-_2>)9b?MJ@~i2X{yHIk
zD{8(lKY!NI`h)qizAtBwSM_ok)6a3QBgT&-R}4OXHuT}=|G>(@_^Isv8`i&Dy6h_B
z^=C1CYC5LBfyE!bzgU<3U5(1)GR7}s*AIxn%iSLSg6CI{7+=kY$rwMHoxcYV;{IDl
zJY>p`6WafPSHIk7%E$7n>6rb#1loRJ{Bhzj<BZ=wt`y?GIRf#I5#rx2g!q>T^Y`t4
zTem`u8<)}e@eCeEj31Za^dBEAegA5#7>pmy`X4xdD*F22HqiBl@m({!Bw~C&i~oLv
zbN2-E{i`a3{->ya@HiLMRuZNk%de(m{Nw~0e~90shrIoW%HuM|=eXDL|0>@vw7-=R
zXn%3S^>^QQ&9A=+0{@^8_+ItSajgE6h4|eYLi}Qd^KVrM=O4Gv>xkL!#p5`}uMw^v
z$8T6`eEp6S`v0QyPB6ayR`}`o9mWsqL(m^D=>H`I{X9NiM=XBzLi{d&+B|+<dO42i
zkLg9@*MVf*XY|V}d4BbX@sn8m;QP@n2TeI$<#8F~bKL8Q@tauu!2TJj=JqEG_V*fK
zZhx5&zrtJ0^`{8>$Ids`A9XXWKX`xatt0k4hs6<#Un=Xr;Qg_*!`CO6^0EACI;LOE
zhshW}syFo?22K-SsfK3g`os7^=0D7TA9!o9$(2kJF+P@GO>Zr}pVdG3KQ#pZO9cPh
z?}h%yGymcFYjLlHg=*ZnjK#l<`47)em-t5X<N4Ji##i%UGR999?B5-N{S|`!%@MFa
zOR)dN-sbVI66}9|pYX@OgxL?zkBgtGHGck3B0N7|)~z>I{jJu2BpgNiKd}GRkIn6`
zVeyCggZk0t_LmFs`}(j~jN?})=>Ij}Tt6Cc1;Ea~Bw_w0X6-kRD>Pfg_$3L>{7b(M
zr-c3fGnLs7{on5Qo;QB}Rl)3s{;&D*^<jU1tVWnWNIk5;c>cDA*$?;sckg<)k{n!r
zSpB(Xc1gte#X|e3y!o{MxlpYnjNg>tw4cX+Torcv8-)1Zzq;1|Q~R;}YC7hBnGnA%
z|6TgN%HuM|=eXAq<saj$KXhjO!jrIaP(DUb(lNfD>4yjJTc4kMheESOjBjV~_ygl-
zC3Uf$Kllm%twB$O{r#D!iBvy%4B}gnbNqvt8<_oAel;EAS2F!@<@qIJsPX%|svb<n
z^kezebc~;LDvcl5-y8w^8wLHlBcQ+ZG{^rxBA`E}qN{cOz=i9+^ny8Ry>S_<KaP7H
zF@E$IXa0Nl#xr3W!1agmT{F8RV*E<he|IFD+$l?kx=^hojF074(=on(jN|``iN#^}
zzlQk__us|GZCRn(&1KAfj(Z(3em&C<<G)p@Z+wcCgYmKaYC6Vm67;W*fc~fh>HQD*
ze_sUj`vv`LBA`E>>4*Ej0}?lp-7MUHSpB)@)>AQlGSd(3|LUB&u($s#A^uyweY#n<
zoTgy*WBJwe*5a24_SZ$g{&GS8n-S1oCFp-Q0{Uy2emH+79KX)`3{b6mkXx(%-E_I7
z{j1+CDt|q#wc=OJ=HKA?<L1mF<Ml^Vh3Aj$`usiy^9ZxQfwf;4_#AN5fFn%#SbjAf
z)34^k<ksRhGye}KijRHs+&jaqAJeC%WBymM`BQj)d11x+8&w{cF@AIu9shv;{X_6S
zOL+cx+M<L+u1`H;`qg}x+*<rt!T$jv_>bAErni>;svb<n^d|`Z4-UcqxIVP~K>NEa
zg!YHotEOZ22Zi=GErj-$!u*Hv|C~MBepK~x8Pm^kujAj9A7uW+_`CC<@ZW!W#f{@w
z{AyYM2iLF9e)_$h=U0yyzf`FIA&Gw)-~X1e=Xdb_L;g2Uov!NTGNzy7UdPtrR|x(O
z4Z;6PcK$>B7yN7<e=ol|j``ofp8rAoe+nV~)q?-SL-3#5=XJ#F_u_FJ<2MNHfAB8z
z_}2;kj|{>8CL#VCzuo)Ve<SlB?%(1%Z^`2ER*zWxn_2v!|Gc!r(pOa;moYxay^a{a
zLiqkR;p2giV&!0b-$C^H4fa3&T=?f-FniT>%>L+G9Q)rMW*+|-=09Bj-`ugv`1={(
z<8=NQ-v7FBpF!sFR~<!U%zq@imW=V^1pnU(!T(qx{y%4%$6qrPNx<xn7UKWt2=n+S
z3I4wmg8zuQS~6z8mJvz7_*LxuhxZrW`XUxiW7i+XPZj*%8iN1DZ2S%1f4p%J{O|t5
z^t<QQQ!#!qvmg5JXn*W#ok>$LK9*li|GV<bnE!D9e){2s#`70`cK*Qki#Jt1c8cmZ
zms`vK64rj;#jktH4nfsmK&4RsU#%(4<MygYjIZXy<i9JwM)3dZz0m(Sq5a(+f%aD~
z#P8b>;#VrP-}^#nzgT-y(_5?kH3|Oj48ecZPE2ks`!RiLI;KBCcz>&N^9yk*kIN{Z
zjelVN>&a~&zr*vZM~tuL!(@zKCd_}8{x7rClpodB89!Inp7?|*AIq<%WA>N#b><I8
zeQF**KeN9xQ8=?-vhnvD<wE@0K5QO8)lW>u{KxXE=@>s=@PAea{-+4-_rUGu@mKA{
zWX%2wA^z`#5dUPs|Jfn<kJ+oHWA>~0Fd5?qS^VMsr>H|_{c6h368xVVg8wz_{vnDe
zUiQG9YfbfI`PFpHe>EQ_WBd~4KaBr7x7ls{{&}eo|2c!r<B!>^repReu<;MXzkaiM
z{L7jDaO3yrx`$yI3fCW|-!-#KVr%iMSpN_0|NI5!@vjov|M45Toa|z{mDF1HWBSx|
zOn<Ua|G&1m%lQ1OVC@&?-<Pbv{8Cjfmofbu_c~(yI^p@pevgbri^2FPK>;v+HS-_Z
z{|}dMh*fB|i1AZd{9*pCYFZ%-<6M6j-!-#KBF3*1>~9Xi{-9w0<007J!0Hd~{~I2t
zGrs??WY=%FfB){rV=*`X&%Xau%la>Pf2aDfJB`QRRV;qcaqr6SGld*ne`sJ`bL)w%
z#cyQo7yN%F1pliA|9{&H{nsPyo`S~zR(k&f*S|ks_~0^kHvax#iE#b6Fzu+(rhF{F
znvU5YBiMh*i{|#13HJXP0sG?w`zO6*ZhwVf|Eu%EAO9p~KV1LcDK)?TS26qH`FVOt
z_^;oog8fH7Xl{RvVE?+6;kUn7us>;=x&3v5{qNR?-~KXYe`iwvU%tF<ntI-I89V<Q
znEmkm?-%#3fy;pF597OLc1gtem4f}})SBDhB-o#QU-<2hKaBSO5dRUcnA`6oGj<Sk
zi2tz4@Y|ov?1%gBcBkDmpB!9&Sp7va`(gcnt`B@;{QXImpnqPjxqiQ(|D4U{`dyuM
zNyPjw5$wNcrMdlag8kRD`PMjoE~dIBVfH65{c!*A$YZZfa3zyOj9(+%KWx0SZyQs7
zt#JPzAA$S-20{M`5zyZ(=szg}`lH*?{;LbAxQj=PFdn~R^{u93?I)J$hw)F;<@Xn<
zJT7B=j(Z(3ege}E&)-LVe4g?C2VQzPj_FSk^pB2!{-B`$<Ot|574(mbfc^@mAFkig
zePUr70@oi_f3BHb5;1-?(+~4sySi*MUjNWVm1`2FzfSPK<BO>KX#el3%q0=i-zexm
zECTv{2Rq}p!y}+SM$q3i0{Y{ae(3+}uI;q1OVwFPSp8x7)pU%X#Pmb^zx9HW-&G!$
zF+Rt=ju<~xi2vG?4jh7&gYmKaYC6U*7W6+F0sUoy{&f-1Un%Hc9|8R}Oh2^$s`)$M
z;QGVr&o#44BF3+0`eFRxUzUYVAYgnKRjx@Gze(_azx;R4b0w2RjF074(=mQjduRN)
ze+2aV1^ov`K!3cTzg-0MrwZ>+eOA}ApIUER#_EsbUPp{yBCLPaIdj$+tQ?Gw<yX@&
zeg)HiBq988_ret_kINXJ<6cLMUnA)MF#`G<1pPlpKz})#KY=;0b52P%|Ne$NvIH*F
z->)IqUn@Mnx_`g=>#=&o>JQ7WrneT~&-^ED_)>2;@)A`qmofcSLi`tp5`V71<A~|6
z6XO4H2=Px~{&y$(k67$OKVZQ0dzfv*t;Mfp@rM@|7N67RM_Zxt2c|!j`F{k-Kk~Mx
z`zthC#Q60r{_x`E$?;e2b>Cl<2>zcCg8z1aJpRDq=Rvb!j9($xKPm+K8(8~+=g&uX
zTXDOsQ27JXuVh0-jNioGKY{n(RzLpbbgTf3UnBUR5Q6`hJ~bWFuja$#*5ao=N1y+|
z_3QX+?#>UleoUX5j``m#w7&r%w7(MOKkQ%j%9ig7RJ~lr^ar1y@q_laCWQ9K%lA5B
z`n`A@$M_Y@|86AXN89{+-TGzRKd&R^e~sY($07J1+lk&k!u-+c6VKm+*#Y|9Y=|kM
zd>BLSKK``zzC`yD+_>&J-BU4s32VRb{$i)jLqBt8yW0+V8-(~Zgb+VWpPG)@uja#K
zjGrLXU%f~Dxt9GrJ^$hS`78wgqtBvzi2to2#NX8>mqg5em#nTy7~jwQhw<;1hu_iU
zN+yXIKShZD%2QiDf3ULuN;;;$N@)LSUCi5mGMhhv=Z7zLD|ivJ1=Ek^SJN?mki`$?
z?>hG%|AxxrGRDth_5(kyb6_gZuO2ae4T~Q<xyg9`to167%NU>IUdPtrmk9pP55fNm
zA^urY%;WFnH^(vm<5>Rz@qhet^Z1tw{%3^XKex~8h}rMO<2c5z7UF;9W#;j(68z5!
z!T%<q{lC{eu-CQ!TIN4If8O}cr^fwP9g9DVUkV~Hf72k$-#ik+{7nP%AMRfVUO%eE
z@f&Z8p&YUH`&Y|qEq=4m{&zl8yB)Kqwe(~9)O1XLBWr&!fAxI`^H*_W==clPKUveO
zEnEg&f2e+8{_5$yaQ-U#5PJUs@jL2?=67A4CyAK<SbjDA@5+y5{=@j~x4vVI=ig%v
zcjEVR2<=ae6DDKvYZBVu^C7gq1i}A}A^4BktEOZ2tNAdwwfHH5|26+W|KnKuh4%mX
zf}-K3@ec~|doGmtRnz_#z8@((Yv`k<`my|KdTX_xQo;Y1LhwIHh=0~X^Z2WNVlw7`
zv=IMYA;iCe`4977AAK<OB2)cXel;DlKUIj|&@A)#C5)l%556B*_R&=1=NEn<e$NK>
zzV@5U{D=4NyIhrjh8lM+WATrk<D9?Q!+(02=U0yyU(JWf|MIcO{Izr}eo+rP<Cn}i
zUpHc<VSFsVnvU`POh4RztvIdxXO+igjL&heV{7rFhtT*z|Chewx(_isF#U}&^!(YM
z5WoBR?Qcx^SbjAf)34^k<o~PuVs`z2`ip8@Z~Xpm9P9sK{{E%M7JnY@_>~Fv&uRCh
zvHb~x{W107x4%-b|NI1V`>}Yd=~(+s7W^OCK0oaBSHt{=`|k^S#eAgN&1KB~X5s$t
z)bH*#zJKNAdmS<T^~`?gzoRxL8{41C;t$Wym(4A|6|)1=kL6d>F@BR^{~;mRpUmdp
z!TxJPus^D^bNv`J^RrE=-CV}(4+`z~TmPNwcz*SW@zs2ojPd<~{kuc3zeKRVx>xw^
zPiFSR#NP*>Jo{f$|5JtMFUJ&rxZISF<yX_O_-6_Be|_X67{<H)Fn$?}KRiDg`NV=>
zT*)L6<Cie~@cf{CM|Ajt@++8r`2M`z&TSh_^<(+fbj<#8!T!TSuwT`K$(a5iYd_$B
zhY0vz#o`b5zYi`Sm||+b&rip%`x4@A@;COw{KxXE>3>&#Eo(pU{OhohHO9~16Z+8j
z!TL?pewlEa>Nl5L%l`&uKa4-Nd_83c*QXva{ZW2uKfJ$tSM@t#x4&7i|D6!*j~47-
z83Fri*!c&~pDHdI0JkBoKP>(+ej0yx@%-)z7=^h1Fur?kJ@xO(FJb*B#BW6i@$>tg
z_*MJ^<5$Pp9}FC7{EZXznx`pP{l~KS!TiPRQDfVf^0EACI;LOEhshW}bquY4@c;cQ
z&F4QceQG+UKPc$`AO!s-0{^2B_+<irTL}DWHvbRTzg>s!&Qks6GUh+Wy^gKLPZi!@
z9GLN79cD*s=`RuV?@Tw>Um@^+2!UTC@P7({kHt$($Kux@=x>gIe%}l9{O>^w-tIs0
zF4b->WA=00>xl6y#!&rm{hBdmVJub-#>euj=@`FGIDf}qblZ6<kINXJ<6cLMA9E<3
z|A79ZZ3Ohk3HlF-fc_+=AI9J3|FRmUAzXi0{9H4;Bx3wjrXS|-PTI4yw+q!u!uVKz
zH67y@GyO2|ePG)5Y?a4ljL&heBgQWi^skA4{z^grLlMwlBj|r50{ZKjerWhT=3MkR
zR*zWyVfoc`j30M2?SG*CZ=JFZZlhd(7~eIsOJZyBlbHQ*{@gXk{QWf-Q(coV`%?w|
zcSk^fv7o;q0{Y7Y{i`CNzmn;P^Jm>7^Dc6&Jd%jjAC_ND$M`i&Kb$|uE$cE<<#8F~
zbKL6)d~$LQQ1d0<LB~(<{B=x0ZLNxPneqE@nI9V%ALhT$`LXC4o~|Alzn7XGeJ9lq
z@2|D_;_~?_&Sl{L|NNN#Bh@kzn11m8nf#XhSGguK(+|}w{i2uB{u9P8w_f^fi|vop
zpZ0vBiP;apOOLkCl?oRG&`;(Vx(i9xpUGszZjBv@ly-j0{u6$T$}bW4OL9E<+W4$a
z;9r;9GGEngB4h2RL72aJDTMi(I6sXa%-_7d7tY^AcX8U^mVuc&u$W@;i)a2@^VfU6
z4*UFd>fJQ{aQ`>&{LfD^wLezyf7&2(|C30M2<H#@-}ATd`=21#-y_c4{sg~c|5p*P
zKZV&39pmy7&WFo@>kn&xP3-)Infv|Udyaff?f%2~?z#0;j2{&2-#X9Se&2c;f3Sb{
zZgcxf1^v5kG}j+3=r11heAwexc9wJg-W$U6ha^AclWU`I)n54gp@P*P^dZO3Gk^Y>
z%>0MvpGDo1!ruQ@3-+%M!TuD%{$C<sf1P0e<!714KUJ{*xgOz<zc0qQe(#f-VtoD1
zV)n!JYs+z;7`LAoLH~@)%=HHa{k@XS^%JxI(huvu;{^K)tIh2%_B+?lu~&rOen0EK
zVf@qP;DN@^ze||?(0}>{qL<%RyZ;5Xf8~ePAM+pXe;WMlld!TdeyN|<AB^9>i(1&m
zl#k_C(=q*OK1{~=34;Hhhv0vi-|_#az0m(8;r#tRFs#M<U$@wnGykFgd-}Mih~)mm
z;$JV!UqzjJQJFit_2!S71pNm^Kz~#$z5YPQ(=Gz~{eu2OBcMN?>4%Ap$M5U<M!4%g
zndyh`Pye{=v611{pC$PJ>A-m(hg(0UPff?p-x9(8?GdoQT+qKG0{W{2{a;2ve=XAw
z?>}F9a{3Up-nfj_AIH6pt;KI(_QU+erub_nV0K{on;9Sa&&sOTZ#U&*`PFnxfAld<
z|9yW1^v4SN*F->nf}sE52<T5?`r-O<>xh^!YQ1q8t3Qr=9Wj28>F+=a==bDznOHd(
zAIq<%WBgL4AFf|>e(teQ<#8F~bKL8Q@hb%Vb0eU?TF^f)0{Xq;#&Ilub%OnA5wO3J
z>4*L^cks=>aeLJxX1|&blTrS$wEu+u|L#qTE;i<41SK8QAH(#6|81X{eSt!=MT~D}
z@c0Ac#|iq|ML>U&puc?t^rs5?J48T#G1Cv%k5NzTx(cgCtp2e4YC6U*WBQ@}KXPzh
z*xP@l5dYz)jlWT~o6DH}9QQh6{2D?3hzRKSvYX?W{ZZ`sB|JZfIeWt%o?ks;d^H~?
zw-!HDnEzRvYCiu{;dkb5Paa@C|AYCfreppW3-*snGq*qf1bY2}@zYtyfAE#6m&=&`
zO26ZO+kxi(mofX{{Qu(cb?<R~>JihQ%;qoQ`Df<Z-@-nBRw>v&a-_Nase=7ayc2%=
zYXtk}<eJ-G!JfZD{OjBP9`^VLS^VJp*&}W<|9-a0PuuUlgnv#P`49PF?GMSWCI4UL
zm$3N5^P{0x4u)Z*>ksq4+E3#T&yNPLfv>RLe;D6Ax1RcU<(CQZ8y-UZYWz<8hW-QN
zr`NQ53ReFWEdKEPZ{&_$#?Sw1S^VMo--OM{(2cnMF#WEXT@wGU{3;=SCx;NfIzMf{
z5WmU)!1&b*<F~RiQx>~ay_JO3e?5yIJbygvm`{!}<zxBPbWDGfV1LJX=Jq%EY5jx!
z4H2+Esw*A;!u;h&A=uw2*uUo3@W<cJ?1%Al+hP6($iel8)t_r-mqd(T!_I#g|CQD)
zOn0GLNf;l?ucl-Cc)|ZOXPf(9C)oe~kKwmJS+M`YYs~F$5bWO*n-%u>R|)T5jtpV^
z(&Tr>FUS7_$1nB5{7-xY=6{+5{i7nFKdL|Ne_{Ud!uvlle*UTU6PS$kAAY7E`p;2Y
z!ax5W&-BBMQ~8Q3jOX8@dOPE%&7bc0&eVS_znYH4FIlkv_7Ln>^<XllKTFVmM+Ed^
z_NwWa{Uw6^|J@7iFK70{`MaR>*RZc2S;h3j{N<)Ue>p>qJD0KebKL8Q@oNSD{YO3;
z_Vp_o1pU1tpubtre^dnYM<3^0KaP%o{#d3T-ap##VM8L;j<EKF<yX@&ege}E*RK!f
zhyVFm3eykQulRBO%T>F%jM>j|uOr3}3i?MzK!2&A|HKIBuMqT~90C2+Oh5Ghr`$OG
zEvz1~`or?8=@`F`>4*FG4L`2#q4Kzl@j32w#Q2R&KU{w*HvAs;>yK}M^Zf3f2<VRy
z^skJ7{y0JZeG$-~#Pmb|SCf);E!K{(_JieD(=opP1v>ukN(jSFICQeg<1)tQxYrTm
zr!xQH{NK|*DFG`7<74^Nbc|mt==W{Ce3i=MGREh)*Ae5F3Hs04bJC4iIT#<yucl-C
zN~RyiAJ??K?Prz8WsJ{puOr6KV)Iwgq<~Lr@6y(H;N@ccW<PDe@cxK@dEc<V|6d~5
zpYe*h{k~p~{VPJSzg*Bi=v8z5QG)(OrQwfX6|*0%zt3HJ+G1Yc>Jh8|Xl6gm|Ch~q
zGwjbVY6bf{Jz{Quj9~w#7lz;dX2Jg9pPSq77wq5n(eT?J-Hnc4p#PX~-EBS9cEe??
z{lqf+q5rsIQqLVczk0;@YCcSEEq*NXAI_h1;vX1qsy~kT59iOw{RjVI%E$7n>8<5|
zg5dw+5d4o9{6Bdw^gqb_hx>=I9o|J>fWhM5w4Ppn4kG-zsGE)7-z^pNzYv0c-;<91
z=?9tXSKApTWBykN_Fv!8JbuxF{YSJ7zx~zBez<?=anS*1n)>f&_O~U(_fLJsxc|WP
zsp(k!8wLAw?=iPOPO$&D-0<7)>rSsf5dZ7nHMhTpJ^zIGPhM$me**I#-aqQNAaSA^
zcP?Y`Pv}L@KX`w}Kjpvs^8D%%<E!~FxwZH)EdFr)e|_yS+WLar9!!4{^B=DN2QPl)
z2cBO&Vth3pCbt$pPVoQj5d2RT{O=e6|NUFLTI-jQ$B@3SpZ}nk9QK14R{gh|l@5Qy
z4~t(7yMOIM@?84qGcQ<~UH-%PRby!ThxdQW#>9ku|Dt-~{=56>hZ=vsQp4<r3xC()
z`=8|Ex|M|akL6d>F@BRUf6@Q=v2Uw9E@S*UW<RXodG3}oH}L%G5#y`*Fd5@V4W#`y
z%zxzn@>7*5zk%5g@ejWHRh}sy%de(m_WPOrF#ek!xNC*V<1)r?V)n!Mui^B$ex6@F
zVth3pCZqhZ&iHS`*kxgV{u#~m!}WLZ?%pSu+Mh)(JaFxS>qol{H<M_(|1kgKS^dHD
zxBHJC{e(Lk@Bgs;YC5Jrndt`~(%L`vrpn_o#^<=#v9<VF!uk7akEd2)cC?oMIM#mP
z`-QdN{|Tp|>#w!+mk8(oySHpv=Bk_|wwC^6!T%n<&M*vi{bBlp?EHa?ez)E`|8ymj
zM2wH+SJN?mDzhKP&nNHq+!&R|WsG0U?6=-O|EBwIJimIx_-Z~(#`q<I{in_D8*j=l
zV|=UsU$H+t26Fvj`du@-Bx3w>q5b~8V2|<mtBTnV<F|b$jt=|vql(!N4ga}aXMX77
zx|M|akL6d>F@7!656{o;zJBI|Dv!$;pW|LfjNc&mfAGWM_rF=t-)(Z^R?H8~ek{M5
zj`5=hIpfEVJ8daZd0fW$9QQh6{8*+R>i_(WyS~TD!T4ByH67z82>K`9vNG)V&nbfb
z%G=H`)*obixNu*-eQKlXH<vO0Iqr4D_@#pVe|BB{2UZTo$MUP`7{7w)hx?yhFV777
z_(`=BlQH|Nnf-A8zcS^p(WZPXznYHeSMy==-<6*<lJ;M4|8d`t%1=%0Pi6B@z<+Vr
zpe9p(MGC!tg71I&Zuy?<=HdRs;+M?kKY>5)jV1THvs-Wci0M<)G5doLIPpJbsCoR0
zh4@bxZXW+CA^!J;5dTym{x9x@@lO@n|4$*rzf6dK#}Vf7uM^^*UuWL_gF^hv-rW1z
ze<^GKaQ)qU;{Mas^M=dV`BTZ_5B&RHnPWWuZesC=`=7Z(pWnjusYgtI35!4Qhd&!L
zN9A!D<8$2W*joHz*8U-WJp<<PuNUI~>o?}{_nqO)|2=fNdHl<S_%Hu#?~8wh(Ebx{
zHjjUk5dUty=Nh+vzYzb|uQrc=g%JPBu3h)K_MgD~hxwl~eFKMJ=OK3fRWbiz{=fUH
z7yWL^FOH$@ALftFZe0G2DL<tb<+mZkt(cJnYXQPkO6h-BejR&$4)Z_XZ!=%NM{=?S
z0rNk#7mYtWI3ImJUI4}~WBo6@zjgSg6=A>sEMe^r-v8QOevI+>yN0!Yi2u(Kh<}z4
z|8XJ2znb;G5dYgE5dTsk{+YL%$G=YKe|m(_{}8wT(hqCDK^A}Lf8NJ35e$Rsg!s?j
z9RBuSCd5DPKj!go5c;1XpN7BxDemL+KP4fw|3(&nxPRZ8euwe>|6gi6E!2N9yZ*xc
z`)uEK<Nl{X=zroP5r5YHq5oeNLi~MeocsU&%flc4R3ZNNA7vi@CZYd1BLe+TiO~Oa
zfldhdVf{~x5dTRV!XN*j5dT+GLWsZ6{~Yr}`1_wyq5Utt8VNp0#^N8x;t%t;rKP_;
zhn0ZwvHWT}#xG&<hw;m;U(9-1<#8F~`<|lxFYpINApT{&oc{m95aQ4M^E#sbdl4Dl
zTKs4he|Z1mhD)}?G=}RB(_h8vANZ4R_`sN7&f*X6FI>O!8RPdC%Gvk>_@_PkxG~?=
zS(il2f0wMTN&oU)!{YM===lfp2a|VPH4Mpx_J1|3{Q>`yeU}=~KUA>x2lEGWH-Bcl
zeoqB!f55-~>pJ842h3kJ{onSZM#N0U;^$}mAGDttA+*0bq5WMJLi?)}+Fx1-?XOa3
ze>eQw{?JB&)jvv5fY##sd(itAm_Hf+)U~q}wYG@quVU>7=ASy2c7oS%U4IxqiH#qv
z_gBB@JKU8_5;1-iYk%<m?tfQ5wA+-A<yX@&{c1i;#`p;@(CZIz!*}Y-t8O&qWBJu|
zOuw2BlQDj(P=5<UsJ}Yl{g1;hx_6$b{%WEASMP=O-zdDl^TFpok2Uol%de(m^{3{;
z<W}Ry(f$YCU#h?LjjpEpi-r6DV7Jv_U;m<kU4LQz>$}Il`Jbu%F@pcw*VY;PkLgp>
zTdV%cg!umuLj2<d{}24t-2XT>euwx6pD>TV8YfI{t@tG||6%^b|DV;y{a>XJ|EIf$
zzx`wJQq!^cB?$F*Vzqhwr3&#I-(Vg;)lN*t?5}u;Ucce{x1x;~?;!`63h)I}{@VAC
zkoT|rF#R>G{$b)HYsc_Yv9d6JF^eC(fBgAf-y6Tbn#}4C-k;g^;g2ty>aSw)gZZ0F
z{LeO%gB8DuFvYJ-@c*{i!;dz#zg~#{lTjm#<B#c6)3N$X72==d`^h-|m4g45tiAg+
zRWFw@{T%l?widrqc>n2x(dO~55&Dk<LKuH~`OR_6|9V0Hn3?ANR|%_sm_Jw^!u>zD
z&+CZUU&F@VF#mK*2>1U@%zqgFZQ2XRzfpso@$0(n;UB*@vHl0{-($}B+W7qwKeHeD
z|La5O|7uzN!~Or~ee>@i2iG6geq1xVBx3w{W<QLd9({j~@%NK8!uvb_2_b$irn)9!
z_SXsV%j#zyzht5Py%NIxQ<lKrZ;|=<yI!z==+Wl(y9Uc85sP1mVE@|@xPK}W#;^Xy
zPmJ&X$_4wIo6Y0z5-QguEPnA1I`1$1lv{3m|6IlFhyLTuW4exVRZbEy{S`v|^4m2S
z#}Ct|repfme3*>!YnlJh|2#cm*2AX!WFh{CuQHE6rcX`B?5`5ye^Y{a{2Q46@cr!h
zKWD$9>g6(~pW|LfjPIXA@4w*w;h75a=fBN@{nza@x4(h)e{j>X;kkdG|6=us)nDuo
z+W$cNiQ0ah@%!&J!uYqL{rSevUom^tbj<z)!T#H)TyJc@st1!X{aAiA9pk46_MbE<
z{Pt(D{tur2RNpmhgladJG5dpp{T+IKv6bgnj~Ks+oxkw>XxH5E?_XUi*xxS%`&B<N
z8S}qF(0^D2^kep_>6ra$K1}|*^5cc)uP=r0{I$9lz5c=d*Uce3f5qaZrepET670WW
zgZcC08o~a+mFCZnRXZ^mv%iGd5ARR+`@PForu;be{sugMSao|~r70iFucl-6mkah6
z`(uplj~2#%yEcU1{wl%#+h>{EpCH7)%ManVKbh%=`M39eHh+JtmbHJFKilz<`TJjL
zJHceE{b2dk^w#1xu=<DV|GXJz)u?*8jOnjq@q_F49UVTug6CI{7+=kY$$wXVvk<>P
z2=S{I;&<0SFn-ZT(EAUVKYeub!zrfq-@xJr*WXM2GXfq1y8iyI?Z?$vmqg6|SRsDv
zLx^9a5WnUB!1$%G_`&nrS2t|v?Gkz`35&m<UBBV^YszEiRhaUz{AxO;KPcEg>1lKO
zQ`z+s?0-K3_N#tkGUk7&;D48A%>54v{;ysa{`#w6_QU+kWAig%8q@WM`5$EMuPtHa
z4?4n?3yByXB`5&KuM_M)V41o7B`p46{|nQ@Z-1j;|ItsG+g~Qwzhim$?e`r?ub(h}
zOAlfE(bS9Hzry(Ko`2x@Luuxyh_!!|paB2!m4FzESo}(a`O9ZQn7?cm<{y8H!2IK1
z4Fl$Xx$ykz&!UPFtUQeGOQq*O%%5D?v2mm^A0sH~nErb9{2%6j{vUg90^d~8y^mi3
zp)5*3mLeh%L8_nx1gWe+1d9R&MXVbH6)Y|g_M)Oe77L0-){0w1Uo8R>kfne^P?oYu
zK!xH)M8PT|0k@(;|8tVL?O`(K&7J)Ixuq}P`}yc)PUgAKbIzQZJ9q9RoiIjSzr|Ui
zzo-=S`%wIQj#bxhL;AN}q#pke+JE)MSEm;UVJ|LH@po{3nEyTS*@sPw0m45hyikoS
zQusU`KbU_vEmGI-bVk}A^so5SeEmVBKdp6<a{S#$|K4UFnI3;H=ZE#PS{KIg{*LXK
zhq(u=pEdgP^K<U|k3JN?I&s7=3B|ARIT*h}-hUv6zFesO{*l299n|<^2+S%a3ZK-j
zWd0tE!+#6UADF*i`mp)$PfI&~mc^0y!Th0RTJ{7=57mBtXUY6w$qxtGsp6^nqMhPT
zLHa+4Lw^A2Z+S>vza8;E)k8ggLB#)W9Q<OOs4^8lEAKxre>n2(m&)(oLR>%0AI9y?
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%0DX<_+)>`SixlKVfe
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
T{P!OI^-p}~Uww|%SLy!;*Tqt{

literal 0
HcmV?d00001

diff --git a/src/function_algebra.hpp b/src/function_algebra.hpp
new file mode 100644
index 000000000..1becba2bb
--- /dev/null
+++ b/src/function_algebra.hpp
@@ -0,0 +1 @@
+404: Not Found
\ No newline at end of file
diff --git a/src/mass_spring_function.hpp b/src/mass_spring_function.hpp
new file mode 100644
index 000000000..1becba2bb
--- /dev/null
+++ b/src/mass_spring_function.hpp
@@ -0,0 +1 @@
+404: Not Found
\ No newline at end of file
diff --git a/src/matrix.hpp b/src/matrix.hpp
new file mode 100644
index 000000000..1becba2bb
--- /dev/null
+++ b/src/matrix.hpp
@@ -0,0 +1 @@
+404: Not Found
\ No newline at end of file
diff --git a/src/newton.hpp b/src/newton.hpp
new file mode 100644
index 000000000..57d4ebd05
--- /dev/null
+++ b/src/newton.hpp
@@ -0,0 +1,41 @@
+#ifndef Newton_h
+#define Newton_h
+
+#include "nonlinfunc.hpp"
+#include <inverse.hpp>
+#include <lapack_interface.hpp>
+
+namespace ASC_ode
+{  
+  void NewtonSolver (std::shared_ptr<NonlinearFunction> func, VectorView<double> x,
+                     double tol = 1e-10, int maxsteps = 10,
+                     std::function<void(int,double,VectorView<double>)> callback = nullptr)
+  {
+    Vector<double> res(func->dimF());
+    Matrix<double> fprime(func->dimF(), func->dimX());
+
+    for (int i = 0; i < maxsteps; i++)
+      {
+        func->evaluate(x, res);
+        double err= norm(res);
+        if (err < tol) return;
+
+        func->evaluateDeriv(x, fprime);
+
+        calcInverse(fprime);
+        x -= fprime*res;
+
+        // LapackLU LU(fprime);
+        // LU.solve(res);
+        // x -= res;
+ 
+        if (callback)
+          callback(i, err, x);
+      }
+
+    throw std::domain_error("Newton did not converge");
+  }
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/nonlinfunc.hpp b/src/nonlinfunc.hpp
new file mode 100644
index 000000000..1becba2bb
--- /dev/null
+++ b/src/nonlinfunc.hpp
@@ -0,0 +1 @@
+404: Not Found
\ No newline at end of file
diff --git a/src/timestepper.hpp b/src/timestepper.hpp
new file mode 100644
index 000000000..1becba2bb
--- /dev/null
+++ b/src/timestepper.hpp
@@ -0,0 +1 @@
+404: Not Found
\ No newline at end of file
diff --git a/src/vector.hpp b/src/vector.hpp
new file mode 100644
index 000000000..1becba2bb
--- /dev/null
+++ b/src/vector.hpp
@@ -0,0 +1 @@
+404: Not Found
\ No newline at end of file
diff --git a/untitled.txt b/untitled.txt
new file mode 100644
index 000000000..e69de29bb