diff --git a/CMakeLists.txt b/CMakeLists.txt
index b82d5d429..af3d75ee4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -72,3 +72,4 @@ include(CTest)
 add_subdirectory(lib)
 add_subdirectory(tests)
 add_subdirectory(bench)
+add_subdirectory(examples)
diff --git a/bench/blas.cpp b/bench/blas.cpp
index 979760c96..f7fdc7e26 100644
--- a/bench/blas.cpp
+++ b/bench/blas.cpp
@@ -139,8 +139,8 @@ void bench(sc::numeric_type dtype, std::string operation)
       sc::array x(N, dtype), y(N, dtype);
       /* ISAAC */
       std::list<sc::driver::Event> events;
-      BENCHMARK_ISAAC(y = sc::control(x + alpha*y, sc::execution_options_type(0, &events)), 3*N*dtsize/t)
-      BENCHMARK_ISAAC(y = sc::control(x + alpha*y, sc::execution_options_type(0, &events), sc::dispatcher_options_type(true)), 3*N*dtsize/t)
+      BENCHMARK_ISAAC(y = sc::execution_handler(x + alpha*y, sc::execution_options_type(0, &events)), 3*N*dtsize/t)
+      BENCHMARK_ISAAC(y = sc::execution_handler(x + alpha*y, sc::execution_options_type(0, &events), sc::dispatcher_options_type(true)), 3*N*dtsize/t)
       /* clblas */
   #ifdef BENCH_CLBLAS
       if(x.context().backend()==sc::driver::OPENCL)
@@ -171,7 +171,7 @@ void bench(sc::numeric_type dtype, std::string operation)
       sc::array scratch(N, dtype);
       sc::scalar s(dtype);
       s = dot(x,y); queue.synchronize();
-      BENCHMARK_ISAAC(s = sc::control(dot(x,y), sc::execution_options_type(0, &events)), 2*N*dtsize/t)
+      BENCHMARK_ISAAC(s = sc::execution_handler(dot(x,y), sc::execution_options_type(0, &events)), 2*N*dtsize/t)
       /* clblas */
   #ifdef BENCH_CLBLAS
       if(x.context().backend()==sc::driver::OPENCL)
@@ -234,8 +234,8 @@ void bench(sc::numeric_type dtype, std::string operation)
     #ifdef HAS_A_BLAS
         int_t lda = A.ld();
     #endif
-        BENCHMARK_ISAAC(y = sc::control(AT?dot(A.T(),x):dot(A,x), sc::execution_options_type(0, &events)),(M*N + M + N)*dtsize/t);
-        BENCHMARK_ISAAC(y = sc::control(AT?dot(A.T(),x):dot(A,x), sc::execution_options_type(0, &events), sc::dispatcher_options_type(true)),(M*N + M + N)*dtsize/t);
+        BENCHMARK_ISAAC(y = sc::execution_handler(AT?dot(A.T(),x):dot(A,x), sc::execution_options_type(0, &events)),(M*N + M + N)*dtsize/t);
+        BENCHMARK_ISAAC(y = sc::execution_handler(AT?dot(A.T(),x):dot(A,x), sc::execution_options_type(0, &events), sc::dispatcher_options_type(true)),(M*N + M + N)*dtsize/t);
     #ifdef BENCH_CLBLAS
         if(y.context().backend()==sc::driver::OPENCL)
             BENCHMARK_CLBLAS(clblasSgemv(clblasColumnMajor, AT?clblasTrans:clblasNoTrans, As1, As2, 1, CL_HANDLE(A.data()), 0, lda, CL_HANDLE(x.data()), 0, 1, 0, CL_HANDLE(y.data()), 0, 1, 1, &CL_HANDLE(queue),0, NULL, &event), (M*N + M + N)*dtsize/t)
@@ -267,8 +267,8 @@ void bench(sc::numeric_type dtype, std::string operation)
     MNKs.push_back(std::make_tuple("ConvAlexNet3",'N','N',169,384,2304));
     MNKs.push_back(std::make_tuple("ConvAlexNet4",'N','N',169,192,1728));
     MNKs.push_back(std::make_tuple("ConvAlexNet5",'N','N',169,128,1728));
-//    MNKs.push_back(std::make_tuple("Convolution [LeNet-1],'N','N',576,20,25));
-//    MNKs.push_back(std::make_tuple("Convolution [LeNet-2]",'N','N',64,50,500));
+//    MNKs.push_back(std::make_tuple("ConvLeNet1,'N','N',576,20,25));
+//    MNKs.push_back(std::make_tuple("ConvLeNet2",'N','N',64,50,500));
 
     //Convolution Gradient-1
 //    MNKs.push_back(std::make_tuple("Convolution Gradient-1 [AlexNet-5]",'T','N',1728,128,169));
@@ -276,15 +276,15 @@ void bench(sc::numeric_type dtype, std::string operation)
 //    MNKs.push_back(std::make_tuple("Convolution Gradient-1 [AlexNet-3]",'T','N',2304,384,169));
 //    MNKs.push_back(std::make_tuple("Convolution Gradient-1 [AlexNet-2]",'T','N',1200,128,729));
 //    MNKs.push_back(std::make_tuple("Convolution Gradient-1 [AlexNet-1]",'T','N',363,96,3025));
-//    MNKs.push_back(std::make_tuple("Conv. Gradient-1 [LeNet-2]",'T','N',500,50,64));
-//    MNKs.push_back(std::make_tuple("Conv. Gradient-1 [LeNet-1]",'T','N',25,20,576));
+//    MNKs.push_back(std::make_tuple("Convolution Gradient-1 [LeNet-2]",'T','N',500,50,64));
+//    MNKs.push_back(std::make_tuple("Convolution Gradient-1 [LeNet-1]",'T','N',25,20,576));
 
     //Convolution Gradient-2
 //    MNKs.push_back(std::make_tuple("Convolution Gradient-2 [AlexNet-5]",'N','T',169,1728,128));
 //    MNKs.push_back(std::make_tuple("Convolution Gradient-2 [AlexNet-4]",'N','T',169,1728,192));
 //    MNKs.push_back(std::make_tuple("Convolution Gradient-2 [AlexNet-3]",'N','T',169,2304,384));
 //    MNKs.push_back(std::make_tuple("Convolution Gradient-2 [AlexNet-2]",'N','T',729,1200,128));
-//    MNKs.push_back(std::make_tuple("Conv. Gradient-2 [LeNet-2]",'N','T',64,500,50));
+//    MNKs.push_back(std::make_tuple("Convolution Gradient-2 [LeNet-2]",'N','T',64,500,50));
 
     //Covariance (e.g., ICA, 10minutes/100Hz)
     MNKs.push_back(std::make_tuple("ICA32",'N','T',32,32,60000));
@@ -317,8 +317,8 @@ void bench(sc::numeric_type dtype, std::string operation)
     #ifdef HAS_A_BLAS
         int_t lda = A.ld(), ldb = B.ld(), ldc = C.ld();
     #endif
-        BENCHMARK_ISAAC(C = sc::control(AT?(BT?dot(A.T(),B.T()):dot(A.T(),B)):(BT?dot(A,B.T()):dot(A,B)), sc::execution_options_type(0, &events), sc::dispatcher_options_type(false)), (double)2*M*N*K/t);
-        BENCHMARK_ISAAC(C = sc::control(AT?(BT?dot(A.T(),B.T()):dot(A.T(),B)):(BT?dot(A,B.T()):dot(A,B)), sc::execution_options_type(0, &events), sc::dispatcher_options_type(true)), (double)2*M*N*K/t);
+        BENCHMARK_ISAAC(C = sc::execution_handler(AT?(BT?dot(A.T(),B.T()):dot(A.T(),B)):(BT?dot(A,B.T()):dot(A,B)), sc::execution_options_type(0, &events), sc::dispatcher_options_type(false)), (double)2*M*N*K/t);
+        BENCHMARK_ISAAC(C = sc::execution_handler(AT?(BT?dot(A.T(),B.T()):dot(A.T(),B)):(BT?dot(A,B.T()):dot(A,B)), sc::execution_options_type(0, &events), sc::dispatcher_options_type(true)), (double)2*M*N*K/t);
         /* clblas */
     #ifdef BENCH_CLBLAS
         if(C.context().backend()==sc::driver::OPENCL)
diff --git a/bench/overhead.cpp b/bench/overhead.cpp
index b48356ecb..fe43c0261 100644
--- a/bench/overhead.cpp
+++ b/bench/overhead.cpp
@@ -1,9 +1,7 @@
 #include "isaac/array.h"
-#include "isaac/tools/timer.hpp"
-
 #include <vector>
 
-namespace isc = isaac;
+namespace sc = isaac;
 
 #ifdef BENCH_CUBLAS
 __global__ void dummy(){}
@@ -12,7 +10,7 @@ __global__ void dummy(){}
 
 int main()
 {
-  for(isc::driver::backend::data_type::const_iterator it = isc::driver::queues.data().begin() ; it != isc::driver::queues.data().end() ; ++it)
+  for(sc::driver::backend::data_type::const_iterator it = sc::driver::queues.data().begin() ; it != sc::driver::queues.data().end() ; ++it)
   {
     cl::CommandQueue queue = it->second[0];
     cl::Context context = it->first;
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
new file mode 100644
index 000000000..be778bff7
--- /dev/null
+++ b/examples/CMakeLists.txt
@@ -0,0 +1,4 @@
+foreach(PROG tie)
+     add_executable(${PROG}-example ${PROG}.cpp)
+     target_link_libraries(${PROG}-example isaac)
+endforeach(PROG)
diff --git a/examples/tie.cpp b/examples/tie.cpp
new file mode 100644
index 000000000..4859cfb8e
--- /dev/null
+++ b/examples/tie.cpp
@@ -0,0 +1,17 @@
+#include "isaac/array.h"
+#include "isaac/symbolic/execute.h"
+#include "isaac/symbolic/io.h"
+
+namespace sc = isaac;
+
+int main()
+{
+//    sc::array A(10,10);
+//    sc::array U(10, 10);
+//    sc::array V(10, 10);
+//    sc::array x(10), y(10);
+////    float c = .2, s = .4;
+//    sc::math_expression tree = sc::sfor(0, 10, 1, sc::rot(sc::col(U, sc::_i0), sc::col(U, sc::_i0 + 1), x[sc::_i0], y[sc::_i0]));
+//    std::cout << to_string(tree) << std::endl;
+//    sc::execute(tree);
+}
diff --git a/include/isaac/array.h b/include/isaac/array.h
index 704081acb..c4ec5c144 100644
--- a/include/isaac/array.h
+++ b/include/isaac/array.h
@@ -21,7 +21,7 @@ protected:
 
 public:
   //1D Constructors
-  array(int_t size1, numeric_type dtype, driver::Context const & context = driver::backend::contexts::get_default());
+  explicit array(int_t size1, numeric_type dtype = FLOAT_TYPE, driver::Context const & context = driver::backend::contexts::get_default());
   array(int_t size1, numeric_type dtype, driver::Buffer data, int_t start, int_t inc);
 
   template<typename DT>
@@ -29,19 +29,18 @@ public:
   array(array & v, slice const & s1);
 
   //2D Constructors
-  array(int_t size1, int_t size2, numeric_type dtype, driver::Context const & context = driver::backend::contexts::get_default());
+  array(int_t size1, int_t size2, numeric_type dtype = FLOAT_TYPE, driver::Context const & context = driver::backend::contexts::get_default());
   array(int_t size1, int_t size2, numeric_type dtype, driver::Buffer data, int_t start, int_t ld);
   template<typename DT>
   array(int_t size1, int_t size2, std::vector<DT> const & data, driver::Context const & context = driver::backend::contexts::get_default());
   array(array & M, slice const & s1, slice const & s2);
 
   //3D Constructors
-  array(int_t size1, int_t size2, int_t size3, numeric_type dtype, driver::Context const & context = driver::backend::contexts::get_default());
+  array(int_t size1, int_t size2, int_t size3, numeric_type dtype = FLOAT_TYPE, driver::Context const & context = driver::backend::contexts::get_default());
 
   //General constructor
-  explicit array(array_expression const & proxy);
-  template<class T>
-  explicit array(controller<T> const &);
+  explicit array(math_expression const & proxy);
+  explicit array(execution_handler const &);
   
   //Copy Constructor
   array(array const &);
@@ -63,36 +62,36 @@ public:
 
   //Numeric operators
   array& operator=(array const &);
-  array& operator=(array_expression const &);
-  template<class T>
-  array& operator=(controller<T> const &);
+  array& operator=(math_expression const &);
+  array& operator=(execution_handler const &);
   template<class T>
   array & operator=(std::vector<T> const & rhs);
   array & operator=(value_scalar const & rhs);
 
-  array_expression operator-();
-  array_expression operator!();
+  math_expression operator-();
+  math_expression operator!();
 
   array& operator+=(value_scalar const &);
   array& operator+=(array const &);
-  array& operator+=(array_expression const &);
+  array& operator+=(math_expression const &);
   array& operator-=(value_scalar const &);
   array& operator-=(array const &);
-  array& operator-=(array_expression const &);
+  array& operator-=(math_expression const &);
   array& operator*=(value_scalar const &);
   array& operator*=(array const &);
-  array& operator*=(array_expression const &);
+  array& operator*=(math_expression const &);
   array& operator/=(value_scalar const &);
   array& operator/=(array const &);
-  array& operator/=(array_expression const &);
+  array& operator/=(math_expression const &);
 
   //Indexing operators
+  math_expression operator[](for_idx_t idx) const;
   const scalar operator[](int_t) const;
   scalar operator[](int_t);
   array operator[](slice const &);
   array operator()(slice const &, slice const &);
 
-  array_expression T() const;
+  math_expression T() const;
 protected:
   numeric_type dtype_;
 
@@ -108,7 +107,7 @@ protected:
 class ISAACAPI scalar : public array
 {
   friend value_scalar::value_scalar(const scalar &);
-  friend value_scalar::value_scalar(const array_expression &);
+  friend value_scalar::value_scalar(const math_expression &);
 private:
   void inject(values_holder&) const;
   template<class T> T cast() const;
@@ -116,7 +115,7 @@ public:
   explicit scalar(numeric_type dtype, driver::Buffer const & data, int_t offset);
   explicit scalar(value_scalar value, driver::Context const & context = driver::backend::contexts::get_default());
   explicit scalar(numeric_type dtype, driver::Context const & context = driver::backend::contexts::get_default());
-  scalar(array_expression const & proxy);
+  scalar(math_expression const & proxy);
   scalar& operator=(value_scalar const &);
 //  scalar& operator=(scalar const & s);
   using array::operator =;
@@ -154,14 +153,24 @@ template<class T> ISAACAPI void copy(array const & gA, std::vector<T> & cA, bool
 //Binary operators
 
 #define ISAAC_DECLARE_ELEMENT_BINARY_OPERATOR(OPNAME) \
-ISAACAPI array_expression OPNAME (array_expression const & x, array_expression const & y);\
-ISAACAPI array_expression OPNAME (array const & x, array_expression const & y);\
-ISAACAPI array_expression OPNAME (array_expression const & x, array const & y);\
-ISAACAPI array_expression OPNAME (array const & x, array const & y);\
-ISAACAPI array_expression OPNAME (array_expression const & x, value_scalar const & y);\
-ISAACAPI array_expression OPNAME (array const & x, value_scalar const & y);\
-ISAACAPI array_expression OPNAME (value_scalar const & y, array_expression const & x);\
-ISAACAPI array_expression OPNAME (value_scalar const & y, array const & x);
+ISAACAPI math_expression OPNAME (array const & x, math_expression const & y);\
+ISAACAPI math_expression OPNAME (array const & x, value_scalar const & y);\
+ISAACAPI math_expression OPNAME (array const & x, for_idx_t const & y);\
+ISAACAPI math_expression OPNAME (array const & x, array const & y);\
+\
+ISAACAPI math_expression OPNAME (math_expression const & x, math_expression const & y);\
+ISAACAPI math_expression OPNAME (math_expression const & x, value_scalar const & y);\
+ISAACAPI math_expression OPNAME (math_expression const & x, for_idx_t const & y);\
+ISAACAPI math_expression OPNAME (math_expression const & x, array const & y);\
+\
+ISAACAPI math_expression OPNAME (value_scalar const & y, math_expression const & x);\
+ISAACAPI math_expression OPNAME (value_scalar const & y, for_idx_t const & x);\
+ISAACAPI math_expression OPNAME (value_scalar const & y, array const & x);\
+\
+ISAACAPI math_expression OPNAME (for_idx_t const & y, math_expression const & x);\
+ISAACAPI math_expression OPNAME (for_idx_t const & y, for_idx_t const & x);\
+ISAACAPI math_expression OPNAME (for_idx_t const & y, value_scalar const & x);\
+ISAACAPI math_expression OPNAME (for_idx_t const & y, array const & x);
 
 ISAAC_DECLARE_ELEMENT_BINARY_OPERATOR(operator +)
 ISAAC_DECLARE_ELEMENT_BINARY_OPERATOR(operator -)
@@ -184,15 +193,32 @@ ISAAC_DECLARE_ELEMENT_BINARY_OPERATOR(outer)
 
 ISAAC_DECLARE_ELEMENT_BINARY_OPERATOR(assign)
 
-
 #undef ISAAC_DECLARE_ELEMENT_BINARY_OPERATOR
 
+#define ISAAC_DECLARE_ROT(LTYPE, RTYPE, CTYPE, STYPE) \
+  math_expression rot(LTYPE const & x, RTYPE const & y, CTYPE const & c, STYPE const & s);
+
+ISAAC_DECLARE_ROT(array, array, scalar, scalar)
+ISAAC_DECLARE_ROT(math_expression, array, scalar, scalar)
+ISAAC_DECLARE_ROT(array, math_expression, scalar, scalar)
+ISAAC_DECLARE_ROT(math_expression, math_expression, scalar, scalar)
+
+ISAAC_DECLARE_ROT(array, array, value_scalar, value_scalar)
+ISAAC_DECLARE_ROT(math_expression, array, value_scalar, value_scalar)
+ISAAC_DECLARE_ROT(array, math_expression, value_scalar, value_scalar)
+ISAAC_DECLARE_ROT(math_expression, math_expression, value_scalar, value_scalar)
+
+ISAAC_DECLARE_ROT(array, array, math_expression, math_expression)
+ISAAC_DECLARE_ROT(math_expression, array, math_expression, math_expression)
+ISAAC_DECLARE_ROT(array, math_expression, math_expression, math_expression)
+ISAAC_DECLARE_ROT(math_expression, math_expression, math_expression, math_expression)
 //--------------------------------
 
+
 //Unary operators
 #define ISAAC_DECLARE_UNARY_OPERATOR(OPNAME) \
-  ISAACAPI array_expression OPNAME (array const & x);\
-  ISAACAPI array_expression OPNAME (array_expression const & x);
+  ISAACAPI math_expression OPNAME (array const & x);\
+  ISAACAPI math_expression OPNAME (math_expression const & x);
 
 ISAAC_DECLARE_UNARY_OPERATOR(abs)
 ISAAC_DECLARE_UNARY_OPERATOR(acos)
@@ -212,19 +238,21 @@ ISAAC_DECLARE_UNARY_OPERATOR(tan)
 ISAAC_DECLARE_UNARY_OPERATOR(tanh)
 ISAAC_DECLARE_UNARY_OPERATOR(trans)
 
-ISAACAPI array_expression cast(array const &, numeric_type dtype);
-ISAACAPI array_expression cast(array_expression const &, numeric_type dtype);
+ISAACAPI math_expression cast(array const &, numeric_type dtype);
+ISAACAPI math_expression cast(math_expression const &, numeric_type dtype);
 
-ISAACAPI array_expression norm(array const &, unsigned int order = 2);
-ISAACAPI array_expression norm(array_expression const &, unsigned int order = 2);
+ISAACAPI math_expression norm(array const &, unsigned int order = 2);
+ISAACAPI math_expression norm(math_expression const &, unsigned int order = 2);
 
 #undef ISAAC_DECLARE_UNARY_OPERATOR
 
-ISAACAPI array_expression repmat(array const &, int_t const & rep1, int_t const & rep2);
+ISAACAPI math_expression repmat(array const &, int_t const & rep1, int_t const & rep2);
+
+//Matrix reduction
 
 #define ISAAC_DECLARE_DOT(OPNAME) \
-ISAACAPI array_expression OPNAME(array const & M, int_t axis = -1);\
-ISAACAPI array_expression OPNAME(array_expression const & M, int_t axis = -1);
+ISAACAPI math_expression OPNAME(array const & M, int_t axis = -1);\
+ISAACAPI math_expression OPNAME(math_expression const & M, int_t axis = -1);
 
 ISAAC_DECLARE_DOT(sum)
 ISAAC_DECLARE_DOT(argmax)
@@ -232,9 +260,45 @@ ISAAC_DECLARE_DOT((max))
 ISAAC_DECLARE_DOT((min))
 ISAAC_DECLARE_DOT(argmin)
 
-ISAACAPI array_expression eye(int_t, int_t, isaac::numeric_type, driver::Context const & context = driver::backend::contexts::get_default());
-ISAACAPI array_expression zeros(int_t M, int_t N, numeric_type dtype, driver::Context const & context = driver::backend::contexts::get_default());
-ISAACAPI array_expression reshape(array const &, int_t, int_t);
+//Fusion
+ISAACAPI math_expression fuse(math_expression const & x, math_expression const & y);
+
+//For
+ISAACAPI math_expression sfor(math_expression const & start, math_expression const & end, math_expression const & inc, math_expression const & expression);
+static const for_idx_t _i0{0};
+static const for_idx_t _i1{1};
+static const for_idx_t _i2{2};
+static const for_idx_t _i3{3};
+static const for_idx_t _i4{4};
+static const for_idx_t _i5{5};
+static const for_idx_t _i6{6};
+static const for_idx_t _i7{7};
+static const for_idx_t _i8{8};
+static const for_idx_t _i9{9};
+
+//Misc.
+ISAACAPI math_expression eye(int_t, int_t, isaac::numeric_type, driver::Context const & context = driver::backend::contexts::get_default());
+ISAACAPI math_expression zeros(int_t M, int_t N, numeric_type dtype, driver::Context const & context = driver::backend::contexts::get_default());
+ISAACAPI math_expression reshape(array const &, int_t, int_t);
+
+//Row
+ISAACAPI math_expression row(array const &, value_scalar const &);
+ISAACAPI math_expression row(array const &, for_idx_t const &);
+ISAACAPI math_expression row(array const &, math_expression const &);
+
+ISAACAPI math_expression row(math_expression const &, value_scalar const &);
+ISAACAPI math_expression row(math_expression const &, for_idx_t const &);
+ISAACAPI math_expression row(math_expression const &, math_expression const &);
+
+//col
+ISAACAPI math_expression col(array const &, value_scalar const &);
+ISAACAPI math_expression col(array const &, for_idx_t const &);
+ISAACAPI math_expression col(array const &, math_expression const &);
+
+ISAACAPI math_expression col(math_expression const &, value_scalar const &);
+ISAACAPI math_expression col(math_expression const &, for_idx_t const &);
+ISAACAPI math_expression col(math_expression const &, math_expression const &);
+
 
 //
 ISAACAPI std::ostream& operator<<(std::ostream &, array const &);
diff --git a/include/isaac/common/numeric_type.h b/include/isaac/common/numeric_type.h
index 477c480d6..123fc29b7 100644
--- a/include/isaac/common/numeric_type.h
+++ b/include/isaac/common/numeric_type.h
@@ -1,6 +1,7 @@
 #ifndef ISAAC_COMMON_NUMERIC_TYPE_H
 #define ISAAC_COMMON_NUMERIC_TYPE_H
 
+#include <stdexcept>
 #include "isaac/exception/unknown_datatype.h"
 
 namespace isaac
@@ -96,9 +97,20 @@ struct to_int_numeric_type
 };
 
 template<class T> struct to_numeric_type { static const numeric_type value = to_int_numeric_type<T>::value; };
+
+template<> struct to_numeric_type<char> { static const numeric_type value = CHAR_TYPE; };
+template<> struct to_numeric_type<unsigned char> { static const numeric_type value = UCHAR_TYPE ; };
+template<> struct to_numeric_type<short> { static const numeric_type value = SHORT_TYPE ; };
+template<> struct to_numeric_type<unsigned short> { static const numeric_type value = USHORT_TYPE ; };
+template<> struct to_numeric_type<int> { static const numeric_type value = INT_TYPE ; };
+template<> struct to_numeric_type<unsigned int> { static const numeric_type value = UINT_TYPE ; };
+template<> struct to_numeric_type<long> { static const numeric_type value = LONG_TYPE ; };
+template<> struct to_numeric_type<unsigned long> { static const numeric_type value = ULONG_TYPE ; };
 template<> struct to_numeric_type<float> { static const numeric_type value = FLOAT_TYPE; };
 template<> struct to_numeric_type<double> { static const numeric_type value = DOUBLE_TYPE; };
 
+template<class T> typename std::enable_if<std::is_arithmetic<T>::value, numeric_type>::type numeric_type_of(T) { return to_numeric_type<T>::value; }
+template<class T> typename std::enable_if<!std::is_arithmetic<T>::value, numeric_type>::type numeric_type_of(T const & x) { return x.dtype(); }
 }
 
 #endif
diff --git a/include/isaac/driver/backend.h b/include/isaac/driver/backend.h
index 56e80eaf5..6eab6c773 100644
--- a/include/isaac/driver/backend.h
+++ b/include/isaac/driver/backend.h
@@ -64,7 +64,7 @@ RESTORE_MSVC_WARNING_C4251
       static void release();
   public:
       static void get(Context const &, std::vector<CommandQueue *> &queues);
-      static CommandQueue & get(Context const &, unsigned int id);
+      static CommandQueue & get(Context const &, unsigned int id = 0);
   private:
 DISABLE_MSVC_WARNING_C4251
       static std::map< Context, std::vector<CommandQueue*> > cache_;
diff --git a/include/isaac/kernels/binder.h b/include/isaac/kernels/binder.h
index a8d3f510e..5d0b08170 100644
--- a/include/isaac/kernels/binder.h
+++ b/include/isaac/kernels/binder.h
@@ -9,8 +9,8 @@ namespace isaac
 
 enum binding_policy_t
 {
-  BIND_ALL_UNIQUE,
-  BIND_TO_HANDLE
+  BIND_INDEPENDENT,
+  BIND_SEQUENTIAL
 };
 
 
@@ -19,8 +19,8 @@ class symbolic_binder
 public:
   symbolic_binder();
   virtual ~symbolic_binder();
-  virtual bool bind(driver::Buffer const &) = 0;
-  virtual unsigned int get(driver::Buffer const &) = 0;
+  virtual bool bind(driver::Buffer const &, bool) = 0;
+  virtual unsigned int get(driver::Buffer const &, bool) = 0;
   unsigned int get();
 protected:
   unsigned int current_arg_;
@@ -28,20 +28,20 @@ protected:
 };
 
 
-class bind_to_handle : public symbolic_binder
+class bind_sequential : public symbolic_binder
 {
 public:
-  bind_to_handle();
-  bool bind(driver::Buffer const &);
-  unsigned int get(driver::Buffer const &);
+  bind_sequential();
+  bool bind(driver::Buffer const &, bool);
+  unsigned int get(driver::Buffer const &, bool);
 };
 
-class bind_all_unique : public symbolic_binder
+class bind_independent : public symbolic_binder
 {
 public:
-  bind_all_unique();
-  bool bind(driver::Buffer const &);
-  unsigned int get(driver::Buffer const &);
+  bind_independent();
+  bool bind(driver::Buffer const &, bool);
+  unsigned int get(driver::Buffer const &, bool);
 };
 
 }
diff --git a/include/isaac/kernels/mapped_object.h b/include/isaac/kernels/mapped_object.h
index db05af182..e9ce52abd 100644
--- a/include/isaac/kernels/mapped_object.h
+++ b/include/isaac/kernels/mapped_object.h
@@ -22,9 +22,12 @@ class mapped_object;
 typedef std::pair<size_t, leaf_t> mapping_key;
 typedef std::map<mapping_key, std::shared_ptr<mapped_object> > mapping_type;
 
+
+
+
 /** @brief Mapped Object
 *
-* This object populates the symbolic mapping associated with a array_expression. (root_id, LHS|RHS|PARENT) => mapped_object
+* This object populates the symbolic mapping associated with a math_expression. (root_id, LHS|RHS|PARENT) => mapped_object
 * The tree can then be reconstructed in its symbolic form
 */
 class mapped_object
@@ -46,13 +49,14 @@ protected:
 public:
   struct node_info
   {
-    node_info(mapping_type const * _mapping, array_expression const * _array_expression, size_t _root_idx);
+    node_info(mapping_type const * _mapping, math_expression const * _math_expression, size_t _root_idx);
     mapping_type const * mapping;
-    isaac::array_expression const * array_expression;
+    isaac::math_expression const * math_expression;
     size_t root_idx;
   };
 
 public:
+  mapped_object(std::string const & scalartype, std::string const & name, std::string const & type_key);
   mapped_object(std::string const & scalartype, unsigned int id, std::string const & type_key);
   virtual ~mapped_object();
 
@@ -63,18 +67,19 @@ public:
   std::string process(std::string const & in) const;
   std::string evaluate(std::map<std::string, std::string> const & accessors) const;
 protected:
+  std::string type_key_;
   std::string name_;
   std::string scalartype_;
-  std::string type_key_;
   std::map<std::string, std::string> keywords_;
 };
 
+
 class binary_leaf
 {
 public:
   binary_leaf(mapped_object::node_info info);
 
-  void process_recursive(kernel_generation_stream & stream, leaf_t leaf, std::map<std::string, std::string> const & accessors);
+  void process_recursive(kernel_generation_stream & stream, leaf_t leaf, std::map<std::string, std::string> const & accessors, std::set<std::string> & already_fetched);
   std::string evaluate_recursive(leaf_t leaf, std::map<std::string, std::string> const & accessors);
 protected:
   mapped_object::node_info info_;
@@ -100,8 +105,8 @@ public:
   mapped_dot(std::string const & scalartype, unsigned int id, node_info info, std::string const & type_key);
 
   size_t root_idx() const;
-  isaac::array_expression const & array_expression() const;
-  array_expression::node root_node() const;
+  isaac::math_expression const & math_expression() const;
+  math_expression::node root_node() const;
   bool is_index_dot() const;
   op_element root_op() const;
 };
@@ -137,17 +142,14 @@ public:
   mapped_host_scalar(std::string const & scalartype, unsigned int id);
 };
 
-/** @brief Tuple
-*
-* Maps an object passed by pointer
-*/
-class mapped_tuple : public mapped_object
+/** @brief Placeholder
+ *
+ * Maps a placeholder
+ */
+class mapped_placeholder : public mapped_object
 {
 public:
-  mapped_tuple(std::string const & scalartype, unsigned int id, size_t size);
-private:
-  size_t size_;
-  std::vector<std::string> names_;
+  mapped_placeholder(unsigned int level);
 };
 
 /** @brief Handle
@@ -193,6 +195,14 @@ public:
   mapped_vdiag(std::string const & scalartype, unsigned int id, node_info info);
 };
 
+class mapped_array_access: public mapped_object, binary_leaf
+{
+private:
+  void postprocess(std::string &res) const;
+public:
+  mapped_array_access(std::string const & scalartype, unsigned int id, node_info info);
+};
+
 class mapped_matrix_row : public mapped_object, binary_leaf
 {
 private:
@@ -243,5 +253,7 @@ public:
   mapped_cast(operation_node_type type, unsigned int id);
 };
 
+extern mapped_object& get(math_expression::container_type const &, size_t, mapping_type const &, size_t);
+
 }
 #endif
diff --git a/include/isaac/kernels/parse.h b/include/isaac/kernels/parse.h
index 453202fd0..9fc57c1e5 100644
--- a/include/isaac/kernels/parse.h
+++ b/include/isaac/kernels/parse.h
@@ -13,8 +13,8 @@ namespace detail
 {
 
   bool is_node_leaf(op_element const & op);
-  bool is_scalar_dot(array_expression::node const & node);
-  bool is_vector_dot(array_expression::node const & node);
+  bool is_scalar_dot(math_expression::node const & node);
+  bool is_vector_dot(math_expression::node const & node);
   bool is_assignment(op_element const & op);
   bool is_elementwise_operator(op_element const & op);
   bool is_elementwise_function(op_element const & op);
@@ -24,58 +24,58 @@ namespace detail
 
 class scalar;
 
-/** @brief base functor class for traversing a array_expression */
+/** @brief base functor class for traversing a math_expression */
 class traversal_functor
 {
 public:
-  void call_before_expansion(array_expression const &, std::size_t) const { }
-  void call_after_expansion(array_expression const &, std::size_t) const { }
+  void call_before_expansion(math_expression const &, std::size_t) const { }
+  void call_after_expansion(math_expression const &, std::size_t) const { }
 };
 
 
-/** @brief Recursively execute a functor on a array_expression */
+/** @brief Recursively execute a functor on a math_expression */
 template<class Fun>
-inline void traverse(isaac::array_expression const & array_expression, std::size_t root_idx, Fun const & fun, bool inspect)
+inline void traverse(isaac::math_expression const & math_expression, std::size_t root_idx, Fun const & fun, bool inspect)
 {
-  array_expression::node const & root_node = array_expression.tree()[root_idx];
+  math_expression::node const & root_node = math_expression.tree()[root_idx];
   bool recurse = detail::is_node_leaf(root_node.op)?inspect:true;
   bool bypass = detail::bypass(root_node.op);
 
   if(!bypass)
-    fun.call_before_expansion(array_expression, root_idx);
+    fun.call_before_expansion(math_expression, root_idx);
 
   //Lhs:
   if (recurse)
   {
     if (root_node.lhs.type_family==COMPOSITE_OPERATOR_FAMILY)
-      traverse(array_expression, root_node.lhs.node_index, fun, inspect);
+      traverse(math_expression, root_node.lhs.node_index, fun, inspect);
     if (root_node.lhs.type_family != INVALID_TYPE_FAMILY)
-      fun(array_expression, root_idx, LHS_NODE_TYPE);
+      fun(math_expression, root_idx, LHS_NODE_TYPE);
   }
 
   //Self:
   if(!bypass)
-    fun(array_expression, root_idx, PARENT_NODE_TYPE);
+    fun(math_expression, root_idx, PARENT_NODE_TYPE);
 
   //Rhs:
   if (recurse && root_node.rhs.type_family!=INVALID_TYPE_FAMILY)
   {
     if (root_node.rhs.type_family==COMPOSITE_OPERATOR_FAMILY)
-      traverse(array_expression, root_node.rhs.node_index, fun, inspect);
+      traverse(math_expression, root_node.rhs.node_index, fun, inspect);
     if (root_node.rhs.type_family != INVALID_TYPE_FAMILY)
-      fun(array_expression, root_idx, RHS_NODE_TYPE);
+      fun(math_expression, root_idx, RHS_NODE_TYPE);
   }
 
   if(!bypass)
-    fun.call_after_expansion(array_expression, root_idx);
+    fun.call_after_expansion(math_expression, root_idx);
 }
 
 class filter_fun : public traversal_functor
 {
 public:
-  typedef bool (*pred_t)(array_expression::node const & node);
+  typedef bool (*pred_t)(math_expression::node const & node);
   filter_fun(pred_t pred, std::vector<size_t> & out);
-  void operator()(isaac::array_expression const & array_expression, size_t root_idx, leaf_t) const;
+  void operator()(isaac::math_expression const & math_expression, size_t root_idx, leaf_t) const;
 private:
   pred_t pred_;
   std::vector<size_t> & out_;
@@ -84,22 +84,23 @@ private:
 class filter_elements_fun : public traversal_functor
 {
 public:
-  filter_elements_fun(array_expression_node_subtype subtype, std::vector<lhs_rhs_element> & out);
-  void operator()(isaac::array_expression const & array_expression, size_t root_idx, leaf_t) const;
+  filter_elements_fun(math_expression_node_subtype subtype, std::vector<lhs_rhs_element> & out);
+  void operator()(isaac::math_expression const & math_expression, size_t root_idx, leaf_t) const;
 private:
-  array_expression_node_subtype subtype_;
+  math_expression_node_subtype subtype_;
   std::vector<lhs_rhs_element> & out_;
 };
 
-std::vector<size_t> filter_nodes(bool (*pred)(array_expression::node const & node),
-                                        isaac::array_expression const & array_expression,
+std::vector<size_t> filter_nodes(bool (*pred)(math_expression::node const & node),
+                                        isaac::math_expression const & math_expression,
+                                        size_t root,
                                         bool inspect);
 
-std::vector<lhs_rhs_element> filter_elements(array_expression_node_subtype subtype,
-                                             isaac::array_expression const & array_expression);
+std::vector<lhs_rhs_element> filter_elements(math_expression_node_subtype subtype,
+                                             isaac::math_expression const & math_expression);
 const char * evaluate(operation_node_type type);
 
-/** @brief functor for generating the expression string from a array_expression */
+/** @brief functor for generating the expression string from a math_expression */
 class evaluate_expression_traversal: public traversal_functor
 {
 private:
@@ -109,24 +110,24 @@ private:
 
 public:
   evaluate_expression_traversal(std::map<std::string, std::string> const & accessors, std::string & str, mapping_type const & mapping);
-  void call_before_expansion(isaac::array_expression const & array_expression, std::size_t root_idx) const;
-  void call_after_expansion(array_expression const & /*array_expression*/, std::size_t /*root_idx*/) const;
-  void operator()(isaac::array_expression const & array_expression, std::size_t root_idx, leaf_t leaf) const;
+  void call_before_expansion(isaac::math_expression const & math_expression, std::size_t root_idx) const;
+  void call_after_expansion(math_expression const & /*math_expression*/, std::size_t /*root_idx*/) const;
+  void operator()(isaac::math_expression const & math_expression, std::size_t root_idx, leaf_t leaf) const;
 };
 
 std::string evaluate(leaf_t leaf, std::map<std::string, std::string> const & accessors,
-                            isaac::array_expression const & array_expression, std::size_t root_idx, mapping_type const & mapping);
+                            isaac::math_expression const & math_expression, std::size_t root_idx, mapping_type const & mapping);
 
 void evaluate(kernel_generation_stream & stream, leaf_t leaf, std::map<std::string, std::string> const & accessors,
-                     expressions_tuple const & expressions, std::vector<mapping_type> const & mappings);
+                     math_expression const & expressions, mapping_type const & mappings);
 
-/** @brief functor for fetching or writing-back the elements in a array_expression */
+/** @brief functor for fetching or writing-back the elements in a math_expression */
 class process_traversal : public traversal_functor
 {
 public:
   process_traversal(std::map<std::string, std::string> const & accessors, kernel_generation_stream & stream,
                     mapping_type const & mapping, std::set<std::string> & already_processed);
-  void operator()(array_expression const & array_expression, std::size_t root_idx, leaf_t leaf) const;
+  void operator()(math_expression const & math_expression, std::size_t root_idx, leaf_t leaf) const;
 private:
   std::map<std::string, std::string> accessors_;
   kernel_generation_stream & stream_;
@@ -135,21 +136,21 @@ private:
 };
 
 void process(kernel_generation_stream & stream, leaf_t leaf, std::map<std::string, std::string> const & accessors,
-             isaac::array_expression const & array_expression, size_t root_idx, mapping_type const & mapping, std::set<std::string> & already_processed);
+             isaac::math_expression const & math_expression, size_t root_idx, mapping_type const & mapping, std::set<std::string> & already_processed);
 
 void process(kernel_generation_stream & stream, leaf_t leaf, std::map<std::string, std::string> const & accessors,
-                    expressions_tuple const & expressions, std::vector<mapping_type> const & mappings);
+                    math_expression const & expressions, mapping_type const & mappings);
 
 
-class array_expression_representation_functor : public traversal_functor{
+class math_expression_representation_functor : public traversal_functor{
 private:
   static void append_id(char * & ptr, unsigned int val);
   void append(driver::Buffer const & h, numeric_type dtype, char prefix) const;
-  void append(lhs_rhs_element const & lhs_rhs) const;
+  void append(lhs_rhs_element const & lhs_rhs, bool is_assigned) const;
 public:
-  array_expression_representation_functor(symbolic_binder & binder, char *& ptr);
+  math_expression_representation_functor(symbolic_binder & binder, char *& ptr);
   void append(char*& p, const char * str) const;
-  void operator()(isaac::array_expression const & array_expression, std::size_t root_idx, leaf_t leaf_t) const;
+  void operator()(isaac::math_expression const & math_expression, std::size_t root_idx, leaf_t leaf_t) const;
 private:
   symbolic_binder & binder_;
   char *& ptr_;
diff --git a/include/isaac/kernels/templates/axpy.h b/include/isaac/kernels/templates/axpy.h
index 08d79753b..37a13bf1f 100644
--- a/include/isaac/kernels/templates/axpy.h
+++ b/include/isaac/kernels/templates/axpy.h
@@ -19,13 +19,13 @@ public:
 class axpy : public base_impl<axpy, axpy_parameters>
 {
 private:
-  virtual int is_invalid_impl(driver::Device const &, expressions_tuple const &) const;
-  std::string generate_impl(std::string const & suffix, expressions_tuple const & expressions, driver::Device const & device, std::vector<mapping_type> const & mappings) const;
+  virtual int is_invalid_impl(driver::Device const &, math_expression const  &) const;
+  std::string generate_impl(std::string const & suffix, math_expression const  & expressions, driver::Device const & device, mapping_type const & mappings) const;
 public:
-  axpy(axpy::parameters_type const & parameters, binding_policy_t binding_policy = BIND_ALL_UNIQUE);
-  axpy(unsigned int _simd_width, unsigned int _group_size, unsigned int _num_groups, fetching_policy_type _fetching_policy, binding_policy_t binding_policy = BIND_ALL_UNIQUE);
-  std::vector<int_t> input_sizes(expressions_tuple const & expressions) const;
-  void enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, controller<expressions_tuple> const &);
+  axpy(axpy::parameters_type const & parameters, binding_policy_t binding_policy = BIND_INDEPENDENT);
+  axpy(unsigned int _simd_width, unsigned int _group_size, unsigned int _num_groups, fetching_policy_type _fetching_policy, binding_policy_t binding_policy = BIND_INDEPENDENT);
+  std::vector<int_t> input_sizes(math_expression const  & expressions) const;
+  void enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, execution_handler const &);
 };
 
 }
diff --git a/include/isaac/kernels/templates/base.h b/include/isaac/kernels/templates/base.h
index c6223156e..5e58ccb35 100644
--- a/include/isaac/kernels/templates/base.h
+++ b/include/isaac/kernels/templates/base.h
@@ -60,21 +60,21 @@ public:
     unsigned int num_kernels;
   };
 protected:
-  static int_t vector_size(array_expression::node const & node);
-  static std::pair<int_t, int_t> matrix_size(array_expression::node const & node);
-  static bool requires_fallback(expressions_tuple const & expressions);
+  static int_t vector_size(math_expression::node const & node);
+  static std::pair<int_t, int_t> matrix_size(math_expression::container_type const & tree, math_expression::node const & node);
+  static bool requires_fallback(math_expression const & expressions);
 private:
-  virtual std::string generate_impl(std::string const & suffix, expressions_tuple const & expressions, driver::Device const & device, std::vector<mapping_type> const & mapping) const = 0;
+  virtual std::string generate_impl(std::string const & suffix, math_expression const & expressions, driver::Device const & device, mapping_type const & mapping) const = 0;
 public:
   base(binding_policy_t binding_policy);
-  virtual unsigned int temporary_workspace(expressions_tuple const &) const;
-  virtual unsigned int lmem_usage(expressions_tuple const &) const;
-  virtual unsigned int registers_usage(expressions_tuple const &) const;
-  virtual std::vector<int_t> input_sizes(expressions_tuple const & expressions) const = 0;
+  virtual unsigned int temporary_workspace(math_expression const &) const;
+  virtual unsigned int lmem_usage(math_expression const &) const;
+  virtual unsigned int registers_usage(math_expression const &) const;
+  virtual std::vector<int_t> input_sizes(math_expression const & expressions) const = 0;
   virtual ~base();
-  std::string generate(std::string const & suffix, expressions_tuple const & expressions, driver::Device const & device);
-  virtual int is_invalid(expressions_tuple const & expressions, driver::Device const & device) const = 0;
-  virtual void enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, controller<expressions_tuple> const & expressions) = 0;
+  std::string generate(std::string const & suffix, math_expression const & expressions, driver::Device const & device);
+  virtual int is_invalid(math_expression const & expressions, driver::Device const & device) const = 0;
+  virtual void enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, execution_handler const & expressions) = 0;
   virtual std::shared_ptr<base> clone() const = 0;
 private:
   binding_policy_t binding_policy_;
@@ -85,7 +85,7 @@ template<class TemplateType, class ParametersType>
 class base_impl : public base
 {
 private:
-  virtual int is_invalid_impl(driver::Device const &, expressions_tuple const &) const;
+  virtual int is_invalid_impl(driver::Device const &, math_expression const &) const;
 public:
   typedef ParametersType parameters_type;
   base_impl(parameters_type const & parameters, binding_policy_t binding_policy);
@@ -93,7 +93,7 @@ public:
   unsigned int local_size_1() const;
   std::shared_ptr<base> clone() const;
   /** @brief returns whether or not the profile has undefined behavior on particular device */
-  int is_invalid(expressions_tuple const & expressions, driver::Device const & device) const;
+  int is_invalid(math_expression const & expressions, driver::Device const & device) const;
 protected:
   parameters_type p_;
   binding_policy_t binding_policy_;
diff --git a/include/isaac/kernels/templates/dot.h b/include/isaac/kernels/templates/dot.h
index 482093c3e..bf8b7eec3 100644
--- a/include/isaac/kernels/templates/dot.h
+++ b/include/isaac/kernels/templates/dot.h
@@ -20,17 +20,17 @@ struct dot_parameters : public base::parameters_type
 class dot : public base_impl<dot, dot_parameters>
 {
 private:
-  unsigned int lmem_usage(expressions_tuple const & expressions) const;
-  int is_invalid_impl(driver::Device const &, expressions_tuple const &) const;
+  unsigned int lmem_usage(math_expression const  & expressions) const;
+  int is_invalid_impl(driver::Device const &, math_expression const  &) const;
   inline void reduce_1d_local_memory(kernel_generation_stream & stream, unsigned int size, std::vector<mapped_scalar_dot*> exprs,
                                      std::string const & buf_str, std::string const & buf_value_str, driver::backend_type backend) const;
-  std::string generate_impl(std::string const & suffix,  expressions_tuple const & expressions, driver::Device const & device, std::vector<mapping_type> const & mappings) const;
+  std::string generate_impl(std::string const & suffix,  math_expression const  & expressions, driver::Device const & device, mapping_type const & mapping) const;
 
 public:
-  dot(dot::parameters_type const & parameters, binding_policy_t binding_policy = BIND_ALL_UNIQUE);
-  dot(unsigned int simd, unsigned int ls, unsigned int ng, fetching_policy_type fetch, binding_policy_t bind = BIND_ALL_UNIQUE);
-  std::vector<int_t> input_sizes(expressions_tuple const & expressions) const;
-  void enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, controller<expressions_tuple> const &);
+  dot(dot::parameters_type const & parameters, binding_policy_t binding_policy = BIND_INDEPENDENT);
+  dot(unsigned int simd, unsigned int ls, unsigned int ng, fetching_policy_type fetch, binding_policy_t bind = BIND_INDEPENDENT);
+  std::vector<int_t> input_sizes(math_expression const  & expressions) const;
+  void enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, execution_handler const &);
 private:
   std::vector< driver::Buffer > tmp_;
   std::vector< driver::Buffer > tmpidx_;
diff --git a/include/isaac/kernels/templates/gemm.h b/include/isaac/kernels/templates/gemm.h
index e7fdbfc35..6d9f264cb 100644
--- a/include/isaac/kernels/templates/gemm.h
+++ b/include/isaac/kernels/templates/gemm.h
@@ -41,19 +41,19 @@ struct gemm_parameters : public base::parameters_type
 class gemm : public base_impl<gemm, gemm_parameters>
 {
 private:
-  unsigned int temporary_workspace(expressions_tuple const & expressions) const;
-  unsigned int lmem_usage(expressions_tuple const & expressions) const;
-  unsigned int registers_usage(expressions_tuple const & expressions) const;
-  int is_invalid_impl(driver::Device const &, expressions_tuple const &) const;
-  std::string generate_impl(std::string const & suffix, expressions_tuple const & expressions, driver::Device const & device, std::vector<mapping_type> const &) const;
+  unsigned int temporary_workspace(math_expression const & expressions) const;
+  unsigned int lmem_usage(math_expression const & expressions) const;
+  unsigned int registers_usage(math_expression const & expressions) const;
+  int is_invalid_impl(driver::Device const &, math_expression const &) const;
+  std::string generate_impl(std::string const & suffix, math_expression const & expressions, driver::Device const & device, mapping_type const &) const;
   void enqueue_block(driver::CommandQueue & queue, int_t M, int_t N, int_t K, array const & A, array const & B, array const & C,
                      value_scalar const &alpha, value_scalar const &beta, driver::Program const & program, std::string const & suffix, execution_options_type const & options);
   array create_slice(array & M, int_t s0_0, int_t s0_1, int_t s1_0, int_t s1_1, bool swap);
-  std::vector<int_t> infos(expressions_tuple const & expressions,  isaac::symbolic::preset::gemm::args &arguments) const;
+  std::vector<int_t> infos(math_expression const & expressions,  isaac::symbolic::preset::gemm::args &arguments) const;
 public:
   gemm(gemm::parameters_type const & parameters, bool check_bound, char A_trans, char B_trans);
-  std::vector<int_t> input_sizes(expressions_tuple const & expressions) const;
-  void enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, controller<expressions_tuple> const &ctr);
+  std::vector<int_t> input_sizes(math_expression const & expressions) const;
+  void enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, execution_handler const &ctr);
 private:
   const char A_trans_;
   const char B_trans_;
diff --git a/include/isaac/kernels/templates/gemv.h b/include/isaac/kernels/templates/gemv.h
index 0d0c9b147..59a52506d 100644
--- a/include/isaac/kernels/templates/gemv.h
+++ b/include/isaac/kernels/templates/gemv.h
@@ -31,12 +31,12 @@ protected:
   };
   gemv(gemv::parameters_type const & , dot_type, binding_policy_t);
 private:
-  virtual int is_invalid_impl(driver::Device const &, expressions_tuple const &) const;
-  unsigned int lmem_usage(expressions_tuple const &) const;
-  std::string generate_impl(std::string const & suffix, expressions_tuple const &, driver::Device const & device, std::vector<mapping_type> const &) const;
+  virtual int is_invalid_impl(driver::Device const &, math_expression const &) const;
+  unsigned int lmem_usage(math_expression const &) const;
+  std::string generate_impl(std::string const & suffix, math_expression const &, driver::Device const & device, mapping_type const &) const;
 public:
-  virtual std::vector<int_t> input_sizes(expressions_tuple const & expressions) const;
-  void enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, controller<expressions_tuple> const &);
+  virtual std::vector<int_t> input_sizes(math_expression const & expressions) const;
+  void enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, execution_handler const &);
 private:
   dot_type dot_type_;
 };
@@ -44,15 +44,15 @@ private:
 class gemv_n : public gemv
 {
 public:
-  gemv_n(gemv::parameters_type  const &, binding_policy_t binding_policy = BIND_ALL_UNIQUE);
-  gemv_n(unsigned int simd, unsigned int ls1, unsigned int ls2, unsigned int ng1, unsigned int ng2, fetching_policy_type fetch, binding_policy_t bind = BIND_ALL_UNIQUE);
+  gemv_n(gemv::parameters_type  const &, binding_policy_t binding_policy = BIND_INDEPENDENT);
+  gemv_n(unsigned int simd, unsigned int ls1, unsigned int ls2, unsigned int ng1, unsigned int ng2, fetching_policy_type fetch, binding_policy_t bind = BIND_INDEPENDENT);
 };
 
 class gemv_t : public gemv
 {
 public:
-  gemv_t(gemv::parameters_type  const &, binding_policy_t binding_policy = BIND_ALL_UNIQUE);
-  gemv_t(unsigned int simd, unsigned int ls1, unsigned int ls2, unsigned int ng1, unsigned int ng2, fetching_policy_type fetch, binding_policy_t bind = BIND_ALL_UNIQUE);
+  gemv_t(gemv::parameters_type  const &, binding_policy_t binding_policy = BIND_INDEPENDENT);
+  gemv_t(unsigned int simd, unsigned int ls1, unsigned int ls2, unsigned int ng1, unsigned int ng2, fetching_policy_type fetch, binding_policy_t bind = BIND_INDEPENDENT);
 };
 
 }
diff --git a/include/isaac/kernels/templates/ger.h b/include/isaac/kernels/templates/ger.h
index 8f87682c7..e9958452d 100644
--- a/include/isaac/kernels/templates/ger.h
+++ b/include/isaac/kernels/templates/ger.h
@@ -22,13 +22,13 @@ public:
 class ger : public base_impl<ger, ger_parameters>
 {
 private:
-  int is_invalid_impl(driver::Device const &, expressions_tuple const &) const;
-  std::string generate_impl(std::string const & suffix, expressions_tuple const & expressions, driver::Device const & device, std::vector<mapping_type> const & mappings) const;
+  int is_invalid_impl(driver::Device const &, math_expression const  &) const;
+  std::string generate_impl(std::string const & suffix, math_expression const  & expressions, driver::Device const & device, mapping_type const & mapping) const;
 public:
-  ger(parameters_type const & parameters, binding_policy_t binding_policy = BIND_ALL_UNIQUE);
-  ger(unsigned int simd, unsigned int ls1, unsigned int ls2,  unsigned int ng1, unsigned int ng2, fetching_policy_type fetch, binding_policy_t bind = BIND_ALL_UNIQUE);
-  std::vector<int_t> input_sizes(expressions_tuple const & expressions) const;
-  void enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, controller<expressions_tuple> const &);
+  ger(parameters_type const & parameters, binding_policy_t binding_policy = BIND_INDEPENDENT);
+  ger(unsigned int simd, unsigned int ls1, unsigned int ls2,  unsigned int ng1, unsigned int ng2, fetching_policy_type fetch, binding_policy_t bind = BIND_INDEPENDENT);
+  std::vector<int_t> input_sizes(math_expression const  & expressions) const;
+  void enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, execution_handler const &);
 };
 
 }
diff --git a/include/isaac/profiles/profiles.h b/include/isaac/profiles/profiles.h
index 50f0911b3..152e58d7d 100644
--- a/include/isaac/profiles/profiles.h
+++ b/include/isaac/profiles/profiles.h
@@ -26,14 +26,13 @@ public:
 
     private:
       std::string define_extension(std::string const & extensions, std::string const & ext);
-      inline void fill_program_name(char* program_name, expressions_tuple const & expressions, binding_policy_t binding_policy);
-      driver::Program const & init(controller<expressions_tuple> const &);
+      driver::Program const & init(execution_handler const &);
 
     public:
       value_type(expression_type, numeric_type, predictors::random_forest const &, std::vector< std::shared_ptr<templates::base> > const &, driver::CommandQueue const &);
       value_type(expression_type, numeric_type, templates::base const &, driver::CommandQueue const &);
 
-      void execute(controller<expressions_tuple> const &);
+      void execute(execution_handler const &);
       templates_container const & templates() const;
 
     private:
diff --git a/include/isaac/symbolic/execute.h b/include/isaac/symbolic/execute.h
index 54c94d77e..6d965d510 100644
--- a/include/isaac/symbolic/execute.h
+++ b/include/isaac/symbolic/execute.h
@@ -7,8 +7,11 @@
 namespace isaac
 {
 
-/** @brief Executes a array_expression on the given queue for the given models map*/
-void execute(controller<array_expression> const & , profiles::map_type &);
+/** @brief Executes a math_expression on the given queue for the given models map*/
+void execute(execution_handler const & , profiles::map_type &);
+
+/** @brief Executes a math_expression on the default models map*/
+void execute(execution_handler const &);
 
 }
 
diff --git a/include/isaac/symbolic/expression.h b/include/isaac/symbolic/expression.h
index c5871175e..5efff3cc3 100644
--- a/include/isaac/symbolic/expression.h
+++ b/include/isaac/symbolic/expression.h
@@ -21,7 +21,6 @@ namespace isaac
 {
 
 class array;
-struct repeat_infos;
 
 /** @brief Optimization enum for grouping operations into unary or binary operations. Just for optimization of lookups. */
 enum operation_node_type_family
@@ -84,7 +83,6 @@ enum operation_node_type
   OPERATOR_TRANS_TYPE,
 
   // binary expression
-  OPERATOR_ACCESS_TYPE,
   OPERATOR_ASSIGN_TYPE,
   OPERATOR_INPLACE_ADD_TYPE,
   OPERATOR_INPLACE_SUB_TYPE,
@@ -110,7 +108,14 @@ enum operation_node_type
   OPERATOR_ELEMENT_MAX_TYPE,
   OPERATOR_ELEMENT_MIN_TYPE,
 
+  //Products
   OPERATOR_OUTER_PROD_TYPE,
+  OPERATOR_GEMM_NN_TYPE,
+  OPERATOR_GEMM_TN_TYPE,
+  OPERATOR_GEMM_NT_TYPE,
+  OPERATOR_GEMM_TT_TYPE,
+
+  //Access modifiers
   OPERATOR_MATRIX_DIAG_TYPE,
   OPERATOR_MATRIX_ROW_TYPE,
   OPERATOR_MATRIX_COLUMN_TYPE,
@@ -118,32 +123,32 @@ enum operation_node_type
   OPERATOR_RESHAPE_TYPE,
   OPERATOR_SHIFT_TYPE,
   OPERATOR_VDIAG_TYPE,
+  OPERATOR_ACCESS_INDEX_TYPE,
 
-  OPERATOR_GEMM_NN_TYPE,
-  OPERATOR_GEMM_TN_TYPE,
-  OPERATOR_GEMM_NT_TYPE,
-  OPERATOR_GEMM_TT_TYPE,
 
-  OPERATOR_PAIR_TYPE
+  OPERATOR_PAIR_TYPE,
+
+  OPERATOR_FUSE,
+  OPERATOR_SFOR_TYPE,
 };
 
-/** @brief Groups the type of a node in the array_expression tree. Used for faster dispatching */
-enum array_expression_node_type_family
+/** @brief Groups the type of a node in the math_expression tree. Used for faster dispatching */
+enum math_expression_node_type_family
 {
   INVALID_TYPE_FAMILY = 0,
   COMPOSITE_OPERATOR_FAMILY,
   VALUE_TYPE_FAMILY,
   ARRAY_TYPE_FAMILY,
-  INFOS_TYPE_FAMILY
+  PLACEHOLDER_TYPE_FAMILY
 };
 
-/** @brief Encodes the type of a node in the array_expression tree. */
-enum array_expression_node_subtype
+/** @brief Encodes the type of a node in the math_expression tree. */
+enum math_expression_node_subtype
 {
   INVALID_SUBTYPE = 0,
   VALUE_SCALAR_TYPE,
   DENSE_ARRAY_TYPE,
-  REPEAT_INFOS_TYPE
+  FOR_LOOP_INDEX_TYPE
 };
 
 struct op_element
@@ -154,30 +159,43 @@ struct op_element
   operation_node_type          type;
 };
 
+struct for_idx_t
+{
+  math_expression operator=(value_scalar const & ) const;
+  math_expression operator=(math_expression const & ) const;
+
+  math_expression operator+=(value_scalar const & ) const;
+  math_expression operator-=(value_scalar const & ) const;
+  math_expression operator*=(value_scalar const & ) const;
+  math_expression operator/=(value_scalar const & ) const;
+
+  int level;
+};
+
 struct lhs_rhs_element
 {
   lhs_rhs_element();
-  array_expression_node_type_family   type_family;
-  array_expression_node_subtype       subtype;
+  math_expression_node_type_family   type_family;
+  math_expression_node_subtype       subtype;
   numeric_type  dtype;
   union
   {
     std::size_t   node_index;
     values_holder vscalar;
-    repeat_infos  tuple;
     isaac::array* array;
+    for_idx_t for_idx;
   };
 };
 
 struct invalid_node{};
 
+void fill(lhs_rhs_element &x, for_idx_t index);
 void fill(lhs_rhs_element &x, invalid_node);
 void fill(lhs_rhs_element & x, std::size_t node_index);
 void fill(lhs_rhs_element & x, array const & a);
 void fill(lhs_rhs_element & x, value_scalar const & v);
-void fill(lhs_rhs_element & x, repeat_infos const & r);
 
-class array_expression : public array_base
+class math_expression : public array_base
 {
 public:
   struct node
@@ -190,16 +208,20 @@ public:
   typedef std::vector<node>     container_type;
 
 public:
+  math_expression(value_scalar const &lhs, for_idx_t const &rhs, const op_element &op, const numeric_type &dtype);
+  math_expression(for_idx_t const &lhs, for_idx_t const &rhs, const op_element &op);
+  math_expression(for_idx_t const &lhs, value_scalar const &rhs, const op_element &op, const numeric_type &dtype);
+
   template<class LT, class RT>
-  array_expression(LT const & lhs, RT const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape);
+  math_expression(LT const & lhs, RT const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape);
   template<class RT>
-  array_expression(array_expression const & lhs, RT const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape);
+  math_expression(math_expression const & lhs, RT const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape);
   template<class LT>
-  array_expression(LT const & lhs, array_expression const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape);
-  array_expression(array_expression const & lhs, array_expression const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape);
+  math_expression(LT const & lhs, math_expression const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape);
+  math_expression(math_expression const & lhs, math_expression const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape);
 
   size4 shape() const;
-  array_expression& reshape(int_t size1, int_t size2=1);
+  math_expression& reshape(int_t size1, int_t size2=1);
   int_t nshape() const;
   container_type & tree();
   container_type const & tree() const;
@@ -207,16 +229,18 @@ public:
   driver::Context const & context() const;
   numeric_type const & dtype() const;
 
-  array_expression operator-();
-  array_expression operator!();
+  math_expression operator-();
+  math_expression operator!();
 private:
   container_type tree_;
   std::size_t root_;
-  driver::Context const & context_;
+  driver::Context const * context_;
   numeric_type dtype_;
   size4 shape_;
 };
 
+
+
 struct execution_options_type
 {
   execution_options_type(unsigned int _queue_id = 0, std::list<driver::Event>* _events = NULL, std::vector<driver::Event>* _dependencies = NULL) :
@@ -263,52 +287,28 @@ struct compilation_options_type
   bool recompile;
 };
 
-template<class TYPE>
-class controller
+class execution_handler
 {
 public:
-  controller(TYPE const & x, execution_options_type const& execution_options = execution_options_type(),
-             dispatcher_options_type const & dispatcher_options = dispatcher_options_type(), compilation_options_type const & compilation_options = compilation_options_type())
+  execution_handler(math_expression const & x, execution_options_type const& execution_options = execution_options_type(),
+             dispatcher_options_type const & dispatcher_options = dispatcher_options_type(),
+             compilation_options_type const & compilation_options = compilation_options_type())
                 : x_(x), execution_options_(execution_options), dispatcher_options_(dispatcher_options), compilation_options_(compilation_options){}
-  controller(TYPE const & x, controller const & other) : x_(x), execution_options_(other.execution_options_), dispatcher_options_(other.dispatcher_options_), compilation_options_(other.compilation_options_){}
-  TYPE const & x() const { return x_; }
+  execution_handler(math_expression const & x, execution_handler const & other) : x_(x), execution_options_(other.execution_options_), dispatcher_options_(other.dispatcher_options_), compilation_options_(other.compilation_options_){}
+  math_expression const & x() const { return x_; }
   execution_options_type const & execution_options() const { return execution_options_; }
   dispatcher_options_type const & dispatcher_options() const { return dispatcher_options_; }
   compilation_options_type const & compilation_options() const { return compilation_options_; }
 private:
-  TYPE const & x_;
+  math_expression x_;
   execution_options_type execution_options_;
   dispatcher_options_type dispatcher_options_;
   compilation_options_type compilation_options_;
 };
 
-template<class TYPE>
-controller<TYPE> control(TYPE const & x, execution_options_type const& execution_options = execution_options_type(),
-                         dispatcher_options_type const & dispatcher_options = dispatcher_options_type(), compilation_options_type const & compilation_options = compilation_options_type())
-{ return controller<TYPE>(x, execution_options, dispatcher_options, compilation_options); }
+math_expression::node const & lhs_most(math_expression::container_type const & array, math_expression::node const & init);
+math_expression::node const & lhs_most(math_expression::container_type const & array, size_t root);
 
-class expressions_tuple
-{
-private:
-  std::shared_ptr<array_expression> create(array_expression const & s);
-public:
-  typedef std::list<std::shared_ptr<array_expression> > data_type;
-  enum order_type { SEQUENTIAL, INDEPENDENT };
-
-  expressions_tuple(array_expression const & s0);
-  expressions_tuple(order_type order, array_expression const & s0, array_expression const & s1);
-  expressions_tuple(data_type const & data, order_type order);
-
-  data_type const & data() const;
-  driver::Context const & context() const;
-  order_type order() const;
-private:
-  data_type data_;
-  order_type order_;
-};
-
-array_expression::node const & lhs_most(array_expression::container_type const & array, array_expression::node const & init);
-array_expression::node const & lhs_most(array_expression::container_type const & array, size_t root);
 
 }
 
diff --git a/include/isaac/symbolic/io.h b/include/isaac/symbolic/io.h
index 16cb541da..c76efd544 100644
--- a/include/isaac/symbolic/io.h
+++ b/include/isaac/symbolic/io.h
@@ -7,10 +7,10 @@
 namespace isaac
 {
 
-std::string to_string(array_expression_node_subtype const & f);
+std::string to_string(math_expression_node_subtype const & f);
 std::string to_string(lhs_rhs_element const & e);
-std::ostream & operator<<(std::ostream & os, array_expression::node const & s_node);
-std::string to_string(isaac::array_expression const & s);
+std::ostream & operator<<(std::ostream & os, math_expression::node const & s_node);
+std::string to_string(isaac::math_expression const & s);
 
 }
 
diff --git a/include/isaac/symbolic/preset.h b/include/isaac/symbolic/preset.h
index 2d75fb4da..ca53d5138 100644
--- a/include/isaac/symbolic/preset.h
+++ b/include/isaac/symbolic/preset.h
@@ -20,11 +20,11 @@ public:
     struct args
     {
         args(): alpha(NULL), A(NULL), B(NULL), beta(NULL), C(NULL), type(INVALID_EXPRESSION_TYPE){ }
-        lhs_rhs_element* alpha;
-        lhs_rhs_element* A;
-        lhs_rhs_element* B;
-        lhs_rhs_element* beta;
-        lhs_rhs_element* C;
+        lhs_rhs_element const * alpha;
+        lhs_rhs_element const * A;
+        lhs_rhs_element const * B;
+        lhs_rhs_element const * beta;
+        lhs_rhs_element const * C;
         expression_type type;
 
         operator bool() const
@@ -34,10 +34,10 @@ public:
     };
 
 private:
-    static void handle_node(array_expression::container_type &tree, size_t rootidx, args & a);
+    static void handle_node( math_expression::container_type const &tree, size_t rootidx, args & a);
 
 public:
-    static args check(array_expression::container_type & tree, size_t rootidx);
+    static args check(math_expression::container_type const &tree, size_t rootidx);
 };
 
 }
diff --git a/include/isaac/tuple.h b/include/isaac/tuple.h
new file mode 100644
index 000000000..502ba6ed8
--- /dev/null
+++ b/include/isaac/tuple.h
@@ -0,0 +1,40 @@
+#ifndef ISAAC_TUPLE_H
+#define ISAAC_TUPLE_H
+
+#include "isaac/common/numeric_type.h"
+
+#include "isaac/defines.h"
+#include "isaac/value_scalar.h"
+#include "isaac/symbolic/expression.h"
+
+namespace isaac
+{
+
+template<class T> typename std::enable_if<!std::is_arithmetic<T>::value, T const &>::type wrap_generic(T const & x){ return x;}
+template<class T> typename std::enable_if<std::is_arithmetic<T>::value, value_scalar>::type wrap_generic(T x) { return value_scalar(x); }
+
+template<typename T>
+ISAACAPI typename std::conditional<std::is_arithmetic<T>::value, value_scalar, T const &>::type make_tuple(driver::Context const &, T const & x)
+{ return wrap_generic(x); }
+
+template<typename T, typename... Args>
+ISAACAPI math_expression make_tuple(driver::Context const & context, T const & x, Args... args)
+{ return math_expression(wrap_generic(x), make_tuple(context, args...), op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_PAIR_TYPE), context, numeric_type_of(x), size4(1)); }
+
+inline value_scalar tuple_get(math_expression::container_type const & tree, size_t root, size_t idx)
+{
+  for(unsigned int i = 0 ; i < idx ; ++i){
+      math_expression::node node = tree[root];
+      if(node.rhs.type_family==COMPOSITE_OPERATOR_FAMILY)
+        root = node.rhs.node_index;
+      else
+        return value_scalar(node.rhs.vscalar, node.rhs.dtype);
+  }
+  return value_scalar(tree[root].lhs.vscalar, tree[root].lhs.dtype);
+}
+
+
+
+}
+
+#endif
diff --git a/include/isaac/types.h b/include/isaac/types.h
index 8425b8dfc..3310822cd 100644
--- a/include/isaac/types.h
+++ b/include/isaac/types.h
@@ -29,14 +29,6 @@ private:
 
 inline int_t prod(size4 const & s) { return s[0]*s[1]; }
 
-struct repeat_infos
-{
-  int_t sub1;
-  int_t sub2;
-  int_t rep1;
-  int_t rep2;
-};
-
 struct slice
 {
   slice(int_t _start, int_t _end, int_t _stride = 1) : start(_start), size((_end - _start)/_stride), stride(_stride) { }
diff --git a/include/isaac/value_scalar.h b/include/isaac/value_scalar.h
index bd25810f0..c02a25983 100644
--- a/include/isaac/value_scalar.h
+++ b/include/isaac/value_scalar.h
@@ -9,7 +9,7 @@ namespace isaac
 {
 
 class scalar;
-class array_expression;
+class math_expression;
 
 union ISAACAPI values_holder
 {
@@ -46,7 +46,7 @@ public:
 #undef ISAAC_INSTANTIATE
   value_scalar(values_holder values, numeric_type dtype);
   explicit value_scalar(scalar const &);
-  explicit value_scalar(array_expression const &);
+  explicit value_scalar(math_expression const &);
   explicit value_scalar(numeric_type dtype);
 
   values_holder values() const;
@@ -159,6 +159,7 @@ ISAAC_DECLARE_UNARY_OPERATOR(trans)
 
 ISAACAPI std::ostream & operator<<(std::ostream & os, value_scalar const & s);
 
+
 }
 
 #endif
diff --git a/lib/array.cpp b/lib/array.cpp
index 7cd0c5ccc..3c4be0a4c 100644
--- a/lib/array.cpp
+++ b/lib/array.cpp
@@ -5,10 +5,11 @@
 #include <stdexcept>
 
 #include "isaac/array.h"
+#include "isaac/tuple.h"
 #include "isaac/exception/unknown_datatype.h"
 #include "isaac/profiles/profiles.h"
 #include "isaac/symbolic/execute.h"
-
+#include "isaac/symbolic/io.h"
 
 namespace isaac
 {
@@ -109,11 +110,16 @@ INSTANTIATE(float);
 INSTANTIATE(double);
 #undef INSTANTIATE
 
-array::array(array_expression const & proxy) : array(control(proxy)){}
-array::array(array const & other) : array(control(other)){}
+array::array(math_expression const & proxy) : array(execution_handler(proxy)){}
 
-template<class TYPE>
-array::array(controller<TYPE> const & other) :
+array::array(array const & other):  dtype_(other.dtype()),
+    shape_(other.shape()), start_(0,0), stride_(1, 1), ld_(shape_[0]),
+    context_(other.context()), data_(context_, size_of(dtype_)*dsize())
+{
+  *this = other;
+}
+
+array::array(execution_handler const & other) :
   dtype_(other.x().dtype()),
   shape_(other.x().shape()), start_(0,0), stride_(1, 1), ld_(shape_[0]),
   context_(other.x().context()), data_(context_, size_of(dtype_)*dsize())
@@ -121,13 +127,11 @@ array::array(controller<TYPE> const & other) :
   *this = other;
 }
 
-
-template ISAACAPI array::array(controller<array> const&);
-template ISAACAPI array::array(controller<array_expression> const&);
-
 /*--- Getters ---*/
 numeric_type array::dtype() const
-{ return dtype_; }
+{
+  return dtype_;
+}
 
 size4 const & array::shape() const
 { return shape_; }
@@ -159,26 +163,37 @@ int_t array::dsize() const
 
 /*--- Assignment Operators ----*/
 //---------------------------------------
+
 array & array::operator=(array const & rhs)
-{ return *this = controller<array>(rhs); }
+{
+    assert(dtype_ == rhs.dtype());
+    math_expression expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_ASSIGN_TYPE), context_, dtype_, shape_);
+    execute(execution_handler(expression));
+    return *this;
+}
 
-array & array::operator=(array_expression const & rhs)
-{ return *this = controller<array_expression>(rhs); }
+array & array::operator=(value_scalar const & rhs)
+{
+    assert(dtype_ == rhs.dtype());
+    math_expression expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_ASSIGN_TYPE), context_, dtype_, shape_);
+    execute(execution_handler(expression));
+    return *this;
+}
 
-template<class TYPE>
-array& array::operator=(controller<TYPE> const & c)
+
+array& array::operator=(execution_handler const & c)
 {
   assert(dtype_ == c.x().dtype());
-  array_expression expression(*this, c.x(), op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_ASSIGN_TYPE), context_, dtype_, shape_);
-  execute(controller<array_expression>(expression, c.execution_options(), c.dispatcher_options(), c.compilation_options()),
-          isaac::profiles::get(c.execution_options().queue(context_)));
+  math_expression expression(*this, c.x(), op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_ASSIGN_TYPE), context_, dtype_, shape_);
+  execute(execution_handler(expression, c.execution_options(), c.dispatcher_options(), c.compilation_options()));
   return *this;
 }
 
-#define INSTANTIATE(TYPE) template ISAACAPI array& array::operator=<TYPE>(controller<TYPE> const &)
-INSTANTIATE(array);
-INSTANTIATE(array_expression);
-#undef INSTANTIATE
+array & array::operator=(math_expression const & rhs)
+{
+  return *this = execution_handler(rhs);
+}
+
 
 template<class DT>
 array & array::operator=(std::vector<DT> const & rhs)
@@ -204,60 +219,63 @@ INSTANTIATE(float);
 INSTANTIATE(double);
 #undef INSTANTIATE
 
-array & array::operator=(value_scalar const & rhs)
-{ return *this = controller<value_scalar>(rhs); }
 
 
 
 
-array_expression array::operator-()
-{ return array_expression(*this, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_SUB_TYPE), context_, dtype_, shape_); }
+math_expression array::operator-()
+{ return math_expression(*this, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_SUB_TYPE), context_, dtype_, shape_); }
 
-array_expression array::operator!()
-{ return array_expression(*this, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_NEGATE_TYPE), context_, INT_TYPE, shape_); }
+math_expression array::operator!()
+{ return math_expression(*this, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_NEGATE_TYPE), context_, INT_TYPE, shape_); }
 
 //
 array & array::operator+=(value_scalar const & rhs)
-{ return *this = array_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_ADD_TYPE), context_, dtype_, shape_); }
+{ return *this = math_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_ADD_TYPE), context_, dtype_, shape_); }
 
 array & array::operator+=(array const & rhs)
-{ return *this = array_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_ADD_TYPE), context_, dtype_, shape_); }
+{ return *this = math_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_ADD_TYPE), context_, dtype_, shape_); }
 
-array & array::operator+=(array_expression const & rhs)
-{ return *this = array_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_ADD_TYPE), rhs.context(), dtype_, shape_); }
+array & array::operator+=(math_expression const & rhs)
+{ return *this = math_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_ADD_TYPE), rhs.context(), dtype_, shape_); }
 //----
 array & array::operator-=(value_scalar const & rhs)
-{ return *this = array_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_SUB_TYPE), context_, dtype_, shape_); }
+{ return *this = math_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_SUB_TYPE), context_, dtype_, shape_); }
 
 array & array::operator-=(array const & rhs)
-{ return *this = array_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_SUB_TYPE), context_, dtype_, shape_); }
+{ return *this = math_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_SUB_TYPE), context_, dtype_, shape_); }
 
-array & array::operator-=(array_expression const & rhs)
-{ return *this = array_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_SUB_TYPE), rhs.context(), dtype_, shape_); }
+array & array::operator-=(math_expression const & rhs)
+{ return *this = math_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_SUB_TYPE), rhs.context(), dtype_, shape_); }
 //----
 array & array::operator*=(value_scalar const & rhs)
-{ return *this = array_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_MULT_TYPE), context_, dtype_, shape_); }
+{ return *this = math_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_MULT_TYPE), context_, dtype_, shape_); }
 
 array & array::operator*=(array const & rhs)
-{ return *this = array_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_MULT_TYPE), context_, dtype_, shape_); }
+{ return *this = math_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_MULT_TYPE), context_, dtype_, shape_); }
 
-array & array::operator*=(array_expression const & rhs)
-{ return *this = array_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_MULT_TYPE), rhs.context(), dtype_, shape_); }
+array & array::operator*=(math_expression const & rhs)
+{ return *this = math_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_MULT_TYPE), rhs.context(), dtype_, shape_); }
 //----
 array & array::operator/=(value_scalar const & rhs)
-{ return *this = array_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_DIV_TYPE), context_, dtype_, shape_); }
+{ return *this = math_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_DIV_TYPE), context_, dtype_, shape_); }
 
 array & array::operator/=(array const & rhs)
-{ return *this = array_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_DIV_TYPE), context_, dtype_, shape_); }
+{ return *this = math_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_DIV_TYPE), context_, dtype_, shape_); }
 
-array & array::operator/=(array_expression const & rhs)
-{ return *this = array_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_DIV_TYPE), rhs.context(), dtype_, shape_); }
+array & array::operator/=(math_expression const & rhs)
+{ return *this = math_expression(*this, rhs, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_DIV_TYPE), rhs.context(), dtype_, shape_); }
 
-array_expression array::T() const
+math_expression array::T() const
 { return isaac::trans(*this) ;}
 
 /*--- Indexing operators -----*/
 //---------------------------------------
+math_expression array::operator[](for_idx_t idx) const
+{
+  return math_expression(*this, idx, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_ACCESS_INDEX_TYPE), context_, dtype_, shape_);
+}
+
 scalar array::operator [](int_t idx)
 {
   assert(nshape()<=1);
@@ -318,7 +336,7 @@ scalar::scalar(value_scalar value, driver::Context const & context) : array(1, v
 scalar::scalar(numeric_type dtype, driver::Context const & context) : array(1, dtype, context)
 { }
 
-scalar::scalar(array_expression const & proxy) : array(proxy){ }
+scalar::scalar(math_expression const & proxy) : array(proxy){ }
 
 void scalar::inject(values_holder & v) const
 {
@@ -445,37 +463,63 @@ size4 elementwise_size(U const & u, V const & v)
 template<class U, class V>
 bool check_elementwise(U const & u, V const & v)
 {
+  return true;
   return detail::max(u.shape())==1 || detail::max(v.shape())==1 || u.shape()==v.shape();
 }
 
 #define DEFINE_ELEMENT_BINARY_OPERATOR(OP, OPNAME, DTYPE) \
-array_expression OPNAME (array_expression const & x, array_expression const & y) \
+math_expression OPNAME (array const & x, math_expression const & y) \
 { assert(check_elementwise(x, y));\
-  return array_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, elementwise_size(x, y)); } \
+  return math_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, elementwise_size(x, y)); } \
+\
+math_expression OPNAME (array const & x, array const & y) \
+{ assert(check_elementwise(x, y));\
+  return math_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, elementwise_size(x, y)); }\
+\
+math_expression OPNAME (array const & x, value_scalar const & y) \
+{ return math_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, x.shape()); }\
+\
+math_expression OPNAME (array const & x, for_idx_t const & y) \
+{ return math_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, x.shape()); }\
+\
+\
+math_expression OPNAME (math_expression const & x, math_expression const & y) \
+{ assert(check_elementwise(x, y));\
+  return math_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, elementwise_size(x, y)); } \
  \
-array_expression OPNAME (array const & x, array_expression const & y) \
+math_expression OPNAME (math_expression const & x, array const & y) \
 { assert(check_elementwise(x, y));\
-  return array_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, elementwise_size(x, y)); } \
+  return math_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, elementwise_size(x, y)); } \
 \
-array_expression OPNAME (array_expression const & x, array const & y) \
-{ assert(check_elementwise(x, y));\
-  return array_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, elementwise_size(x, y)); } \
+math_expression OPNAME (math_expression const & x, value_scalar const & y) \
+{ return math_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, x.shape()); } \
 \
-array_expression OPNAME (array const & x, array const & y) \
-{ assert(check_elementwise(x, y));\
-  return array_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, elementwise_size(x, y)); }\
+math_expression OPNAME (math_expression const & x, for_idx_t const & y) \
+{ return math_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, x.shape()); } \
 \
-array_expression OPNAME (array_expression const & x, value_scalar const & y) \
-{ return array_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, x.shape()); } \
 \
-array_expression OPNAME (array const & x, value_scalar const & y) \
-{ return array_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, x.shape()); }\
+math_expression OPNAME (value_scalar const & y, math_expression const & x) \
+{ return math_expression(y, x, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, x.shape()); } \
 \
-array_expression OPNAME (value_scalar const & y, array_expression const & x) \
-{ return array_expression(y, x, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, x.shape()); } \
+math_expression OPNAME (value_scalar const & y, array const & x) \
+{ return math_expression(y, x, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, x.shape()); }\
 \
-array_expression OPNAME (value_scalar const & y, array const & x) \
-{ return array_expression(y, x, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, x.shape()); }
+math_expression OPNAME (value_scalar const & x, for_idx_t const & y) \
+{ return math_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), DTYPE); }\
+\
+\
+math_expression OPNAME (for_idx_t const & y, math_expression const & x) \
+{ return math_expression(y, x, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, x.shape()); } \
+\
+math_expression OPNAME (for_idx_t const & y, value_scalar const & x) \
+{ return math_expression(y, x, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), DTYPE); } \
+\
+math_expression OPNAME (for_idx_t const & y, array const & x) \
+{ return math_expression(y, x, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP), x.context(), DTYPE, x.shape()); }\
+\
+math_expression OPNAME (for_idx_t const & y, for_idx_t const & x) \
+{ return math_expression(y, x, op_element(OPERATOR_BINARY_TYPE_FAMILY, OP)); }
+
 
 DEFINE_ELEMENT_BINARY_OPERATOR(OPERATOR_ADD_TYPE, operator +, x.dtype())
 DEFINE_ELEMENT_BINARY_OPERATOR(OPERATOR_SUB_TYPE, operator -, x.dtype())
@@ -497,28 +541,50 @@ DEFINE_ELEMENT_BINARY_OPERATOR(OPERATOR_ELEMENT_EQ_TYPE, operator ==, INT_TYPE)
 DEFINE_ELEMENT_BINARY_OPERATOR(OPERATOR_ELEMENT_NEQ_TYPE, operator !=, INT_TYPE)
 
 #define DEFINE_OUTER(LTYPE, RTYPE) \
-array_expression outer(LTYPE const & x, RTYPE const & y)\
+math_expression outer(LTYPE const & x, RTYPE const & y)\
 {\
     assert(x.nshape()==1 && y.nshape()==1);\
-    return array_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_OUTER_PROD_TYPE), x.context(), x.dtype(), size4(detail::max(x.shape()), detail::max(y.shape())) );\
+    return math_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_OUTER_PROD_TYPE), x.context(), x.dtype(), size4(detail::max(x.shape()), detail::max(y.shape())) );\
 }\
 
 DEFINE_OUTER(array, array)
-DEFINE_OUTER(array_expression, array)
-DEFINE_OUTER(array, array_expression)
-DEFINE_OUTER(array_expression, array_expression)
+DEFINE_OUTER(math_expression, array)
+DEFINE_OUTER(array, math_expression)
+DEFINE_OUTER(math_expression, math_expression)
 
 #undef DEFINE_ELEMENT_BINARY_OPERATOR
+
+#define DEFINE_ROT(LTYPE, RTYPE, CTYPE, STYPE)\
+math_expression rot(LTYPE const & x, RTYPE const & y, CTYPE const & c, STYPE const & s)\
+{ return fuse(assign(x, c*x + s*y), assign(y, c*y - s*x)); }
+
+DEFINE_ROT(array, array, scalar, scalar)
+DEFINE_ROT(math_expression, array, scalar, scalar)
+DEFINE_ROT(array, math_expression, scalar, scalar)
+DEFINE_ROT(math_expression, math_expression, scalar, scalar)
+
+DEFINE_ROT(array, array, value_scalar, value_scalar)
+DEFINE_ROT(math_expression, array, value_scalar, value_scalar)
+DEFINE_ROT(array, math_expression, value_scalar, value_scalar)
+DEFINE_ROT(math_expression, math_expression, value_scalar, value_scalar)
+
+DEFINE_ROT(array, array, math_expression, math_expression)
+DEFINE_ROT(math_expression, array, math_expression, math_expression)
+DEFINE_ROT(array, math_expression, math_expression, math_expression)
+DEFINE_ROT(math_expression, math_expression, math_expression, math_expression)
+
+
+
 //---------------------------------------
 
 /*--- Math Operators----*/
 //---------------------------------------
 #define DEFINE_ELEMENT_UNARY_OPERATOR(OP, OPNAME) \
-array_expression OPNAME (array  const & x) \
-{ return array_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OP), x.context(), x.dtype(), x.shape()); }\
+math_expression OPNAME (array  const & x) \
+{ return math_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OP), x.context(), x.dtype(), x.shape()); }\
 \
-array_expression OPNAME (array_expression const & x) \
-{ return array_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OP), x.context(), x.dtype(), x.shape()); }
+math_expression OPNAME (math_expression const & x) \
+{ return math_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OP), x.context(), x.dtype(), x.shape()); }
 
 DEFINE_ELEMENT_UNARY_OPERATOR((x.dtype()==FLOAT_TYPE || x.dtype()==DOUBLE_TYPE)?OPERATOR_FABS_TYPE:OPERATOR_ABS_TYPE,  abs)
 DEFINE_ELEMENT_UNARY_OPERATOR(OPERATOR_ACOS_TYPE, acos)
@@ -562,17 +628,17 @@ inline operation_node_type casted(numeric_type dtype)
   }
 }
 
-array_expression cast(array const & x, numeric_type dtype)
-{ return array_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, casted(dtype)), x.context(), dtype, x.shape()); }
+math_expression cast(array const & x, numeric_type dtype)
+{ return math_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, casted(dtype)), x.context(), dtype, x.shape()); }
 
-array_expression cast(array_expression const & x, numeric_type dtype)
-{ return array_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, casted(dtype)), x.context(), dtype, x.shape()); }
+math_expression cast(math_expression const & x, numeric_type dtype)
+{ return math_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, casted(dtype)), x.context(), dtype, x.shape()); }
 
-isaac::array_expression eye(int_t M, int_t N, isaac::numeric_type dtype, driver::Context const & ctx)
-{ return array_expression(value_scalar(1), value_scalar(0), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_VDIAG_TYPE), ctx, dtype, size4(M, N)); }
+isaac::math_expression eye(int_t M, int_t N, isaac::numeric_type dtype, driver::Context const & ctx)
+{ return math_expression(value_scalar(1), value_scalar(0), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_VDIAG_TYPE), ctx, dtype, size4(M, N)); }
 
-isaac::array_expression zeros(int_t M, int_t N, isaac::numeric_type dtype, driver::Context  const & ctx)
-{ return array_expression(value_scalar(0, dtype), invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_ADD_TYPE), ctx, dtype, size4(M, N)); }
+isaac::math_expression zeros(int_t M, int_t N, isaac::numeric_type dtype, driver::Context  const & ctx)
+{ return math_expression(value_scalar(0, dtype), invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_ADD_TYPE), ctx, dtype, size4(M, N)); }
 
 inline size4 flip(size4 const & shape)
 { return size4(shape[1], shape[0]);}
@@ -580,59 +646,77 @@ inline size4 flip(size4 const & shape)
 inline size4 prod(size4 const & shape1, size4 const & shape2)
 { return size4(shape1[0]*shape2[0], shape1[1]*shape2[1]);}
 
-array_expression trans(array  const & x) \
-{ return array_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_TRANS_TYPE), x.context(), x.dtype(), flip(x.shape())); }\
+math_expression trans(array  const & x) \
+{ return math_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_TRANS_TYPE), x.context(), x.dtype(), flip(x.shape())); }\
 \
-array_expression trans(array_expression const & x) \
-{ return array_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_TRANS_TYPE), x.context(), x.dtype(), flip(x.shape())); }
+math_expression trans(math_expression const & x) \
+{ return math_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_TRANS_TYPE), x.context(), x.dtype(), flip(x.shape())); }
 
-array_expression repmat(array const & A, int_t const & rep1, int_t const & rep2)
+math_expression repmat(array const & A, int_t const & rep1, int_t const & rep2)
 {
-  repeat_infos infos;
-  infos.rep1 = rep1;
-  infos.rep2 = rep2;
-  infos.sub1 = A.shape()[0];
-  infos.sub2 = A.shape()[1];
-  return array_expression(A, infos, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_REPEAT_TYPE), A.context(), A.dtype(), size4(infos.rep1*infos.sub1, infos.rep2*infos.sub2));
+  int_t sub1 = A.shape()[0];
+  int_t sub2 = A.shape()[1];
+  return math_expression(A, make_tuple(A.context(), rep1, rep2, sub1, sub2), op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_REPEAT_TYPE), A.context(), A.dtype(), size4(rep1*sub1, rep2*sub2));
 }
 
-array_expression repmat(array_expression const & A, int_t const & rep1, int_t const & rep2)
+math_expression repmat(math_expression const & A, int_t const & rep1, int_t const & rep2)
 {
-  repeat_infos infos;
-  infos.rep1 = rep1;
-  infos.rep2 = rep2;
-  infos.sub1 = A.shape()[0];
-  infos.sub2 = A.shape()[1];
-  return array_expression(A, infos, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_REPEAT_TYPE), A.context(), A.dtype(), size4(infos.rep1*infos.sub1, infos.rep2*infos.sub2));
+  int_t sub1 = A.shape()[0];
+  int_t sub2 = A.shape()[1];
+  return math_expression(A, make_tuple(A.context(), rep1, rep2, sub1, sub2), op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_REPEAT_TYPE), A.context(), A.dtype(), size4(rep1*sub1, rep2*sub2));
 }
 
+#define DEFINE_ACCESS_ROW(TYPEA, TYPEB) \
+  math_expression row(TYPEA const & x, TYPEB const & i)\
+  { return math_expression(x, i, op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_MATRIX_ROW_TYPE), x.context(), x.dtype(), size4(x.shape()[1], 1)); }
+
+DEFINE_ACCESS_ROW(array, value_scalar)
+DEFINE_ACCESS_ROW(array, for_idx_t)
+DEFINE_ACCESS_ROW(array, math_expression)
+
+DEFINE_ACCESS_ROW(math_expression, value_scalar)
+DEFINE_ACCESS_ROW(math_expression, for_idx_t)
+DEFINE_ACCESS_ROW(math_expression, math_expression)
+
+#define DEFINE_ACCESS_COL(TYPEA, TYPEB) \
+  math_expression col(TYPEA const & x, TYPEB const & i)\
+  { return math_expression(x, i, op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_MATRIX_COLUMN_TYPE), x.context(), x.dtype(), size4(x.shape()[1], 1)); }
+
+DEFINE_ACCESS_COL(array, value_scalar)
+DEFINE_ACCESS_COL(array, for_idx_t)
+DEFINE_ACCESS_COL(array, math_expression)
+
+DEFINE_ACCESS_COL(math_expression, value_scalar)
+DEFINE_ACCESS_COL(math_expression, for_idx_t)
+DEFINE_ACCESS_COL(math_expression, math_expression)
+
 ////---------------------------------------
 
 ///*--- Reductions ---*/
 ////---------------------------------------
 #define DEFINE_DOT(OP, OPNAME)\
-array_expression OPNAME(array const & x, int_t axis)\
+math_expression OPNAME(array const & x, int_t axis)\
 {\
   if(axis < -1 || axis > x.nshape())\
     throw std::out_of_range("The axis entry is out of bounds");\
   else if(axis==-1)\
-    return array_expression(x, invalid_node(), op_element(OPERATOR_VECTOR_DOT_TYPE_FAMILY, OP), x.context(), x.dtype(), size4(1));\
+    return math_expression(x, invalid_node(), op_element(OPERATOR_VECTOR_DOT_TYPE_FAMILY, OP), x.context(), x.dtype(), size4(1));\
   else if(axis==0)\
-    return array_expression(x, invalid_node(), op_element(OPERATOR_COLUMNS_DOT_TYPE_FAMILY, OP), x.context(), x.dtype(), size4(x.shape()[1]));\
+    return math_expression(x, invalid_node(), op_element(OPERATOR_COLUMNS_DOT_TYPE_FAMILY, OP), x.context(), x.dtype(), size4(x.shape()[1]));\
   else\
-    return array_expression(x, invalid_node(), op_element(OPERATOR_ROWS_DOT_TYPE_FAMILY, OP), x.context(), x.dtype(), size4(x.shape()[0]));\
+    return math_expression(x, invalid_node(), op_element(OPERATOR_ROWS_DOT_TYPE_FAMILY, OP), x.context(), x.dtype(), size4(x.shape()[0]));\
 }\
 \
-array_expression OPNAME(array_expression const & x, int_t axis)\
+math_expression OPNAME(math_expression const & x, int_t axis)\
 {\
   if(axis < -1 || axis > x.nshape())\
     throw std::out_of_range("The axis entry is out of bounds");\
   if(axis==-1)\
-    return array_expression(x, invalid_node(), op_element(OPERATOR_VECTOR_DOT_TYPE_FAMILY, OP), x.context(), x.dtype(), size4(1));\
+    return math_expression(x, invalid_node(), op_element(OPERATOR_VECTOR_DOT_TYPE_FAMILY, OP), x.context(), x.dtype(), size4(1));\
   else if(axis==0)\
-    return array_expression(x, invalid_node(), op_element(OPERATOR_COLUMNS_DOT_TYPE_FAMILY, OP), x.context(), x.dtype(), size4(x.shape()[1]));\
+    return math_expression(x, invalid_node(), op_element(OPERATOR_COLUMNS_DOT_TYPE_FAMILY, OP), x.context(), x.dtype(), size4(x.shape()[1]));\
   else\
-    return array_expression(x, invalid_node(), op_element(OPERATOR_ROWS_DOT_TYPE_FAMILY, OP), x.context(), x.dtype(), size4(x.shape()[0]));\
+    return math_expression(x, invalid_node(), op_element(OPERATOR_ROWS_DOT_TYPE_FAMILY, OP), x.context(), x.dtype(), size4(x.shape()[0]));\
 }
 
 DEFINE_DOT(OPERATOR_ADD_TYPE, sum)
@@ -646,51 +730,51 @@ DEFINE_DOT(OPERATOR_ELEMENT_ARGMIN_TYPE, argmin)
 namespace detail
 {
 
-  array_expression matmatprod(array const & A, array const & B)
+  math_expression matmatprod(array const & A, array const & B)
   {
     size4 shape(A.shape()[0], B.shape()[1]);
-    return array_expression(A, B, op_element(OPERATOR_GEMM_TYPE_FAMILY, OPERATOR_GEMM_NN_TYPE), A.context(), A.dtype(), shape);
+    return math_expression(A, B, op_element(OPERATOR_GEMM_TYPE_FAMILY, OPERATOR_GEMM_NN_TYPE), A.context(), A.dtype(), shape);
   }
 
-  array_expression matmatprod(array_expression const & A, array const & B)
+  math_expression matmatprod(math_expression const & A, array const & B)
   {
     operation_node_type type = OPERATOR_GEMM_NN_TYPE;
     size4 shape(A.shape()[0], B.shape()[1]);
 
-    array_expression::node & A_root = const_cast<array_expression::node &>(A.tree()[A.root()]);
+    math_expression::node & A_root = const_cast<math_expression::node &>(A.tree()[A.root()]);
     bool A_trans = A_root.op.type==OPERATOR_TRANS_TYPE;
     if(A_trans){
       type = OPERATOR_GEMM_TN_TYPE;
     }
 
-    array_expression res(A, B, op_element(OPERATOR_GEMM_TYPE_FAMILY, type), A.context(), A.dtype(), shape);
-    array_expression::node & res_root = const_cast<array_expression::node &>(res.tree()[res.root()]);
+    math_expression res(A, B, op_element(OPERATOR_GEMM_TYPE_FAMILY, type), A.context(), A.dtype(), shape);
+    math_expression::node & res_root = const_cast<math_expression::node &>(res.tree()[res.root()]);
     if(A_trans) res_root.lhs = A_root.lhs;
     return res;
   }
 
-  array_expression matmatprod(array const & A, array_expression const & B)
+  math_expression matmatprod(array const & A, math_expression const & B)
   {
     operation_node_type type = OPERATOR_GEMM_NN_TYPE;
     size4 shape(A.shape()[0], B.shape()[1]);
 
-    array_expression::node & B_root = const_cast<array_expression::node &>(B.tree()[B.root()]);
+    math_expression::node & B_root = const_cast<math_expression::node &>(B.tree()[B.root()]);
     bool B_trans = B_root.op.type==OPERATOR_TRANS_TYPE;
     if(B_trans){
       type = OPERATOR_GEMM_NT_TYPE;
     }
 
-    array_expression res(A, B, op_element(OPERATOR_GEMM_TYPE_FAMILY, type), A.context(), A.dtype(), shape);
-    array_expression::node & res_root = const_cast<array_expression::node &>(res.tree()[res.root()]);
+    math_expression res(A, B, op_element(OPERATOR_GEMM_TYPE_FAMILY, type), A.context(), A.dtype(), shape);
+    math_expression::node & res_root = const_cast<math_expression::node &>(res.tree()[res.root()]);
     if(B_trans) res_root.rhs = B_root.lhs;
     return res;
   }
 
-  array_expression matmatprod(array_expression const & A, array_expression const & B)
+  math_expression matmatprod(math_expression const & A, math_expression const & B)
   {
     operation_node_type type = OPERATOR_GEMM_NN_TYPE;
-    array_expression::node & A_root = const_cast<array_expression::node &>(A.tree()[A.root()]);
-    array_expression::node & B_root = const_cast<array_expression::node &>(B.tree()[B.root()]);
+    math_expression::node & A_root = const_cast<math_expression::node &>(A.tree()[A.root()]);
+    math_expression::node & B_root = const_cast<math_expression::node &>(B.tree()[B.root()]);
     size4 shape(A.shape()[0], B.shape()[1]);
 
     bool A_trans = A_root.op.type==OPERATOR_TRANS_TYPE;
@@ -701,15 +785,15 @@ namespace detail
     else if(!A_trans && B_trans) type = OPERATOR_GEMM_NT_TYPE;
     else type = OPERATOR_GEMM_NN_TYPE;
 
-    array_expression res(A, B, op_element(OPERATOR_GEMM_TYPE_FAMILY, type), A.context(), A.dtype(), shape);
-    array_expression::node & res_root = const_cast<array_expression::node &>(res.tree()[res.root()]);
+    math_expression res(A, B, op_element(OPERATOR_GEMM_TYPE_FAMILY, type), A.context(), A.dtype(), shape);
+    math_expression::node & res_root = const_cast<math_expression::node &>(res.tree()[res.root()]);
     if(A_trans) res_root.lhs = A_root.lhs;
     if(B_trans) res_root.rhs = B_root.lhs;
     return res;
   }
 
   template<class T>
-  array_expression matvecprod(array const & A, T const & x)
+  math_expression matvecprod(array const & A, T const & x)
   {
     int_t M = A.shape()[0];
     int_t N = A.shape()[1];
@@ -717,11 +801,11 @@ namespace detail
   }
 
   template<class T>
-  array_expression matvecprod(array_expression const & A, T const & x)
+  math_expression matvecprod(math_expression const & A, T const & x)
   {
     int_t M = A.shape()[0];
     int_t N = A.shape()[1];
-    array_expression::node & A_root = const_cast<array_expression::node &>(A.tree()[A.root()]);
+    math_expression::node & A_root = const_cast<math_expression::node &>(A.tree()[A.root()]);
     bool A_trans = A_root.op.type==OPERATOR_TRANS_TYPE;
     while(A_root.lhs.type_family==COMPOSITE_OPERATOR_FAMILY){
         A_root = A.tree()[A_root.lhs.node_index];
@@ -729,7 +813,7 @@ namespace detail
     }
     if(A_trans)
     {
-      array_expression tmp(A, repmat(x, 1, M), op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_ELEMENT_PROD_TYPE), A.context(), A.dtype(), size4(N, M));
+      math_expression tmp(A, repmat(x, 1, M), op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_ELEMENT_PROD_TYPE), A.context(), A.dtype(), size4(N, M));
       //Remove trans
       tmp.tree()[tmp.root()].lhs = A.tree()[A.root()].lhs;
       return sum(tmp, 0);
@@ -741,15 +825,15 @@ namespace detail
 
 }
 
-array_expression reshape(array const & x, int_t shape0, int_t shape1)
-{  return array_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_RESHAPE_TYPE), x.context(), x.dtype(), size4(shape0, shape1)); }
+math_expression reshape(array const & x, int_t shape0, int_t shape1)
+{  return math_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_RESHAPE_TYPE), x.context(), x.dtype(), size4(shape0, shape1)); }
 
-array_expression reshape(array_expression const & x, int_t shape0, int_t shape1)
-{  return array_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_RESHAPE_TYPE), x.context(), x.dtype(), size4(shape0, shape1)); }
+math_expression reshape(math_expression const & x, int_t shape0, int_t shape1)
+{  return math_expression(x, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_RESHAPE_TYPE), x.context(), x.dtype(), size4(shape0, shape1)); }
 
 
 #define DEFINE_DOT(LTYPE, RTYPE) \
-array_expression dot(LTYPE const & x, RTYPE const & y)\
+math_expression dot(LTYPE const & x, RTYPE const & y)\
 {\
   if(x.nshape()<1 || y.nshape()<1){\
     return x*y;\
@@ -771,15 +855,15 @@ array_expression dot(LTYPE const & x, RTYPE const & y)\
 }
 
 DEFINE_DOT(array, array)
-DEFINE_DOT(array_expression, array)
-DEFINE_DOT(array, array_expression)
-DEFINE_DOT(array_expression, array_expression)
+DEFINE_DOT(math_expression, array)
+DEFINE_DOT(array, math_expression)
+DEFINE_DOT(math_expression, math_expression)
 
 #undef DEFINE_DOT
 
 
 #define DEFINE_NORM(TYPE)\
-array_expression norm(TYPE const & x, unsigned int order)\
+math_expression norm(TYPE const & x, unsigned int order)\
 {\
   assert(order > 0 && order < 3);\
   switch(order)\
@@ -790,10 +874,24 @@ array_expression norm(TYPE const & x, unsigned int order)\
 }
 
 DEFINE_NORM(array)
-DEFINE_NORM(array_expression)
+DEFINE_NORM(math_expression)
 
 #undef DEFINE_NORM
 
+/*--- Fusion ----*/
+math_expression fuse(math_expression const & x, math_expression const & y)
+{
+  assert(x.context()==y.context());
+  return math_expression(x, y, op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_FUSE), x.context(), x.dtype(), x.shape());
+}
+
+/*--- For loops ---*/
+ISAACAPI math_expression sfor(math_expression const & start, math_expression const & end, math_expression const & inc, math_expression const & x)
+{
+  return math_expression(x, make_tuple(x.context(), start, end, inc), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_SFOR_TYPE), x.context(), x.dtype(), x.shape());
+}
+
+
 /*--- Copy ----*/
 //---------------------------------------
 
diff --git a/lib/kernels/binder.cpp b/lib/kernels/binder.cpp
index 950f7339a..4ac3c4d22 100644
--- a/lib/kernels/binder.cpp
+++ b/lib/kernels/binder.cpp
@@ -3,32 +3,47 @@
 namespace isaac
 {
 
-symbolic_binder::~symbolic_binder(){ }
+symbolic_binder::~symbolic_binder()
+{
+}
 
 symbolic_binder::symbolic_binder() : current_arg_(0)
-{}
+{
+}
 
 unsigned int symbolic_binder::get()
-{ return current_arg_++; }
+{
+    return current_arg_++;
+}
 
-bind_to_handle::bind_to_handle()
-{ }
+//Sequential
+bind_sequential::bind_sequential()
+{
+}
 
-//
-bool bind_to_handle::bind(driver::Buffer const & ph)
-{ return memory.insert(std::make_pair(ph, current_arg_)).second; }
+bool bind_sequential::bind(driver::Buffer const & ph, bool)
+{
+    return memory.insert(std::make_pair(ph, current_arg_)).second;
+}
 
-unsigned int bind_to_handle::get(driver::Buffer const & ph)
-{ return bind(ph)?current_arg_++:memory.at(ph); }
+unsigned int bind_sequential::get(driver::Buffer const & ph, bool is_assigned)
+{
+    return bind(ph, is_assigned)?current_arg_++:memory.at(ph);
+}
 
-//
-bind_all_unique::bind_all_unique()
-{ }
+//Independent
+bind_independent::bind_independent()
+{
+}
 
-bool bind_all_unique::bind(driver::Buffer const &)
-{return true;}
+bool bind_independent::bind(driver::Buffer const & ph, bool is_assigned)
+{
+    return is_assigned?true:memory.insert(std::make_pair(ph, current_arg_)).second;
+}
 
-unsigned int bind_all_unique::get(driver::Buffer const &)
-{ return current_arg_++;}
+unsigned int bind_independent::get(driver::Buffer const & ph, bool is_assigned)
+{
+    return bind(ph, is_assigned)?current_arg_++:memory.at(ph);
+}
 
 }
diff --git a/lib/kernels/mapped_object.cpp b/lib/kernels/mapped_object.cpp
index 4d08f3b20..f58c2744f 100644
--- a/lib/kernels/mapped_object.cpp
+++ b/lib/kernels/mapped_object.cpp
@@ -1,14 +1,14 @@
+#include <cassert>
+#include <iostream>
 #include <set>
 #include <string>
 
-#include <iostream>
-
+#include "isaac/tuple.h"
 #include "isaac/kernels/mapped_object.h"
 #include "isaac/kernels/parse.h"
 #include "isaac/kernels/stream.h"
 #include "isaac/symbolic/expression.h"
 
-#include <string>
 #include "find_and_replace.hpp"
 #include "to_string.hpp"
 
@@ -51,15 +51,18 @@ void mapped_object::register_attribute(std::string & attribute, std::string cons
   keywords_[key] = attribute;
 }
 
-mapped_object::node_info::node_info(mapping_type const * _mapping, isaac::array_expression const * _array_expression, size_t _root_idx) :
-    mapping(_mapping), array_expression(_array_expression), root_idx(_root_idx) { }
+mapped_object::node_info::node_info(mapping_type const * _mapping, isaac::math_expression const * _math_expression, size_t _root_idx) :
+    mapping(_mapping), math_expression(_math_expression), root_idx(_root_idx) { }
 
-mapped_object::mapped_object(std::string const & scalartype, unsigned int id, std::string const & type_key) : type_key_(type_key)
+mapped_object::mapped_object(std::string const & scalartype, std::string const & name, std::string const & type_key) : type_key_(type_key), name_(name)
 {
   register_attribute(scalartype_, "#scalartype", scalartype);
-  register_attribute(name_, "#name", "obj" + tools::to_string(id));
+  keywords_["#name"] = name;
 }
 
+mapped_object::mapped_object(std::string const & scalartype, unsigned int id, std::string const & type_key) : mapped_object(scalartype, "obj" + tools::to_string(id), type_key)
+{ }
+
 mapped_object::~mapped_object()
 { }
 
@@ -89,18 +92,28 @@ std::string mapped_object::evaluate(std::map<std::string, std::string> const & a
   return process(accessors.at(type_key_));
 }
 
+mapped_object& get(math_expression::container_type const & tree, size_t root, mapping_type const & mapping, size_t idx)
+{
+  for(unsigned int i = 0 ; i < idx ; ++i){
+      math_expression::node node = tree[root];
+      if(node.rhs.type_family==COMPOSITE_OPERATOR_FAMILY)
+        root = node.rhs.node_index;
+      else
+        return *(mapping.at(std::make_pair(root, RHS_NODE_TYPE)));
+  }
+  return *(mapping.at(std::make_pair(root, LHS_NODE_TYPE)));
+}
 
 binary_leaf::binary_leaf(mapped_object::node_info info) : info_(info){ }
 
-void binary_leaf::process_recursive(kernel_generation_stream & stream, leaf_t leaf, std::map<std::string, std::string> const & accessors)
+void binary_leaf::process_recursive(kernel_generation_stream & stream, leaf_t leaf, std::map<std::string, std::string> const & accessors, std::set<std::string> & already_fetched)
 {
-  std::set<std::string> already_fetched;
-  process(stream, leaf, accessors, *info_.array_expression, info_.root_idx, *info_.mapping, already_fetched);
+  process(stream, leaf, accessors, *info_.math_expression, info_.root_idx, *info_.mapping, already_fetched);
 }
 
 std::string binary_leaf::evaluate_recursive(leaf_t leaf, std::map<std::string, std::string> const & accessors)
 {
-  return evaluate(leaf, accessors, *info_.array_expression, info_.root_idx, *info_.mapping);
+  return evaluate(leaf, accessors, *info_.math_expression, info_.root_idx, *info_.mapping);
 }
 
 
@@ -114,11 +127,11 @@ mapped_dot::mapped_dot(std::string const & scalartype, unsigned int id, node_inf
 size_t mapped_dot::root_idx() const
 { return info_.root_idx; }
 
-isaac::array_expression const & mapped_dot::array_expression() const
-{ return *info_.array_expression; }
+isaac::math_expression const & mapped_dot::math_expression() const
+{ return *info_.math_expression; }
 
-array_expression::node mapped_dot::root_node() const
-{ return array_expression().tree()[root_idx()]; }
+math_expression::node mapped_dot::root_node() const
+{ return math_expression().tree()[root_idx()]; }
 
 bool mapped_dot::is_index_dot() const
 {
@@ -131,7 +144,7 @@ bool mapped_dot::is_index_dot() const
 
 op_element mapped_dot::root_op() const
 {
-    return info_.array_expression->tree()[info_.root_idx].op;
+    return info_.math_expression->tree()[info_.root_idx].op;
 }
 
 
@@ -155,15 +168,11 @@ void mapped_host_scalar::preprocess(std::string & str) const
   replace_macro(str, "$VALUE", Morph());
 }
 
-
-mapped_host_scalar::mapped_host_scalar(std::string const & scalartype, unsigned int id) : mapped_object(scalartype, id, "host_scalar"){ }
+//
+mapped_placeholder::mapped_placeholder(unsigned int level) : mapped_object("int", "sforidx" + tools::to_string(level), "placeholder"){}
 
 //
-mapped_tuple::mapped_tuple(std::string const & scalartype, unsigned int id, size_t size) : mapped_object(scalartype, id, "tuple"+tools::to_string(size)), size_(size), names_(size)
-{
-  for(size_t i = 0 ; i < size_ ; ++i)
-    register_attribute(names_[i], "#tuplearg"+tools::to_string(i), name_ + tools::to_string(i));
-}
+mapped_host_scalar::mapped_host_scalar(std::string const & scalartype, unsigned int id) : mapped_object(scalartype, id, "host_scalar"){ }
 
 //
 mapped_handle::mapped_handle(std::string const & scalartype, unsigned int id, std::string const & type_key) : mapped_object(scalartype, id, type_key)
@@ -230,22 +239,34 @@ mapped_array::mapped_array(std::string const & scalartype, unsigned int id, char
 void mapped_vdiag::postprocess(std::string &res) const
 {
   std::map<std::string, std::string> accessors;
-  tools::find_and_replace(res, "#diag_offset", isaac::evaluate(RHS_NODE_TYPE, accessors, *info_.array_expression, info_.root_idx, *info_.mapping));
+  tools::find_and_replace(res, "#diag_offset", isaac::evaluate(RHS_NODE_TYPE, accessors, *info_.math_expression, info_.root_idx, *info_.mapping));
   accessors["array1"] = res;
   accessors["host_scalar"] = res;
-  res = isaac::evaluate(LHS_NODE_TYPE, accessors, *info_.array_expression, info_.root_idx, *info_.mapping);
+  res = isaac::evaluate(LHS_NODE_TYPE, accessors, *info_.math_expression, info_.root_idx, *info_.mapping);
 }
 
 mapped_vdiag::mapped_vdiag(std::string const & scalartype, unsigned int id, node_info info) : mapped_object(scalartype, id, "vdiag"), binary_leaf(info){}
 
+//
+void mapped_array_access::postprocess(std::string &res) const
+{
+  std::map<std::string, std::string> accessors;
+  tools::find_and_replace(res, "#index", isaac::evaluate(RHS_NODE_TYPE, accessors, *info_.math_expression, info_.root_idx, *info_.mapping));
+  accessors["array1"] = res;
+  accessors["array2"] = res;
+  res = isaac::evaluate(LHS_NODE_TYPE, accessors, *info_.math_expression, info_.root_idx, *info_.mapping);
+}
+
+mapped_array_access::mapped_array_access(std::string const & scalartype, unsigned int id, node_info info) : mapped_object(scalartype, id, "array_access"), binary_leaf(info)
+{ }
 
 //
 void mapped_matrix_row::postprocess(std::string &res) const
 {
   std::map<std::string, std::string> accessors;
-  tools::find_and_replace(res, "#row", isaac::evaluate(RHS_NODE_TYPE, accessors, *info_.array_expression, info_.root_idx, *info_.mapping));
+  tools::find_and_replace(res, "#row", isaac::evaluate(RHS_NODE_TYPE, accessors, *info_.math_expression, info_.root_idx, *info_.mapping));
   accessors["array2"] = res;
-  res = isaac::evaluate(LHS_NODE_TYPE, accessors, *info_.array_expression, info_.root_idx, *info_.mapping);
+  res = isaac::evaluate(LHS_NODE_TYPE, accessors, *info_.math_expression, info_.root_idx, *info_.mapping);
 }
 
 mapped_matrix_row::mapped_matrix_row(std::string const & scalartype, unsigned int id, node_info info) : mapped_object(scalartype, id, "matrix_row"), binary_leaf(info)
@@ -255,34 +276,45 @@ mapped_matrix_row::mapped_matrix_row(std::string const & scalartype, unsigned in
 void mapped_matrix_column::postprocess(std::string &res) const
 {
   std::map<std::string, std::string> accessors;
-  tools::find_and_replace(res, "#column", isaac::evaluate(RHS_NODE_TYPE, accessors, *info_.array_expression, info_.root_idx, *info_.mapping));
+  tools::find_and_replace(res, "#column", isaac::evaluate(RHS_NODE_TYPE, accessors, *info_.math_expression, info_.root_idx, *info_.mapping));
   accessors["array2"] = res;
-  res = isaac::evaluate(LHS_NODE_TYPE, accessors, *info_.array_expression, info_.root_idx, *info_.mapping);
+  res = isaac::evaluate(LHS_NODE_TYPE, accessors, *info_.math_expression, info_.root_idx, *info_.mapping);
 }
 
 mapped_matrix_column::mapped_matrix_column(std::string const & scalartype, unsigned int id, node_info info) : mapped_object(scalartype, id, "matrix_column"), binary_leaf(info)
 { }
 
+
+
+
 //
 char mapped_repeat::get_type(node_info const & info)
 {
-  repeat_infos const & infos = info.array_expression->tree()[info.root_idx].rhs.tuple;
-  if(infos.sub1>1 && infos.sub2==1)
+  math_expression::container_type const & tree = info.math_expression->tree();
+  size_t tuple_root = tree[info.root_idx].rhs.node_index;
+
+  int sub0 = tuple_get(tree, tuple_root, 2);
+  int sub1 = tuple_get(tree, tuple_root, 3);
+  if(sub0>1 && sub1==1)
     return 'c';
-  else if(infos.sub1==1 && infos.sub2>1)
+  else if(sub0==1 && sub1>1)
     return 'r';
   else
     return 'm';
 }
 
+
+
 void mapped_repeat::postprocess(std::string &res) const
 {
   std::map<std::string, std::string> accessors;
-  mapped_object& args = *(info_.mapping->at(std::make_pair(info_.root_idx,RHS_NODE_TYPE)));
-  tools::find_and_replace(res, "#tuplearg0", args.process("#tuplearg0"));
-  tools::find_and_replace(res, "#tuplearg1", args.process("#tuplearg1"));
-  tools::find_and_replace(res, "#tuplearg2", args.process("#tuplearg2"));
-  tools::find_and_replace(res, "#tuplearg3", args.process("#tuplearg3"));
+  math_expression::container_type const & tree = info_.math_expression->tree();
+  size_t tuple_root = tree[info_.root_idx].rhs.node_index;
+
+  tools::find_and_replace(res, "#rep0", get(tree, tuple_root, *info_.mapping, 0).process("#name"));
+  tools::find_and_replace(res, "#rep1", get(tree, tuple_root, *info_.mapping, 1).process("#name"));
+  tools::find_and_replace(res, "#sub0", get(tree, tuple_root, *info_.mapping, 2).process("#name"));
+  tools::find_and_replace(res, "#sub1", get(tree, tuple_root, *info_.mapping, 3).process("#name"));
 
   struct MorphValue : public MorphBase
   {
@@ -303,7 +335,7 @@ void mapped_repeat::postprocess(std::string &res) const
   replace_macro(res, "$VALUE", MorphValue(type_));
   accessors["array1"] = res;
   accessors["array2"] = res;
-  res = isaac::evaluate(LHS_NODE_TYPE, accessors, *info_.array_expression, info_.root_idx, *info_.mapping);
+  res = isaac::evaluate(LHS_NODE_TYPE, accessors, *info_.math_expression, info_.root_idx, *info_.mapping);
 }
 
 mapped_repeat::mapped_repeat(std::string const & scalartype, unsigned int id, node_info info) : mapped_object(scalartype, id, "repeat"), binary_leaf(info), type_(get_type(info))
@@ -315,9 +347,9 @@ mapped_repeat::mapped_repeat(std::string const & scalartype, unsigned int id, no
 void mapped_matrix_diag::postprocess(std::string &res) const
 {
   std::map<std::string, std::string> accessors;
-  tools::find_and_replace(res, "#diag_offset", isaac::evaluate(RHS_NODE_TYPE, accessors, *info_.array_expression, info_.root_idx, *info_.mapping));
+  tools::find_and_replace(res, "#diag_offset", isaac::evaluate(RHS_NODE_TYPE, accessors, *info_.math_expression, info_.root_idx, *info_.mapping));
   accessors["array2"] = res;
-  res = isaac::evaluate(LHS_NODE_TYPE, accessors, *info_.array_expression, info_.root_idx, *info_.mapping);
+  res = isaac::evaluate(LHS_NODE_TYPE, accessors, *info_.math_expression, info_.root_idx, *info_.mapping);
 }
 
 mapped_matrix_diag::mapped_matrix_diag(std::string const & scalartype, unsigned int id, node_info info) : mapped_object(scalartype, id, "matrix_diag"), binary_leaf(info)
@@ -333,7 +365,7 @@ void mapped_outer::postprocess(std::string &res) const
       {
         std::map<std::string, std::string> accessors;
         accessors["array1"] = "$VALUE{"+i+"}";
-        return isaac::evaluate(leaf_, accessors, *i_.array_expression, i_.root_idx, *i_.mapping);
+        return isaac::evaluate(leaf_, accessors, *i_.math_expression, i_.root_idx, *i_.mapping);
       }
       std::string operator()(std::string const &, std::string const &) const{return "";}
     private:
diff --git a/lib/kernels/parse.cpp b/lib/kernels/parse.cpp
index 8ec3a0f13..8d7068485 100644
--- a/lib/kernels/parse.cpp
+++ b/lib/kernels/parse.cpp
@@ -1,5 +1,7 @@
 #include <cstring>
 
+#include "to_string.hpp"
+
 #include "isaac/array.h"
 #include "isaac/kernels/parse.h"
 #include "isaac/exception/operation_not_supported.h"
@@ -12,12 +14,12 @@ namespace detail
 
 
 
-  bool is_scalar_dot(array_expression::node const & node)
+  bool is_scalar_dot(math_expression::node const & node)
   {
     return node.op.type_family==OPERATOR_VECTOR_DOT_TYPE_FAMILY;
   }
 
-  bool is_vector_dot(array_expression::node const & node)
+  bool is_vector_dot(math_expression::node const & node)
   {
     return node.op.type_family==OPERATOR_ROWS_DOT_TYPE_FAMILY
         || node.op.type_family==OPERATOR_COLUMNS_DOT_TYPE_FAMILY;
@@ -76,6 +78,7 @@ namespace detail
         || op.type==OPERATOR_REPEAT_TYPE
         || op.type==OPERATOR_MATRIX_ROW_TYPE
         || op.type==OPERATOR_MATRIX_COLUMN_TYPE
+        || op.type==OPERATOR_ACCESS_INDEX_TYPE
         || op.type==OPERATOR_OUTER_PROD_TYPE
         || op.type_family==OPERATOR_VECTOR_DOT_TYPE_FAMILY
         || op.type_family==OPERATOR_ROWS_DOT_TYPE_FAMILY
@@ -120,29 +123,29 @@ namespace detail
 filter_fun::filter_fun(pred_t pred, std::vector<size_t> & out) : pred_(pred), out_(out)
 { }
 
-void filter_fun::operator()(isaac::array_expression const & array_expression, size_t root_idx, leaf_t) const
+void filter_fun::operator()(isaac::math_expression const & math_expression, size_t root_idx, leaf_t leaf) const
 {
-  array_expression::node const * root_node = &array_expression.tree()[root_idx];
-  if (pred_(*root_node))
+  math_expression::node const * root_node = &math_expression.tree()[root_idx];
+  if (leaf==PARENT_NODE_TYPE && pred_(*root_node))
     out_.push_back(root_idx);
 }
 
 //
-std::vector<size_t> filter_nodes(bool (*pred)(array_expression::node const & node), isaac::array_expression const & array_expression, bool inspect)
+std::vector<size_t> filter_nodes(bool (*pred)(math_expression::node const & node), isaac::math_expression const & math_expression, size_t root, bool inspect)
 {
   std::vector<size_t> res;
-  traverse(array_expression, array_expression.root(), filter_fun(pred, res), inspect);
+  traverse(math_expression, root, filter_fun(pred, res), inspect);
   return res;
 }
 
 //
-filter_elements_fun::filter_elements_fun(array_expression_node_subtype subtype, std::vector<lhs_rhs_element> & out) :
+filter_elements_fun::filter_elements_fun(math_expression_node_subtype subtype, std::vector<lhs_rhs_element> & out) :
   subtype_(subtype), out_(out)
 { }
 
-void filter_elements_fun::operator()(isaac::array_expression const & array_expression, size_t root_idx, leaf_t) const
+void filter_elements_fun::operator()(isaac::math_expression const & math_expression, size_t root_idx, leaf_t) const
 {
-  array_expression::node const * root_node = &array_expression.tree()[root_idx];
+  math_expression::node const * root_node = &math_expression.tree()[root_idx];
   if (root_node->lhs.subtype==subtype_)
     out_.push_back(root_node->lhs);
   if (root_node->rhs.subtype==subtype_)
@@ -150,10 +153,10 @@ void filter_elements_fun::operator()(isaac::array_expression const & array_expre
 }
 
 
-std::vector<lhs_rhs_element> filter_elements(array_expression_node_subtype subtype, isaac::array_expression const & array_expression)
+std::vector<lhs_rhs_element> filter_elements(math_expression_node_subtype subtype, isaac::math_expression const & math_expression)
 {
   std::vector<lhs_rhs_element> res;
-  traverse(array_expression, array_expression.root(), filter_elements_fun(subtype, res), true);
+  traverse(math_expression, math_expression.root(), filter_elements_fun(subtype, res), true);
   return res;
 }
 
@@ -199,7 +202,6 @@ const char * evaluate(operation_node_type type)
   case OPERATOR_ELEMENT_PROD_TYPE : return "*";
   case OPERATOR_DIV_TYPE : return "/";
   case OPERATOR_ELEMENT_DIV_TYPE : return "/";
-  case OPERATOR_ACCESS_TYPE : return "[]";
 
     //Relational
   case OPERATOR_NEGATE_TYPE: return "!";
@@ -225,6 +227,10 @@ const char * evaluate(operation_node_type type)
   case OPERATOR_MATRIX_ROW_TYPE : return "row";
   case OPERATOR_MATRIX_COLUMN_TYPE : return "col";
   case OPERATOR_PAIR_TYPE: return "pair";
+  case OPERATOR_ACCESS_INDEX_TYPE: return "access";
+
+    //FOR
+  case OPERATOR_SFOR_TYPE: return "sfor";
 
   default : throw operation_not_supported_exception("Unsupported operator");
   }
@@ -234,26 +240,29 @@ evaluate_expression_traversal::evaluate_expression_traversal(std::map<std::strin
   accessors_(accessors), str_(str), mapping_(mapping)
 { }
 
-void evaluate_expression_traversal::call_before_expansion(isaac::array_expression const & array_expression, std::size_t root_idx) const
+void evaluate_expression_traversal::call_before_expansion(isaac::math_expression const & math_expression, std::size_t root_idx) const
 {
-  array_expression::node const & root_node = array_expression.tree()[root_idx];
+  math_expression::node const & root_node = math_expression.tree()[root_idx];
   if(detail::is_cast(root_node.op))
     str_ += mapping_.at(std::make_pair(root_idx, PARENT_NODE_TYPE))->evaluate(accessors_);
   else if (( (root_node.op.type_family==OPERATOR_UNARY_TYPE_FAMILY&&root_node.op.type!=OPERATOR_ADD_TYPE) || detail::is_elementwise_function(root_node.op))
       && !detail::is_node_leaf(root_node.op))
     str_+=evaluate(root_node.op.type);
-  str_+="(";
+  if(root_node.op.type!=OPERATOR_FUSE)
+    str_+="(";
 
 }
 
-void evaluate_expression_traversal::call_after_expansion(array_expression const & /*array_expression*/, std::size_t /*root_idx*/) const
+void evaluate_expression_traversal::call_after_expansion(math_expression const & math_expression, std::size_t root_idx) const
 {
-  str_+=")";
+  math_expression::node const & root_node = math_expression.tree()[root_idx];
+  if(root_node.op.type!=OPERATOR_FUSE)
+    str_+=")";
 }
 
-void evaluate_expression_traversal::operator()(isaac::array_expression const & array_expression, std::size_t root_idx, leaf_t leaf) const
+void evaluate_expression_traversal::operator()(isaac::math_expression const & math_expression, std::size_t root_idx, leaf_t leaf) const
 {
-  array_expression::node const & root_node = array_expression.tree()[root_idx];
+  math_expression::node const & root_node = math_expression.tree()[root_idx];
   mapping_type::key_type key = std::make_pair(root_idx, leaf);
   if (leaf==PARENT_NODE_TYPE)
   {
@@ -272,53 +281,59 @@ void evaluate_expression_traversal::operator()(isaac::array_expression const & a
     if (leaf==LHS_NODE_TYPE)
     {
       if (root_node.lhs.type_family!=COMPOSITE_OPERATOR_FAMILY)
-        str_ += mapping_.at(key)->evaluate(accessors_);
+      {
+        if (root_node.lhs.subtype==FOR_LOOP_INDEX_TYPE)
+          str_ += "sforidx" + tools::to_string(root_node.lhs.for_idx.level);
+        else
+          str_ += mapping_.at(key)->evaluate(accessors_);
+      }
     }
 
     if (leaf==RHS_NODE_TYPE)
     {
       if (root_node.rhs.type_family!=COMPOSITE_OPERATOR_FAMILY)
-        str_ += mapping_.at(key)->evaluate(accessors_);
+      {
+        if (root_node.rhs.subtype==FOR_LOOP_INDEX_TYPE)
+          str_ += "sforidx" + tools::to_string(root_node.rhs.for_idx.level);
+        else
+          str_ += mapping_.at(key)->evaluate(accessors_);
+      }
     }
   }
 }
 
 
 std::string evaluate(leaf_t leaf, std::map<std::string, std::string> const & accessors,
-                            isaac::array_expression const & array_expression, std::size_t root_idx, mapping_type const & mapping)
+                            isaac::math_expression const & math_expression, std::size_t root_idx, mapping_type const & mapping)
 {
   std::string res;
   evaluate_expression_traversal traversal_functor(accessors, res, mapping);
-  array_expression::node const & root_node = array_expression.tree()[root_idx];
+  math_expression::node const & root_node = math_expression.tree()[root_idx];
 
   if (leaf==RHS_NODE_TYPE)
   {
     if (root_node.rhs.type_family==COMPOSITE_OPERATOR_FAMILY)
-      traverse(array_expression, root_node.rhs.node_index, traversal_functor, false);
+      traverse(math_expression, root_node.rhs.node_index, traversal_functor, false);
     else
-      traversal_functor(array_expression, root_idx, leaf);
+      traversal_functor(math_expression, root_idx, leaf);
   }
   else if (leaf==LHS_NODE_TYPE)
   {
     if (root_node.lhs.type_family==COMPOSITE_OPERATOR_FAMILY)
-      traverse(array_expression, root_node.lhs.node_index, traversal_functor, false);
+      traverse(math_expression, root_node.lhs.node_index, traversal_functor, false);
     else
-      traversal_functor(array_expression, root_idx, leaf);
+      traversal_functor(math_expression, root_idx, leaf);
   }
   else
-    traverse(array_expression, root_idx, traversal_functor, false);
+    traverse(math_expression, root_idx, traversal_functor, false);
 
   return res;
 }
 
 void evaluate(kernel_generation_stream & stream, leaf_t leaf, std::map<std::string, std::string> const & accessors,
-                     expressions_tuple const & expressions, std::vector<mapping_type> const & mappings)
+                     math_expression const & x, mapping_type const & mapping)
 {
-  expressions_tuple::data_type::const_iterator sit;
-  std::vector<mapping_type>::const_iterator mit;
-
-  for (mit = mappings.begin(), sit = expressions.data().begin(); sit != expressions.data().end(); ++mit, ++sit)
-    stream << evaluate(leaf, accessors, **sit, (*sit)->root(), *mit) << ";" << std::endl;
+  stream << evaluate(leaf, accessors, x, x.root(), mapping) << std::endl;
 }
 
 process_traversal::process_traversal(std::map<std::string, std::string> const & accessors, kernel_generation_stream & stream,
@@ -326,7 +341,7 @@ process_traversal::process_traversal(std::map<std::string, std::string> const &
   accessors_(accessors),  stream_(stream), mapping_(mapping), already_processed_(already_processed)
 { }
 
-void process_traversal::operator()(array_expression const & /*array_expression*/, std::size_t root_idx, leaf_t leaf) const
+void process_traversal::operator()(math_expression const & /*math_expression*/, std::size_t root_idx, leaf_t leaf) const
 {
   mapping_type::const_iterator it = mapping_.find(std::make_pair(root_idx, leaf));
   if (it!=mapping_.end())
@@ -336,59 +351,52 @@ void process_traversal::operator()(array_expression const & /*array_expression*/
 
     if(accessors_.find(name)!=accessors_.end() && already_processed_.insert(name).second)
       for(std::map<std::string, std::string>::const_iterator itt = accessors_.lower_bound(name) ; itt != accessors_.upper_bound(name) ; ++itt)
-      {
         stream_ << obj->process(itt->second) << std::endl;
-      }
 
     std::string key = obj->type_key();
     if(accessors_.find(key)!=accessors_.end() && already_processed_.insert(name).second)
       for(std::map<std::string, std::string>::const_iterator itt = accessors_.lower_bound(key) ; itt != accessors_.upper_bound(key) ; ++itt)
-      {
         stream_ << obj->process(itt->second) << std::endl;
-      }
   }
 }
 
 
 void process(kernel_generation_stream & stream, leaf_t leaf, std::map<std::string, std::string> const & accessors,
-                    isaac::array_expression const & array_expression, size_t root_idx, mapping_type const & mapping, std::set<std::string> & already_processed)
+                    isaac::math_expression const & math_expression, size_t root_idx, mapping_type const & mapping, std::set<std::string> & already_processed)
 {
   process_traversal traversal_functor(accessors, stream, mapping, already_processed);
-  array_expression::node const & root_node = array_expression.tree()[root_idx];
+  math_expression::node const & root_node = math_expression.tree()[root_idx];
 
   if (leaf==RHS_NODE_TYPE)
   {
     if (root_node.rhs.type_family==COMPOSITE_OPERATOR_FAMILY)
-      traverse(array_expression, root_node.rhs.node_index, traversal_functor, true);
+      traverse(math_expression, root_node.rhs.node_index, traversal_functor, true);
     else
-      traversal_functor(array_expression, root_idx, leaf);
+      traversal_functor(math_expression, root_idx, leaf);
   }
   else if (leaf==LHS_NODE_TYPE)
   {
     if (root_node.lhs.type_family==COMPOSITE_OPERATOR_FAMILY)
-      traverse(array_expression, root_node.lhs.node_index, traversal_functor, true);
+      traverse(math_expression, root_node.lhs.node_index, traversal_functor, true);
     else
-      traversal_functor(array_expression, root_idx, leaf);
+      traversal_functor(math_expression, root_idx, leaf);
   }
   else
   {
-    traverse(array_expression, root_idx, traversal_functor, true);
+    traverse(math_expression, root_idx, traversal_functor, true);
   }
 }
 
-void process(kernel_generation_stream & stream, leaf_t leaf, std::map<std::string, std::string> const & accessors,
-                    expressions_tuple const & expressions, std::vector<mapping_type> const & mappings)
-{
-  expressions_tuple::data_type::const_iterator sit;
-  std::vector<mapping_type>::const_iterator mit;
-  std::set<std::string> already_processed;
 
-  for (mit = mappings.begin(), sit = expressions.data().begin(); sit != expressions.data().end(); ++mit, ++sit)
-    process(stream, leaf, accessors, **sit, (*sit)->root(), *mit, already_processed);
+void process(kernel_generation_stream & stream, leaf_t leaf, std::map<std::string, std::string> const & accessors,
+                    math_expression const & x, mapping_type const & mapping)
+{
+  std::set<std::string> processed;
+  process(stream, leaf, accessors, x, x.root(), mapping, processed);
 }
 
 
-void array_expression_representation_functor::append_id(char * & ptr, unsigned int val)
+void math_expression_representation_functor::append_id(char * & ptr, unsigned int val)
 {
   if (val==0)
     *ptr++='0';
@@ -400,35 +408,44 @@ void array_expression_representation_functor::append_id(char * & ptr, unsigned i
     }
 }
 
-void array_expression_representation_functor::append(driver::Buffer const & h, numeric_type dtype, char prefix) const
-{
-  *ptr_++=prefix;
-  *ptr_++=(char)dtype;
-  append_id(ptr_, binder_.get(h));
-}
+//void math_expression_representation_functor::append(driver::Buffer const & h, numeric_type dtype, char prefix, bool is_assigned) const
+//{
+//  *ptr_++=prefix;
+//  *ptr_++=(char)dtype;
+//  append_id(ptr_, binder_.get(h, is_assigned));
+//}
 
-void array_expression_representation_functor::append(lhs_rhs_element const & lhs_rhs) const
+void math_expression_representation_functor::append(lhs_rhs_element const & lhs_rhs, bool is_assigned) const
 {
   if(lhs_rhs.subtype==DENSE_ARRAY_TYPE)
-    append(lhs_rhs.array->data(), lhs_rhs.array->dtype(), (char)(((int)'0')+((int)(lhs_rhs.array->shape()[0]>1) + (int)(lhs_rhs.array->shape()[1]>1))));
+  {
+      char prefix = (char)(((int)'0')+((int)(lhs_rhs.array->shape()[0]>1) + (int)(lhs_rhs.array->shape()[1]>1)));
+      numeric_type dtype = lhs_rhs.array->dtype();
+      driver::Buffer const & data = lhs_rhs.array->data();
+
+      *ptr_++=prefix;
+      *ptr_++=(char)dtype;
+
+      append_id(ptr_, binder_.get(data, is_assigned));
+  }
 }
 
-array_expression_representation_functor::array_expression_representation_functor(symbolic_binder & binder, char *& ptr) : binder_(binder), ptr_(ptr){ }
+math_expression_representation_functor::math_expression_representation_functor(symbolic_binder & binder, char *& ptr) : binder_(binder), ptr_(ptr){ }
 
-void array_expression_representation_functor::append(char*& p, const char * str) const
+void math_expression_representation_functor::append(char*& p, const char * str) const
 {
   std::size_t n = std::strlen(str);
   std::memcpy(p, str, n);
   p+=n;
 }
 
-void array_expression_representation_functor::operator()(isaac::array_expression const & array_expression, std::size_t root_idx, leaf_t leaf_t) const
+void math_expression_representation_functor::operator()(isaac::math_expression const & math_expression, std::size_t root_idx, leaf_t leaf_t) const
 {
-  array_expression::node const & root_node = array_expression.tree()[root_idx];
+  math_expression::node const & root_node = math_expression.tree()[root_idx];
   if (leaf_t==LHS_NODE_TYPE && root_node.lhs.type_family != COMPOSITE_OPERATOR_FAMILY)
-    append(root_node.lhs);
+    append(root_node.lhs, detail::is_assignment(root_node.op));
   else if (leaf_t==RHS_NODE_TYPE && root_node.rhs.type_family != COMPOSITE_OPERATOR_FAMILY)
-    append(root_node.rhs);
+    append(root_node.rhs, false);
   else if (leaf_t==PARENT_NODE_TYPE)
     append_id(ptr_,root_node.op.type);
 }
diff --git a/lib/kernels/templates/axpy.cpp b/lib/kernels/templates/axpy.cpp
index a92228b17..344714e70 100644
--- a/lib/kernels/templates/axpy.cpp
+++ b/lib/kernels/templates/axpy.cpp
@@ -9,6 +9,7 @@
 #include "tools/loop.hpp"
 #include "tools/vector_types.hpp"
 #include "tools/arguments.hpp"
+#include "isaac/symbolic/io.h"
 
 #include <string>
 
@@ -21,17 +22,18 @@ axpy_parameters::axpy_parameters(unsigned int _simd_width,
                        unsigned int _group_size, unsigned int _num_groups,
                        fetching_policy_type _fetching_policy) :
       base::parameters_type(_simd_width, _group_size, 1, 1), num_groups(_num_groups), fetching_policy(_fetching_policy)
-{ }
+{
+}
 
 
-int axpy::is_invalid_impl(driver::Device const &, expressions_tuple const &) const
+int axpy::is_invalid_impl(driver::Device const &, math_expression const &) const
 {
   if (p_.fetching_policy==FETCH_FROM_LOCAL)
     return TEMPLATE_INVALID_FETCHING_POLICY_TYPE;
   return TEMPLATE_VALID;
 }
 
-std::string axpy::generate_impl(std::string const & suffix, expressions_tuple const & expressions, driver::Device const & device, std::vector<mapping_type> const & mappings) const
+std::string axpy::generate_impl(std::string const & suffix, math_expression const & expressions, driver::Device const & device, mapping_type const & mappings) const
 {
   driver::backend_type backend = device.backend();
   std::string _size_t = size_type(device);
@@ -40,6 +42,10 @@ std::string axpy::generate_impl(std::string const & suffix, expressions_tuple co
   std::string str_simd_width = tools::to_string(p_.simd_width);
   std::string dtype = append_width("#scalartype",p_.simd_width);
 
+
+  std::vector<size_t> assigned_scalar = filter_nodes([](math_expression::node const & node) {
+                                                        return  detail::is_assignment(node.op) && node.lhs.subtype==DENSE_ARRAY_TYPE && node.lhs.array->nshape()==0;
+                                                        }, expressions, expressions.root(), true);
   switch(backend)
   {
     case driver::CUDA:
@@ -64,36 +70,103 @@ std::string axpy::generate_impl(std::string const & suffix, expressions_tuple co
   stream << "for(" << _size_t << " i = " << init << "; i < " << upper_bound << "; i += " << inc << ")" << std::endl;
   stream << "{" << std::endl;
   stream.inc_tab();
-  process(stream, PARENT_NODE_TYPE, {{"array1", dtype + " #namereg = #pointer[i*#stride];"},
-                                     {"matrix_row", "#scalartype #namereg = $VALUE{#row*#stride, i};"},
-                                     {"matrix_column", "#scalartype #namereg = $VALUE{i*#stride,#column};"},
-                                     {"matrix_diag", "#scalartype #namereg = #pointer[#diag_offset<0?$OFFSET{(i - #diag_offset)*#stride, i}:$OFFSET{i*#stride, (i + #diag_offset)}];"}}, expressions, mappings);
 
 
-  evaluate(stream, PARENT_NODE_TYPE, {{"array0", "#namereg"}, {"array1", "#namereg"},
-                                      {"matrix_row", "#namereg"}, {"matrix_column", "#namereg"}, {"matrix_diag", "#namereg"},
-                                      {"cast", CastPrefix(backend, dtype).get()}, {"host_scalar", p_.simd_width==1?"#name": InitPrefix(backend, dtype).get() + "(#name)"}}, expressions, mappings);
+  math_expression::container_type const & tree = expressions.tree();
+  std::vector<std::size_t> sfors = filter_nodes([](math_expression::node const & node){return node.op.type==OPERATOR_SFOR_TYPE;}, expressions, expressions.root(), true);
+//  std::cout << sfors.size() << std::endl;
+
+  for(unsigned int i = 0 ; i < sfors.size() ; ++i)
+  {
+    std::string info[3];
+    int idx =  sfors[i];
+    for(int i = 0 ; i < 2 ; ++i){
+        idx = tree[idx].rhs.node_index;
+        info[i] = evaluate(LHS_NODE_TYPE, {{"placeholder", "#name"}}, expressions, idx, mappings);
+
+    }
+    info[2] = evaluate(RHS_NODE_TYPE, {{"placeholder", "#name"}}, expressions, idx, mappings);
+    info[0] = info[0].substr(1, info[0].size()-2);
+    stream << "for(int " << info[0] << " ; " << info[1] << "; " << info[2] << ")" << std::endl;
+
+//    stream << "int sforidx0 = 0 ;" << std::endl;
+  }
+
+  if(sfors.size()){
+    stream << "{" << std::endl;
+    stream.inc_tab();
+  }
+
+  size_t root = expressions.root();
+  if(sfors.size())
+      root = tree[sfors.back()].lhs.node_index;
+
+  std::vector<std::size_t> assigned = filter_nodes([](math_expression::node const & node){return detail::is_assignment(node.op);}, expressions, root, true);
+  std::set<std::string> processed;
+
+  //Declares register to store results
+  for(std::size_t idx: assigned)
+  {
+    process(stream, LHS_NODE_TYPE, {{"array1", dtype + " #namereg;"}, {"matrix_row", "#scalartype #namereg;"},
+                                       {"matrix_column", "#scalartype #namereg;"},  {"matrix_diag", "#scalartype #namereg;"}}, expressions, idx, mappings, processed);
+  }
+
+  //Fetches to registers
+  for(std::size_t idx: assigned)
+  {
+    std::string array1 = dtype + " #namereg = " + vload(p_.simd_width, "#scalartype", "i*#stride", "#pointer", "1", backend, false) + ";";
+    std::string array_access = "#scalartype #namereg = #pointer[#index];";
+    std::string matrix_row = dtype + " #namereg = " + vload(p_.simd_width, "#scalartype", "i", "#pointer + #row*#stride", "#ld", backend, false) + ";";
+    std::string matrix_column = dtype + " #namereg = " + vload(p_.simd_width, "#scalartype", "i*#stride", "#pointer + #column*#ld", "#stride", backend, false) + ";";
+    std::string matrix_diag = dtype + " #namereg = " + vload(p_.simd_width, "#scalartype", "i*(#ld + #stride)", "#pointer + (#diag_offset<0)?-#diag_offset:(#diag_offset*#ld)", "#ld + #stride", backend, false) + ";";
+    process(stream, RHS_NODE_TYPE, {{"array1", array1}, {"matrix_row", matrix_row}, {"matrix_column", matrix_column},
+                                    {"matrix_diag", matrix_diag}, {"array_access", array_access}}, expressions, idx, mappings, processed);
+  }
 
 
+  //Compute expressions
+  for(std::size_t idx: assigned)
+    stream << evaluate(PARENT_NODE_TYPE, {{"array0", "#namereg"}, {"array1", "#namereg"},
+                                        {"matrix_row", "#namereg"}, {"matrix_column", "#namereg"}, {"matrix_diag", "#namereg"}, {"array_access", "#namereg"},
+                                        {"cast", CastPrefix(backend, dtype).get()}, {"placeholder", "#name"}, {"host_scalar", p_.simd_width==1?"#name": InitPrefix(backend, dtype).get() + "(#name)"}},
+                                      expressions, idx, mappings) << ";" << std::endl;
 
-  process(stream, LHS_NODE_TYPE, {{"array1", "#pointer[i*#stride] = #namereg;"},
-                                  {"matrix_row", "$VALUE{#row, i} = #namereg;"},
-                                  {"matrix_column", "$VALUE{i, #column} = #namereg;"},
-                                  {"matrix_diag", "#diag_offset<0?$VALUE{(i - #diag_offset)*#stride, i}:$VALUE{i*#stride, (i + #diag_offset)} = #namereg;"}}, expressions, mappings);
+  //Writes back to registers
+  processed.clear();
+  for(std::size_t idx: assigned)
+  {
+    std::string array1 = vstore(p_.simd_width, "#scalartype", "#namereg", "i*#stride", "#pointer", "1", backend, false) + ";";
+    std::string matrix_row = vstore(p_.simd_width, "#scalartype", "#namereg", "i", "#pointer + #row*#stride", "#ld", backend, false) + ";";
+    std::string matrix_column = vstore(p_.simd_width, "#scalartype", "#namereg", "i*#stride", "#pointer + #column*#ld", "#stride", backend, false) + ";";
+    std::string matrix_diag = vstore(p_.simd_width, "#scalartype", "#namereg", "i*(#ld + #stride)", "#pointer + (#diag_offset<0)?-#diag_offset:(#diag_offset*#ld)", "#ld + #stride", backend, false) + ";";
+    process(stream, LHS_NODE_TYPE, {{"array1", array1}, {"matrix_row", matrix_row}, {"matrix_column", matrix_column}, {"matrix_diag", matrix_diag}}, expressions, idx, mappings, processed);
+  }
+
+  if(sfors.size()){
+    stream.dec_tab();
+    stream << "}" << std::endl;
+  }
 
   stream.dec_tab();
   stream << "}" << std::endl;
 
-  stream << "if(idx==0)" << std::endl;
-  stream << "{" << std::endl;
-  stream.inc_tab();
-  process(stream, LHS_NODE_TYPE, { {"array0", "#pointer[#start] = #namereg;"} }, expressions, mappings);
-  stream.dec_tab();
-  stream << "}" << std::endl;
+  processed.clear();
+  if(assigned_scalar.size())
+  {
+    stream << "if(idx==0)" << std::endl;
+    stream << "{" << std::endl;
+    stream.inc_tab();
+    for(std::size_t idx: assigned)
+      process(stream, LHS_NODE_TYPE, { {"array0", "#pointer[#start] = #namereg;"} }, expressions, idx, mappings, processed);
+    stream.dec_tab();
+    stream << "}" << std::endl;
+  }
 
   stream.dec_tab();
   stream << "}" << std::endl;
 
+//  std::cout << stream.str() << std::endl;
+
   return stream.str();
 }
 
@@ -108,21 +181,21 @@ axpy::axpy(unsigned int simd, unsigned int ls, unsigned int ng,
 {}
 
 
-std::vector<int_t> axpy::input_sizes(expressions_tuple const & expressions) const
+std::vector<int_t> axpy::input_sizes(math_expression const & expressions) const
 {
-  size4 shape = static_cast<array_expression const *>(expressions.data().front().get())->shape();
+  size4 shape = expressions.shape();
   return {std::max(shape[0], shape[1])};
 }
 
-void axpy::enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, controller<expressions_tuple> const & controller)
+void axpy::enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, execution_handler const & control)
 {
-  expressions_tuple const & expressions = controller.x();
+  math_expression const & expressions = control.x();
   //Size
   int_t size = input_sizes(expressions)[0];
   //Fallback
   if(p_.simd_width > 1 && (requires_fallback(expressions) || (size%p_.simd_width>0)))
   {
-      fallback.enqueue(queue, program, "fallback", fallback, controller);
+      fallback.enqueue(queue, program, "fallback", fallback, control);
       return;
   }
   //Kernel
@@ -136,7 +209,7 @@ void axpy::enqueue(driver::CommandQueue & queue, driver::Program const & program
   unsigned int current_arg = 0;
   kernel.setSizeArg(current_arg++, size);
   set_arguments(expressions, kernel, current_arg, binding_policy_);
-  controller.execution_options().enqueue(program.context(), kernel, global, local);
+  control.execution_options().enqueue(program.context(), kernel, global, local);
 }
 
 
diff --git a/lib/kernels/templates/base.cpp b/lib/kernels/templates/base.cpp
index 47e29c066..b8ffb7ede 100644
--- a/lib/kernels/templates/base.cpp
+++ b/lib/kernels/templates/base.cpp
@@ -3,6 +3,7 @@
 #include <string>
 
 #include "isaac/array.h"
+#include "isaac/tuple.h"
 #include "isaac/kernels/keywords.h"
 #include "isaac/kernels/templates/axpy.h"
 #include "isaac/kernels/templates/dot.h"
@@ -27,17 +28,16 @@ base::parameters_type::parameters_type(unsigned int _simd_width, int_t _local_si
 { }
 
 
-bool base::requires_fallback(expressions_tuple const & expressions)
+bool base::requires_fallback(math_expression const  & expression)
 {
-  for (const auto & elem : expressions.data())
-    for(array_expression::container_type::const_iterator itt = (elem)->tree().begin(); itt != (elem)->tree().end() ; ++itt)
-      if(   (itt->lhs.subtype==DENSE_ARRAY_TYPE && (std::max(itt->lhs.array->stride()[0], itt->lhs.array->stride()[1])>1 || std::max(itt->lhs.array->start()[0],itt->lhs.array->start()[1])>0))
-         || (itt->rhs.subtype==DENSE_ARRAY_TYPE && (std::max(itt->rhs.array->stride()[0], itt->rhs.array->stride()[1])>1 || std::max(itt->rhs.array->start()[0],itt->rhs.array->start()[1])>0)))
-        return true;
+  for(math_expression::node const & node: expression.tree())
+    if(  (node.lhs.subtype==DENSE_ARRAY_TYPE && (std::max(node.lhs.array->stride()[0], node.lhs.array->stride()[1])>1 || std::max(node.lhs.array->start()[0],node.lhs.array->start()[1])>0))
+      || (node.rhs.subtype==DENSE_ARRAY_TYPE && (std::max(node.rhs.array->stride()[0], node.rhs.array->stride()[1])>1 || std::max(node.rhs.array->start()[0],node.rhs.array->start()[1])>0)))
+      return true;
   return false;
 }
 
-int_t base::vector_size(array_expression::node const & node)
+int_t base::vector_size(math_expression::node const & node)
 {
   if (node.op.type==OPERATOR_MATRIX_DIAG_TYPE)
     return std::min<int_t>(node.lhs.array->shape()[0], node.lhs.array->shape()[1]);
@@ -50,7 +50,7 @@ int_t base::vector_size(array_expression::node const & node)
 
 }
 
-std::pair<int_t, int_t> base::matrix_size(array_expression::node const & node)
+std::pair<int_t, int_t> base::matrix_size(math_expression::container_type const & tree, math_expression::node const & node)
 {
   if (node.op.type==OPERATOR_VDIAG_TYPE)
   {
@@ -58,7 +58,12 @@ std::pair<int_t, int_t> base::matrix_size(array_expression::node const & node)
     return std::make_pair(size,size);
   }
   else if(node.op.type==OPERATOR_REPEAT_TYPE)
-    return std::make_pair(node.lhs.array->shape()[0]*node.rhs.tuple.rep1, node.lhs.array->shape()[1]*node.rhs.tuple.rep2);
+  {
+    size_t rep0 = tuple_get(tree, node.rhs.node_index, 0);
+    size_t rep1 = tuple_get(tree, node.rhs.node_index, 1);
+    std::cout << rep0 << " " << rep1 << std::endl;
+    return std::make_pair(node.lhs.array->shape()[0]*rep0, node.lhs.array->shape()[1]*rep1);
+  }
   else
     return std::make_pair(node.lhs.array->shape()[0],node.lhs.array->shape()[1]);
 }
@@ -67,43 +72,39 @@ std::pair<int_t, int_t> base::matrix_size(array_expression::node const & node)
 base::base(binding_policy_t binding_policy) : binding_policy_(binding_policy)
 {}
 
-unsigned int base::lmem_usage(expressions_tuple const &) const
+unsigned int base::lmem_usage(math_expression const  &) const
 { return 0; }
 
-unsigned int base::registers_usage(expressions_tuple const &) const
+unsigned int base::registers_usage(math_expression const  &) const
 { return 0; }
 
-unsigned int base::temporary_workspace(expressions_tuple const &) const
+unsigned int base::temporary_workspace(math_expression const  &) const
 { return 0; }
 
 base::~base()
 {
 }
 
-std::string base::generate(std::string const & suffix, expressions_tuple const & expressions, driver::Device const & device)
+std::string base::generate(std::string const & suffix, math_expression const  & expression, driver::Device const & device)
 {
-  expressions_tuple::data_type::const_iterator sit;
-  std::vector<mapping_type>::iterator mit;
-  int err = is_invalid(expressions, device);
+  int err = is_invalid(expression, device);
   if(err != 0)
     throw operation_not_supported_exception("The supplied parameters for this template are invalid : err " + tools::to_string(err));
 
   //Create mapping
-  std::vector<mapping_type> mappings(expressions.data().size());
+  mapping_type mapping;
   std::unique_ptr<symbolic_binder> binder;
-  if (binding_policy_==BIND_TO_HANDLE)
-      binder.reset(new bind_to_handle());
+  if (binding_policy_==BIND_SEQUENTIAL)
+      binder.reset(new bind_sequential());
   else
-      binder.reset(new bind_all_unique());
+      binder.reset(new bind_independent());
 
-  for (mit = mappings.begin(), sit = expressions.data().begin(); sit != expressions.data().end(); ++sit, ++mit)
-    traverse(**sit, (*sit)->root(), map_functor(*binder,*mit,device), true);
-
-  return generate_impl(suffix, expressions, device, mappings);
+  traverse(expression, expression.root(), map_functor(*binder, mapping, device), true);
+  return generate_impl(suffix, expression, device, mapping);
 }
 
 template<class TType, class PType>
-int base_impl<TType, PType>::is_invalid_impl(driver::Device const &, expressions_tuple const &) const
+int base_impl<TType, PType>::is_invalid_impl(driver::Device const &, math_expression const  &) const
 { return TEMPLATE_VALID; }
 
 template<class TType, class PType>
@@ -123,7 +124,7 @@ std::shared_ptr<base> base_impl<TType, PType>::clone() const
 { return std::shared_ptr<base>(new TType(*dynamic_cast<TType const *>(this))); }
 
 template<class TType, class PType>
-int base_impl<TType, PType>::is_invalid(expressions_tuple const & expressions, driver::Device const & device) const
+int base_impl<TType, PType>::is_invalid(math_expression const  & expressions, driver::Device const & device) const
 {
   //Query device informations
   size_t lmem_available = device.local_mem_size();
diff --git a/lib/kernels/templates/dot.cpp b/lib/kernels/templates/dot.cpp
index 44af2b315..d00609ff3 100644
--- a/lib/kernels/templates/dot.cpp
+++ b/lib/kernels/templates/dot.cpp
@@ -20,18 +20,13 @@ dot_parameters::dot_parameters(unsigned int _simd_width,
                      fetching_policy_type _fetching_policy) : base::parameters_type(_simd_width, _group_size, 1, 2), num_groups(_num_groups), fetching_policy(_fetching_policy)
 { }
 
-unsigned int dot::lmem_usage(expressions_tuple const & expressions) const
+unsigned int dot::lmem_usage(math_expression const  & x) const
 {
-  unsigned int res = 0;
-  for(const auto & elem : expressions.data())
-  {
-    numeric_type numeric_t= lhs_most((elem)->tree(), (elem)->root()).lhs.dtype;
-    res += p_.local_size_0*size_of(numeric_t);
-  }
-  return res;
+  numeric_type numeric_t= lhs_most(x.tree(), x.root()).lhs.dtype;
+  return p_.local_size_0*size_of(numeric_t);
 }
 
-int dot::is_invalid_impl(driver::Device const &, expressions_tuple const &) const
+int dot::is_invalid_impl(driver::Device const &, math_expression const  &) const
 {
   if (p_.fetching_policy==FETCH_FROM_LOCAL)
     return TEMPLATE_INVALID_FETCHING_POLICY_TYPE;
@@ -63,15 +58,14 @@ inline void dot::reduce_1d_local_memory(kernel_generation_stream & stream, unsig
   stream << "}" << std::endl;
 }
 
-std::string dot::generate_impl(std::string const & suffix, expressions_tuple const & expressions, driver::Device const & device, std::vector<mapping_type> const & mappings) const
+std::string dot::generate_impl(std::string const & suffix, math_expression const  & expressions, driver::Device const & device, mapping_type const & mapping) const
 {
   kernel_generation_stream stream;
 
   std::vector<mapped_scalar_dot*> exprs;
-  for (const auto & mapping : mappings)
-    for (mapping_type::const_iterator iit = mapping.begin(); iit != mapping.end(); ++iit)
-      if (mapped_scalar_dot * p = dynamic_cast<mapped_scalar_dot*>(iit->second.get()))
-        exprs.push_back(p);
+  for (mapping_type::const_iterator iit = mapping.begin(); iit != mapping.end(); ++iit)
+    if (mapped_scalar_dot * p = dynamic_cast<mapped_scalar_dot*>(iit->second.get()))
+      exprs.push_back(p);
   std::size_t N = exprs.size();
   driver::backend_type backend = device.backend();
   std::string _size_t = size_type(device);
@@ -79,7 +73,7 @@ std::string dot::generate_impl(std::string const & suffix, expressions_tuple con
   std::string arguments = _size_t + " N, ";
   for (unsigned int k = 0; k < N; ++k)
   {
-    std::string numeric_type = to_string(lhs_most(exprs[k]->array_expression().tree(),  exprs[k]->array_expression().root()).lhs.dtype);
+    std::string numeric_type = to_string(lhs_most(exprs[k]->math_expression().tree(),  exprs[k]->math_expression().root()).lhs.dtype);
     if (exprs[k]->is_index_dot())
     {
       arguments += exprs[k]->process(Global(backend).get() + " unsigned int* #name_temp, ");
@@ -104,7 +98,7 @@ std::string dot::generate_impl(std::string const & suffix, expressions_tuple con
       stream << " __attribute__((reqd_work_group_size(" << p_.local_size_0 << ",1,1)))" << std::endl; break;
   }
 
-  stream << KernelPrefix(backend) << " void " << name[0] << "(" << arguments << generate_arguments("#scalartype", device, mappings, expressions) << ")" << std::endl;
+  stream << KernelPrefix(backend) << " void " << name[0] << "(" << arguments << generate_arguments("#scalartype", device, mapping, expressions) << ")" << std::endl;
   stream << "{" << std::endl;
   stream.inc_tab();
 
@@ -115,7 +109,7 @@ std::string dot::generate_impl(std::string const & suffix, expressions_tuple con
 
   process(stream, PARENT_NODE_TYPE, {{"array0", "#scalartype #namereg = #pointer[#start];"},
                                      {"array1", "#pointer += #start;"}},
-                                    expressions, mappings);
+                                    expressions, mapping);
 
   for (unsigned int k = 0; k < N; ++k)
   {
@@ -138,11 +132,12 @@ std::string dot::generate_impl(std::string const & suffix, expressions_tuple con
   {
     std::string i = (simd_width==1)?"i*#stride":"i";
     //Fetch vector entry
+    std::set<std::string> already_fetched;
     for (const auto & elem : exprs)
-      (elem)->process_recursive(stream, PARENT_NODE_TYPE, {{"array1",  append_width("#scalartype",simd_width) + " #namereg = " + vload(simd_width,"#scalartype",i,"#pointer",backend)+";"},
+      (elem)->process_recursive(stream, PARENT_NODE_TYPE, {{"array1",  append_width("#scalartype",simd_width) + " #namereg = " + vload(simd_width,"#scalartype",i,"#pointer","#1",backend)+";"},
                                                            {"matrix_row",  "#scalartype #namereg = #pointer[$OFFSET{#row*#stride, i}];"},
                                                            {"matrix_column", "#scalartype #namereg = #pointer[$OFFSET{i*#stride,#column}];"},
-                                                           {"matrix_diag", "#scalartype #namereg = #pointer[#diag_offset<0?$OFFSET{(i - #diag_offset)*#stride, i}:$OFFSET{i*#stride, (i + #diag_offset)}];"}});
+                                                           {"matrix_diag", "#scalartype #namereg = #pointer[#diag_offset<0?$OFFSET{(i - #diag_offset)*#stride, i}:$OFFSET{i*#stride, (i + #diag_offset)}];"}}, already_fetched);
 
     //Update accumulators
     std::vector<std::string> str(simd_width);
@@ -205,7 +200,7 @@ std::string dot::generate_impl(std::string const & suffix, expressions_tuple con
 
 
 
-  stream << KernelPrefix(backend) << " void " << name[1] << "(" << arguments << generate_arguments("#scalartype", device, mappings, expressions) << ")" << std::endl;
+  stream << KernelPrefix(backend) << " void " << name[1] << "(" << arguments << generate_arguments("#scalartype", device, mapping, expressions) << ")" << std::endl;
   stream << "{" << std::endl;
   stream.inc_tab();
 
@@ -257,7 +252,7 @@ std::string dot::generate_impl(std::string const & suffix, expressions_tuple con
   std::map<std::string, std::string> accessors;
   accessors["scalar_dot"] = "#name_buf[0]";
   accessors["array0"] = "#pointer[#start]";
-  evaluate(stream, PARENT_NODE_TYPE, accessors, expressions, mappings);
+  stream << evaluate(PARENT_NODE_TYPE, accessors, expressions, expressions.root(), mapping) << ";" << std::endl;
   stream.dec_tab();
   stream << "}" << std::endl;
 
@@ -278,34 +273,31 @@ dot::dot(unsigned int simd, unsigned int ls, unsigned int ng,
     base_impl<dot, dot_parameters>(dot_parameters(simd,ls,ng,fetch), bind)
 {}
 
-std::vector<int_t> dot::input_sizes(expressions_tuple const & expressions) const
+std::vector<int_t> dot::input_sizes(math_expression const  & x) const
 {
-  std::vector<size_t> dots_idx = filter_nodes(&is_dot, *(expressions.data().front()), false);
-  int_t N = vector_size(lhs_most(expressions.data().front()->tree(), dots_idx[0]));
+  std::vector<size_t> dots_idx = filter_nodes(&is_dot, x, x.root(), false);
+  int_t N = vector_size(lhs_most(x.tree(), dots_idx[0]));
   return {N};
 }
 
-void dot::enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, controller<expressions_tuple> const & controller)
+void dot::enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, execution_handler const & control)
 {
-  expressions_tuple const & expressions = controller.x();
+  math_expression const  & x = control.x();
 
   //Preprocessing
-  int_t size = input_sizes(expressions)[0];
+  int_t size = input_sizes(x)[0];
 
   //fallback
-  if(p_.simd_width > 1 && (requires_fallback(expressions) || (size%p_.simd_width>0)))
+  if(p_.simd_width > 1 && (requires_fallback(x) || (size%p_.simd_width>0)))
   {
-      fallback.enqueue(queue, program, "fallback", fallback, controller);
+      fallback.enqueue(queue, program, "fallback", fallback, control);
       return;
   }
 
-  std::vector<array_expression::node const *> dots;
-  for (const auto & elem : expressions.data())
-  {
-    std::vector<size_t> dots_idx = filter_nodes(&is_dot, *elem, false);
-    for (auto & dots_idx_itt : dots_idx)
-      dots.push_back(&(elem)->tree()[dots_idx_itt]);
-  }
+  std::vector<math_expression::node const *> dots;
+    std::vector<size_t> dots_idx = filter_nodes(&is_dot, x, x.root(), false);
+    for (size_t idx: dots_idx)
+      dots.push_back(&x.tree()[idx]);
 
   //Kernel
   std::string name[2] = {"prod", "reduce"};
@@ -319,9 +311,8 @@ void dot::enqueue(driver::CommandQueue & queue, driver::Program const & program,
   driver::NDRange local[2] = { driver::NDRange(p_.local_size_0), driver::NDRange(p_.local_size_0) };
 
   //Arguments
-  driver::Context const & context = expressions.context();
-  array_expression const & s = *(expressions.data().front());
-  unsigned int dtype_size = size_of(lhs_most(s.tree(), s.root()).lhs.dtype);
+  driver::Context const & context = x.context();
+  unsigned int dtype_size = size_of(lhs_most(x.tree(), x.root()).lhs.dtype);
   for (auto & kernel : kernels)
   {
     unsigned int n_arg = 0;
@@ -330,7 +321,7 @@ void dot::enqueue(driver::CommandQueue & queue, driver::Program const & program,
     //Temporary buffers
     unsigned int i = 0;
     unsigned int j = 0;
-    for (std::vector<array_expression::node const *>::const_iterator it = dots.begin(); it != dots.end(); ++it)
+    for (std::vector<math_expression::node const *>::const_iterator it = dots.begin(); it != dots.end(); ++it)
     {
       if (is_index_dot((*it)->op))
       {
@@ -345,11 +336,11 @@ void dot::enqueue(driver::CommandQueue & queue, driver::Program const & program,
       i++;
     }
 
-    set_arguments(expressions, kernel, n_arg, binding_policy_);
+    set_arguments(x, kernel, n_arg, binding_policy_);
   }
 
   for (unsigned int k = 0; k < 2; k++)
-    controller.execution_options().enqueue(program.context(), kernels[k], global[k], local[k]);
+    control.execution_options().enqueue(program.context(), kernels[k], global[k], local[k]);
 }
 
 }
diff --git a/lib/kernels/templates/gemm.cpp b/lib/kernels/templates/gemm.cpp
index 4ce9a4ad4..171a08286 100644
--- a/lib/kernels/templates/gemm.cpp
+++ b/lib/kernels/templates/gemm.cpp
@@ -27,27 +27,24 @@ gemm_parameters::gemm_parameters(unsigned int simd_width
 }
 
 
-  unsigned int gemm::lmem_usage(expressions_tuple const & expressions) const
+  unsigned int gemm::lmem_usage(math_expression const & expression) const
   {
-    isaac::array_expression const & array_expression = (*expressions.data().front());
-    numeric_type numeric_t = lhs_most(array_expression.tree(), array_expression.root()).lhs.dtype;
-
+    numeric_type numeric_t = lhs_most(expression.tree(), expression.root()).lhs.dtype;
     unsigned int N = 0;
     N += p_.kL * p_.mL;
     N += p_.nL * p_.kL;
     return N*size_of(numeric_t);
   }
 
-  unsigned int gemm::registers_usage(expressions_tuple const & expressions) const
+  unsigned int gemm::registers_usage(math_expression const & expression) const
   {
-    isaac::array_expression const & array_expression = (*expressions.data().front());
-    numeric_type numeric_t = lhs_most(array_expression.tree(), array_expression.root()).lhs.dtype;
+    numeric_type numeric_t = lhs_most(expression.tree(), expression.root()).lhs.dtype;
 
     unsigned int N = p_.mS * p_.nS + p_.mS * p_.kS + p_.kS * p_.nS;
     return N*size_of(numeric_t);
   }
 
-  unsigned int gemm::temporary_workspace(expressions_tuple const & expressions) const
+  unsigned int gemm::temporary_workspace(math_expression const & expressions) const
   {
       std::vector<int_t> MNK = input_sizes(expressions);
       int_t M = MNK[0]; int_t N = MNK[1];
@@ -56,7 +53,7 @@ gemm_parameters::gemm_parameters(unsigned int simd_width
       return 0;
   }
 
-  int gemm::is_invalid_impl(driver::Device const &, expressions_tuple const &) const
+  int gemm::is_invalid_impl(driver::Device const &, math_expression const &) const
   {
 //    if(device.vendor()==driver::Device::Vendor::NVIDIA && p_.simd_width > 1)
 //      return TEMPLATE_INVALID_SIMD_WIDTH;
@@ -106,16 +103,16 @@ gemm_parameters::gemm_parameters(unsigned int simd_width
     return TEMPLATE_VALID;
   }
 
-  std::string gemm::generate_impl(std::string const & suffix, expressions_tuple const & expressions, driver::Device const & device, std::vector<mapping_type> const &) const
+  std::string gemm::generate_impl(std::string const & suffix, math_expression const & expression, driver::Device const & device, mapping_type const &) const
   {
     using std::string;
     using tools::to_string;
 
     driver::backend_type backend = device.backend();
     bool has_depth = p_.depth > 1;
-#define VLOAD(offset, ptr) vload(p_.simd_width, sdtype, offset, ptr, backend, true)
-#define VLOAD_MISALIGNED(offset, ptr) vload(p_.simd_width, sdtype, offset, ptr, backend, false)
-#define VSTORE(value, offset, ptr) vstore(p_.simd_width, sdtype, value, offset, ptr, backend)
+#define VLOAD(offset, ptr) vload(p_.simd_width, sdtype, offset, ptr, "1", backend, true)
+#define VLOAD_MISALIGNED(offset, ptr) vload(p_.simd_width, sdtype, offset, ptr, "1", backend, false)
+#define VSTORE(value, offset, ptr) vstore(p_.simd_width, sdtype, value, offset, ptr, "1", backend)
 #define ASTRIDE1 string(check_bounds_?"*Astride1":"")
 #define BSTRIDE1 string(check_bounds_?"*Bstride1":"")
 #define CSTRIDE1 string(check_bounds_?"*Cstride1":"")
@@ -126,8 +123,7 @@ gemm_parameters::gemm_parameters(unsigned int simd_width
     /// INIT
     /// //////////////
     kernel_generation_stream stream;
-    array_expression const & st = (*expressions.data().front());
-    numeric_type dtype = lhs_most(st.tree(), st.root()).lhs.dtype;
+    numeric_type dtype = lhs_most(expression.tree(), expression.root()).lhs.dtype;
     std::string sdtype = to_string(dtype);
     std::string vdtype = append_width(sdtype, p_.simd_width);
     std::string _size_t = size_type(device);
@@ -588,7 +584,7 @@ gemm_parameters::gemm_parameters(unsigned int simd_width
 
     gemm_name += suffix;
     reduce_name += suffix;
-    bind_all_unique binder;
+    bind_independent binder;
 
     array const * out = &C;
     std::unique_ptr<array> tmp;
@@ -659,11 +655,10 @@ gemm_parameters::gemm_parameters(unsigned int simd_width
     return array(M, s0, s1);
   }
 
-  std::vector<int_t> gemm::infos(expressions_tuple const & expressions, symbolic::preset::gemm::args& arguments) const
+  std::vector<int_t> gemm::infos(math_expression const & expression, symbolic::preset::gemm::args& arguments) const
   {
-    isaac::array_expression & array_expression = (*expressions.data().front());
-    array_expression::container_type & array = array_expression.tree();
-    std::size_t root = array_expression.root();
+    math_expression::container_type const & array = expression.tree();
+    std::size_t root = expression.root();
     arguments = symbolic::preset::gemm::check(array, root);
     int_t M = arguments.C->array->shape()[0];
     int_t N = arguments.C->array->shape()[1];
@@ -671,7 +666,7 @@ gemm_parameters::gemm_parameters(unsigned int simd_width
     return {M, N, K};
   }
 
-  gemm::gemm(gemm_parameters const & parameters, bool check_bounds, char A_trans, char B_trans) : base_impl<gemm, gemm_parameters>(parameters, BIND_ALL_UNIQUE), A_trans_(A_trans), B_trans_(B_trans), check_bounds_(check_bounds)
+  gemm::gemm(gemm_parameters const & parameters, bool check_bounds, char A_trans, char B_trans) : base_impl<gemm, gemm_parameters>(parameters, BIND_INDEPENDENT), A_trans_(A_trans), B_trans_(B_trans), check_bounds_(check_bounds)
   {
     if(A_trans_=='N' && B_trans_=='N') type_ = GEMM_NN_TYPE;
     else if(A_trans_=='T' && B_trans_=='N') type_ = GEMM_TN_TYPE;
@@ -680,18 +675,18 @@ gemm_parameters::gemm_parameters(unsigned int simd_width
     else throw;
   }
 
-  std::vector<int_t> gemm::input_sizes(expressions_tuple const & expressions) const
+  std::vector<int_t> gemm::input_sizes(math_expression const & expressions) const
   {
     symbolic::preset::gemm::args dummy;
-    return infos(expressions, dummy);
+    return infos((math_expression&)expressions, dummy);
   }
 
-  void gemm::enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback_base, controller<expressions_tuple> const & ctr)
+  void gemm::enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback_base, execution_handler const & control)
   {
     using namespace tools;
 
     gemm & fallback = (gemm&)fallback_base;
-    expressions_tuple const & expressions = ctr.x();
+    math_expression const & expressions = control.x();
 
 
     symbolic::preset::gemm::args args;
@@ -724,7 +719,7 @@ gemm_parameters::gemm_parameters(unsigned int simd_width
     if(args.alpha) alpha = value_scalar(args.alpha->vscalar, dtype);
 
 
-    execution_options_type const & options = ctr.execution_options();
+    execution_options_type const & options = control.execution_options();
 
     if (ldstrideA> 1 || ldstrideB > 1 || ldstrideC > 1)
     {
diff --git a/lib/kernels/templates/gemv.cpp b/lib/kernels/templates/gemv.cpp
index ee85d6b74..bd759ffa3 100644
--- a/lib/kernels/templates/gemv.cpp
+++ b/lib/kernels/templates/gemv.cpp
@@ -22,33 +22,27 @@ gemv_parameters::gemv_parameters(unsigned int _simd_width,
 num_groups_0(_num_groups_0), num_groups_1(_num_groups_1), fetch_policy(_fetch_policy) { }
 
 
-int gemv::is_invalid_impl(driver::Device const &, expressions_tuple const &) const
+int gemv::is_invalid_impl(driver::Device const &, math_expression const &) const
 {
   if (p_.fetch_policy==FETCH_FROM_LOCAL)
     return TEMPLATE_INVALID_FETCHING_POLICY_TYPE;
   return TEMPLATE_VALID;
 }
 
-unsigned int gemv::lmem_usage(const expressions_tuple &) const
+unsigned int gemv::lmem_usage(const math_expression&) const
 {
   return (p_.local_size_0+1)*p_.local_size_1;
 }
 
-std::string gemv::generate_impl(std::string const & suffix, expressions_tuple const & expressions, driver::Device const & device, std::vector<mapping_type> const & mappings) const
+std::string gemv::generate_impl(std::string const & suffix, math_expression const & expression, driver::Device const & device, mapping_type const & mapping) const
 {
   using tools::to_string;
 
 
   std::vector<mapped_gemv*> dots;
-  expressions_tuple::data_type::const_iterator sit;
-  std::vector<mapping_type>::const_iterator mit;
-  for (mit = mappings.begin(), sit = expressions.data().begin(); mit != mappings.end(); ++mit, ++sit)
-  {
-    array_expression const & first_expression = *expressions.data().front();
-    std::vector<size_t> idx = filter_nodes(&is_dot, first_expression, false);
-    for (auto & elem : idx)
-      dots.push_back((mapped_gemv*)(mit->at(mapping_key(elem, PARENT_NODE_TYPE)).get()));
-  }
+  std::vector<size_t> idx = filter_nodes(&is_dot, expression, expression.root(), false);
+  for (auto & elem : idx)
+    dots.push_back((mapped_gemv*)(mapping.at(mapping_key(elem, PARENT_NODE_TYPE)).get()));
 
   kernel_generation_stream stream;
   driver::backend_type backend = device.backend();
@@ -61,7 +55,7 @@ std::string gemv::generate_impl(std::string const & suffix, expressions_tuple co
   std::string arguments = _size_t + " M, " + _size_t + " N, " ;
   for (const auto & e : dots)
   {
-    std::string numeric_type = to_string(lhs_most(e->array_expression().tree(), e->array_expression().root()).lhs.dtype);
+    std::string numeric_type = to_string(lhs_most(e->math_expression().tree(), e->math_expression().root()).lhs.dtype);
     if (e->is_index_dot())
     {
       arguments += e->process(Global(backend).get() + " unsigned int* #name_temp, ");
@@ -80,14 +74,14 @@ std::string gemv::generate_impl(std::string const & suffix, expressions_tuple co
       stream << " __attribute__((reqd_work_group_size(" << p_.local_size_0 << "," << p_.local_size_1 << ",1)))" << std::endl; break;
   }
 
-  stream << KernelPrefix(backend) << " void " << name[0] << "(" << arguments << generate_arguments("#scalartype", device, mappings, expressions) << ")" << std::endl;
+  stream << KernelPrefix(backend) << " void " << name[0] << "(" << arguments << generate_arguments("#scalartype", device, mapping, expression) << ")" << std::endl;
   stream << "{" << std::endl;
   stream.inc_tab();
 
   process(stream, PARENT_NODE_TYPE,
                         {{"array0", "#scalartype #namereg = #pointer[#start];"},
                          {"array1", "#pointer += #start;"},
-                         {"array2", "#pointer += #start;"}}, expressions, mappings);
+                         {"array2", "#pointer += #start;"}}, expression, mapping);
 
   unsigned int local_size_0_ld = p_.local_size_0;
   std::string local_size_0_ld_str = to_string(local_size_0_ld);
@@ -115,23 +109,23 @@ std::string gemv::generate_impl(std::string const & suffix, expressions_tuple co
   element_wise_loop_1D(stream, p_.fetch_policy, (dot_type_==REDUCE_COLUMNS)?p_.simd_width:1, "c", "N", GlobalIdx0(backend).get(), GlobalSize0(backend).get(), device, [&](unsigned int row_simd_width)
   {
 
-
+    std::set<std::string> already_fetched;
     for (const auto & e : dots)
     {
       std::map<std::string, std::string> accessors;
       if(dot_type_==REDUCE_COLUMNS)
       {
         std::string data_type = append_width("#scalartype",row_simd_width);
-        accessors["array2"] = data_type + " #namereg = " + vload(row_simd_width, "#scalartype", "c*#stride", "#pointer + r*#ld", backend,false)+";";
-        accessors["repeat"] = data_type + " #namereg = " + vload(row_simd_width, "#scalartype", "(c%#tuplearg0)*#stride", "#pointer + (r%#tuplearg1)*#stride ", backend,false)+";";
+        accessors["array2"] = data_type + " #namereg = " + vload(row_simd_width, "#scalartype", "c*#stride", "#pointer + r*#ld", "1", backend,false)+";";
+        accessors["repeat"] = data_type + " #namereg = " + vload(row_simd_width, "#scalartype", "(c%#sub0)*#stride", "#pointer + (r%#sub1)*#stride ", "1", backend,false)+";";
       }
       else
       {
         std::string data_type = append_width("#scalartype",col_simd_width);
-        accessors["array2"] = data_type + " #namereg = " + vload(col_simd_width, "#scalartype", "0", "#pointer + r*#stride + c*#ld", backend,false) + ";";
-        accessors["repeat"] = "#scalartype #namereg = $VALUE{(r%#tuplearg0)*#stride, (c%#tuplearg1)*#stride};";
+        accessors["array2"] = data_type + " #namereg = " + vload(col_simd_width, "#scalartype", "0", "#pointer + r*#stride + c*#ld", "1", backend,false) + ";";
+        accessors["repeat"] = "#scalartype #namereg = $VALUE{(r%#sub0)*#stride, (c%#sub1)*#stride};";
       }
-      e->process_recursive(stream, PARENT_NODE_TYPE, accessors);
+      e->process_recursive(stream, PARENT_NODE_TYPE, accessors, already_fetched);
     }
 
     //Update accumulators
@@ -196,7 +190,7 @@ std::string gemv::generate_impl(std::string const & suffix, expressions_tuple co
         if(col_simd_width > 1)
             accessors["gemv"] = access_vector_type(accessors["gemv"], s);
         accessors["array1"] = "#pointer[(r +" + to_string(s) + ")*#stride]";
-        evaluate(stream, PARENT_NODE_TYPE, accessors, expressions, mappings);
+        stream << evaluate(PARENT_NODE_TYPE, accessors, expression, expression.root(), mapping) << ";" << std::endl;
     }
   }
   else
@@ -206,8 +200,8 @@ std::string gemv::generate_impl(std::string const & suffix, expressions_tuple co
       if(col_simd_width > 1)
           stream << "if(M - r > " << col_simd_width << "){" << std::endl;
       if (e->is_index_dot())
-          stream << e->process(vstore(col_simd_width,"uint", "#name_buf_value[lidy*" + local_size_0_ld_str + "]", "0", "#name_temp_value + r + M*" + GroupIdx0(backend).get(),backend, false)) << ";" << std::endl;
-      stream << e->process(vstore(col_simd_width,"#scalartype", "#name_buf[lidy*" + local_size_0_ld_str + "]", "0", "#name_temp + r + M*" + GroupIdx0(backend).get(),backend, false)) << ";" << std::endl;
+          stream << e->process(vstore(col_simd_width,"uint", "#name_buf_value[lidy*" + local_size_0_ld_str + "]", "0", "#name_temp_value + r + M*" + GroupIdx0(backend).get(), "1", backend, false)) << ";" << std::endl;
+      stream << e->process(vstore(col_simd_width,"#scalartype", "#name_buf[lidy*" + local_size_0_ld_str + "]", "0", "#name_temp + r + M*" + GroupIdx0(backend).get(), "1", backend, false)) << ";" << std::endl;
       if(col_simd_width > 1)
       {
           stream << "}" << std::endl;
@@ -233,7 +227,6 @@ std::string gemv::generate_impl(std::string const & suffix, expressions_tuple co
   stream.dec_tab();
   stream << "}" << std::endl;
 
-//  std::cout << stream.str() << std::endl;
 
   if(p_.num_groups_0>1)
   {
@@ -244,14 +237,14 @@ std::string gemv::generate_impl(std::string const & suffix, expressions_tuple co
   if(backend==driver::OPENCL)
     stream << " __attribute__((reqd_work_group_size(" << p_.local_size_0 << "," << p_.local_size_1 << ",1)))" << std::endl;
 
-  stream << KernelPrefix(backend) << " void " << name[1] << "(" << arguments << generate_arguments("#scalartype", device, mappings, expressions) << ")" << std::endl;
+  stream << KernelPrefix(backend) << " void " << name[1] << "(" << arguments << generate_arguments("#scalartype", device, mapping, expression) << ")" << std::endl;
   stream << "{" << std::endl;
   stream.inc_tab();
 
   process(stream, PARENT_NODE_TYPE,
                         {{"array0", "#scalartype #namereg = #pointer[#start];"},
                          {"array1", "#pointer += #start;"},
-                         {"array2", "#pointer += #start; "}}, expressions, mappings);
+                         {"array2", "#pointer += #start; "}}, expression, mapping);
 
   for (const auto & e : dots)
     stream << e->process(Local(backend).get() + " #scalartype #name_buf[" + to_string(p_.local_size_1*local_size_0_ld) + "];") << std::endl;
@@ -316,7 +309,7 @@ std::string gemv::generate_impl(std::string const & suffix, expressions_tuple co
   std::map<std::string, std::string> accessors;
   accessors["gemv"] = "#name_buf[lidy*" + local_size_0_ld_str + "]";
   accessors["array1"] = "#pointer[r*#stride]";
-  evaluate(stream, PARENT_NODE_TYPE, accessors, expressions, mappings);
+  stream << evaluate(PARENT_NODE_TYPE, accessors, expression, expression.root(), mapping) << ";" << std::endl;
 
   stream.dec_tab();
   stream << "}" << std::endl;
@@ -338,41 +331,37 @@ gemv::gemv(gemv::parameters_type const & parameters,
   base_impl<gemv, gemv_parameters>(parameters, binding_policy),
   dot_type_(rtype){ }
 
-std::vector<int_t> gemv::input_sizes(expressions_tuple const & expressions) const
+std::vector<int_t> gemv::input_sizes(math_expression const & expression) const
 {
-  array_expression const & first_expression = *expressions.data().front();
-  std::vector<std::size_t> idx = filter_nodes(&is_dot, first_expression, false);
-  std::pair<int_t, int_t> MN = matrix_size(lhs_most(first_expression.tree(), idx[0]));
+  std::vector<std::size_t> idx = filter_nodes(&is_dot, expression, expression.root(), false);
+  std::pair<int_t, int_t> MN = matrix_size(expression.tree(), lhs_most(expression.tree(), idx[0]));
   if(dot_type_==REDUCE_COLUMNS)
     std::swap(MN.first,MN.second);
   return {MN.first, MN.second};
 }
 
-void gemv::enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, controller<expressions_tuple> const & controller)
+void gemv::enqueue(driver::CommandQueue & queue, driver::Program const & program, std::string const & suffix, base & fallback, execution_handler const & control)
 {
-  expressions_tuple const & expressions = controller.x();
-  driver::Context const & context = expressions.context();
+  math_expression const & expression = control.x();
+  driver::Context const & context = expression.context();
 
-  std::vector<int_t> MN = input_sizes(expressions);
-  std::vector<array_expression::node const *> dots;
-  for (const auto & e : expressions.data())
-  {
-    std::vector<size_t> dots_idx = filter_nodes(&is_dot, *e, false);
-    for (auto & r : dots_idx)
-      dots.push_back(&(e)->tree()[r]);
-  }
+  std::vector<int_t> MN = input_sizes(expression);
+  std::vector<math_expression::node const *> dots;
+  std::vector<size_t> dots_idx = filter_nodes(&is_dot, expression, expression.root(), false);
+  for (size_t idx : dots_idx)
+    dots.push_back(&expression.tree()[idx]);
 
   //Fallback
-  if(p_.simd_width>1 && requires_fallback(expressions))
+  if(p_.simd_width>1 && requires_fallback(expression))
   {
-      fallback.enqueue(queue, program, "fallback", fallback, controller);
+      fallback.enqueue(queue, program, "fallback", fallback, control);
       return;
   }
 
   //Kernel
   std::vector< driver::Buffer > tmp;
   std::vector< driver::Buffer > tmpidx;
-  unsigned int dtype_size = size_of(lhs_most(expressions.data().front()->tree(), expressions.data().front()->root()).lhs.dtype);
+  unsigned int dtype_size = size_of(lhs_most(expression.tree(), expression.root()).lhs.dtype);
 
   std::string name[2] = {"prod", "reduce"};
   name[0] += suffix;
@@ -410,14 +399,14 @@ void gemv::enqueue(driver::CommandQueue & queue, driver::Program const & program
       kernel.setArg(n_arg++, tmp[i]);
       i++;
     }
-    set_arguments(expressions, kernel, n_arg, binding_policy_);
+    set_arguments(expression, kernel, n_arg, binding_policy_);
   }
 
   //NDRange
   driver::NDRange global[2] = { driver::NDRange(p_.local_size_0*p_.num_groups_0, p_.local_size_1*p_.num_groups_1), driver::NDRange(p_.local_size_0, p_.local_size_1*p_.num_groups_1) };
   driver::NDRange local[2] = { driver::NDRange(p_.local_size_0, p_.local_size_1), driver::NDRange(p_.local_size_0, p_.local_size_1) };
   for(unsigned int i = 0 ; i < nk ; ++i)
-    controller.execution_options().enqueue(program.context(), kernels[i], global[i], local[i]);
+    control.execution_options().enqueue(program.context(), kernels[i], global[i], local[i]);
 }
 
 gemv_n::gemv_n(gemv_parameters  const & parameters,
diff --git a/lib/kernels/templates/ger.cpp b/lib/kernels/templates/ger.cpp
index c904dc477..958d049a2 100644
--- a/lib/kernels/templates/ger.cpp
+++ b/lib/kernels/templates/ger.cpp
@@ -20,7 +20,7 @@ ger_parameters::ger_parameters(unsigned int _simd_width,
 
 
 
-int ger::is_invalid_impl(driver::Device const &, expressions_tuple const &) const
+int ger::is_invalid_impl(driver::Device const &, math_expression const  &) const
 {
   if (p_.simd_width>1)
     return TEMPLATE_INVALID_SIMD_WIDTH;
@@ -29,7 +29,7 @@ int ger::is_invalid_impl(driver::Device const &, expressions_tuple const &) cons
   return TEMPLATE_VALID;
 }
 
-std::string ger::generate_impl(std::string const & suffix, expressions_tuple const & expressions, driver::Device const & device, std::vector<mapping_type> const & mappings) const
+std::string ger::generate_impl(std::string const & suffix, math_expression const  & expressions, driver::Device const & device, mapping_type const & mappings) const
 {
   kernel_generation_stream stream;
   std::string _size_t = size_type(device);
@@ -65,18 +65,18 @@ std::string ger::generate_impl(std::string const & suffix, expressions_tuple con
 
   process(stream, PARENT_NODE_TYPE, { {"array2", data_type + " #namereg = $VALUE{i*#stride,j};"},
                                       {"vdiag", "#scalartype #namereg = ((i + ((#diag_offset<0)?#diag_offset:0))!=(j-((#diag_offset>0)?#diag_offset:0)))?0:$VALUE{min(i*#stride, j*#stride)};"},
-                                      {"repeat", "#scalartype #namereg = $VALUE{(i%#tuplearg0)*#stride, (j%#tuplearg1)};"},
+                                      {"repeat", "#scalartype #namereg = $VALUE{(i%#sub0)*#stride, (j%#sub1)};"},
                                       {"outer", "#scalartype #namereg = ($LVALUE{i*#stride})*($RVALUE{j*#stride});"} }
                                     , expressions, mappings);
 
-  evaluate(stream, PARENT_NODE_TYPE, { {"array2", "#namereg"},
+  stream << evaluate(PARENT_NODE_TYPE, { {"array2", "#namereg"},
                                         {"vdiag", "#namereg"},
                                         {"repeat", "#namereg"},
                                         {"array0", "#namereg"},
                                         {"outer", "#namereg"},
                                         {"cast", CastPrefix(backend, data_type).get()},
                                         {"host_scalar", p_.simd_width==1?"#name": InitPrefix(backend, data_type).get() + "(#name)"}}
-                                    , expressions, mappings);
+                                    , expressions, expressions.root(), mappings) << ";" << std::endl;
 
   process(stream, LHS_NODE_TYPE, { {"array2", "$VALUE{i*#stride,j} = #namereg;"} } , expressions, mappings);
 
@@ -107,16 +107,15 @@ ger::ger(unsigned int simd, unsigned int ls1, unsigned int ls2,
     base_impl<ger, ger_parameters>(ger_parameters(simd, ls1, ls2, ng1, ng2, fetch), bind)
 {}
 
-std::vector<int_t> ger::input_sizes(expressions_tuple const & expressions) const
+std::vector<int_t> ger::input_sizes(math_expression const  & expression) const
 {
-  isaac::array_expression const & array_expression = *(expressions.data().front());
-  std::pair<int_t, int_t> size = matrix_size(lhs_most(array_expression.tree(), array_expression.root()));
+  std::pair<int_t, int_t> size = matrix_size(expression.tree(), lhs_most(expression.tree(), expression.root()));
   return {size.first, size.second};
 }
 
-void ger::enqueue(driver::CommandQueue & /*queue*/, driver::Program const & program, std::string const & suffix, base &, controller<expressions_tuple> const & controller)
+void ger::enqueue(driver::CommandQueue & /*queue*/, driver::Program const & program, std::string const & suffix, base &, execution_handler const & control)
 {
-  expressions_tuple const & expressions = controller.x();
+  math_expression const  & expressions = control.x();
   std::string name = "axpy";
   name +=suffix;
   driver::Kernel kernel(program, name.c_str());
@@ -128,7 +127,7 @@ void ger::enqueue(driver::CommandQueue & /*queue*/, driver::Program const & prog
   kernel.setSizeArg(current_arg++, MN[1]);
   set_arguments(expressions, kernel, current_arg, binding_policy_);
 
-  controller.execution_options().enqueue(program.context(), kernel, global, local);
+  control.execution_options().enqueue(program.context(), kernel, global, local);
 }
 
 }
diff --git a/lib/kernels/templates/tools/arguments.hpp b/lib/kernels/templates/tools/arguments.hpp
index a06a506db..fdf485503 100644
--- a/lib/kernels/templates/tools/arguments.hpp
+++ b/lib/kernels/templates/tools/arguments.hpp
@@ -12,7 +12,7 @@ namespace templates
 {
 
 //Generate
-inline std::string generate_arguments(std::string const & data_type, driver::Device const & device, std::vector<mapping_type> const & mappings, expressions_tuple const & expressions)
+inline std::string generate_arguments(std::string const &, driver::Device const & device, mapping_type const & mappings, math_expression const & expressions)
 {
     std::string kwglobal = Global(device.backend()).get();
     std::string _size_t = size_type(device);
@@ -21,8 +21,8 @@ inline std::string generate_arguments(std::string const & data_type, driver::Dev
 
     process(stream, PARENT_NODE_TYPE, { {"array0", kwglobal + " #scalartype* #pointer, " + _size_t + " #start,"},
                                         {"host_scalar", "#scalartype #name,"},
-                                        {"array1", kwglobal + " " + data_type + "* #pointer, " + _size_t + " #start, " + _size_t + " #stride,"},
-                                        {"array2", kwglobal + " " + data_type + "* #pointer, " + _size_t + " #ld, " + _size_t + " #start, " + _size_t + " #stride, "},
+                                        {"array1", kwglobal + " #scalartype* #pointer, " + _size_t + " #start, " + _size_t + " #stride,"},
+                                        {"array2", kwglobal + " #scalartype* #pointer, " + _size_t + " #ld, " + _size_t + " #start, " + _size_t + " #stride, "},
                                         {"tuple4", "#scalartype #name0, #scalartype #name1, #scalartype #name2, #scalartype #name3,"}}
             , expressions, mappings);
 
@@ -62,9 +62,9 @@ public:
         }
     }
 
-    void set_arguments(array const * a) const
+    void set_arguments(array const * a, bool is_assigned) const
     {
-        bool is_bound = binder_.bind(a->data());
+        bool is_bound = binder_.bind(a->data(), is_assigned);
         if (is_bound)
         {
             kernel_.setArg(current_arg_++, a->data());
@@ -88,33 +88,24 @@ public:
         }
     }
 
-    void set_arguments(repeat_infos const & i) const
-    {
-        kernel_.setSizeArg(current_arg_++, i.sub1);
-        kernel_.setSizeArg(current_arg_++, i.sub2);
-        kernel_.setSizeArg(current_arg_++, i.rep1);
-        kernel_.setSizeArg(current_arg_++, i.rep2);
-    }
-
-
-    void set_arguments(lhs_rhs_element const & lhs_rhs) const
+    void set_arguments(lhs_rhs_element const & lhs_rhs, bool is_assigned) const
     {
         switch(lhs_rhs.type_family)
         {
         case VALUE_TYPE_FAMILY: return set_arguments(lhs_rhs.dtype, lhs_rhs.vscalar);
-        case ARRAY_TYPE_FAMILY: return set_arguments(lhs_rhs.array);
-        case INFOS_TYPE_FAMILY: return set_arguments(lhs_rhs.tuple);
+        case ARRAY_TYPE_FAMILY: return set_arguments(lhs_rhs.array, is_assigned);
+        case PLACEHOLDER_TYPE_FAMILY: return;
         default: throw std::runtime_error("Unrecognized type family");
         }
     }
 
-    void operator()(isaac::array_expression const & array_expression, size_t root_idx, leaf_t leaf_t) const
+    void operator()(isaac::math_expression const & math_expression, size_t root_idx, leaf_t leaf_t) const
     {
-        array_expression::node const & root_node = array_expression.tree()[root_idx];
+        math_expression::node const & root_node = math_expression.tree()[root_idx];
         if (leaf_t==LHS_NODE_TYPE && root_node.lhs.type_family != COMPOSITE_OPERATOR_FAMILY)
-            set_arguments(root_node.lhs);
+            set_arguments(root_node.lhs, detail::is_assignment(root_node.op));
         else if (leaf_t==RHS_NODE_TYPE && root_node.rhs.type_family != COMPOSITE_OPERATOR_FAMILY)
-            set_arguments(root_node.rhs);
+            set_arguments(root_node.rhs, false);
     }
 
 
@@ -124,15 +115,15 @@ private:
     driver::Kernel & kernel_;
 };
 
-inline void set_arguments(expressions_tuple const & expressions, driver::Kernel & kernel, unsigned int & current_arg, binding_policy_t binding_policy)
+inline void set_arguments(math_expression const & expression, driver::Kernel & kernel, unsigned int & current_arg, binding_policy_t binding_policy)
 {
     std::unique_ptr<symbolic_binder> binder;
-    if (binding_policy==BIND_TO_HANDLE)
-        binder.reset(new bind_to_handle());
+    if (binding_policy==BIND_SEQUENTIAL)
+        binder.reset(new bind_sequential());
     else
-        binder.reset(new bind_all_unique());
-    for (const auto & elem : expressions.data())
-        traverse(*elem, (elem)->root(), set_arguments_functor(*binder, current_arg, kernel), true);
+        binder.reset(new bind_independent());
+    traverse(expression, expression.root(), set_arguments_functor(*binder, current_arg, kernel), true);
+
 }
 
 }
diff --git a/lib/kernels/templates/tools/map.hpp b/lib/kernels/templates/tools/map.hpp
index 130ac99b0..aa070c1aa 100644
--- a/lib/kernels/templates/tools/map.hpp
+++ b/lib/kernels/templates/tools/map.hpp
@@ -12,19 +12,19 @@ namespace templates
 class map_functor : public traversal_functor
 {
 
-  numeric_type get_numeric_type(isaac::array_expression const * array_expression, size_t root_idx) const
+  numeric_type get_numeric_type(isaac::math_expression const * math_expression, size_t root_idx) const
 {
-  array_expression::node const * root_node = &array_expression->tree()[root_idx];
+  math_expression::node const * root_node = &math_expression->tree()[root_idx];
   while (root_node->lhs.dtype==INVALID_NUMERIC_TYPE)
-    root_node = &array_expression->tree()[root_node->lhs.node_index];
+    root_node = &math_expression->tree()[root_node->lhs.node_index];
   return root_node->lhs.dtype;
 }
 
   template<class T>
-  std::shared_ptr<mapped_object> binary_leaf(isaac::array_expression const * array_expression, size_t root_idx, mapping_type const * mapping) const
-{
-  return std::shared_ptr<mapped_object>(new T(to_string(array_expression->dtype()), binder_.get(), mapped_object::node_info(mapping, array_expression, root_idx)));
-}
+  std::shared_ptr<mapped_object> binary_leaf(isaac::math_expression const * math_expression, size_t root_idx, mapping_type const * mapping) const
+  {
+    return std::shared_ptr<mapped_object>(new T(to_string(math_expression->dtype()), binder_.get(), mapped_object::node_info(mapping, math_expression, root_idx)));
+  }
 
   std::shared_ptr<mapped_object> create(numeric_type dtype, values_holder) const
   {
@@ -32,10 +32,10 @@ class map_functor : public traversal_functor
     return std::shared_ptr<mapped_object>(new mapped_host_scalar(strdtype, binder_.get()));
   }
 
-  std::shared_ptr<mapped_object> create(array const * a)  const
+  std::shared_ptr<mapped_object> create(array const * a, bool is_assigned)  const
   {
     std::string dtype = to_string(a->dtype());
-    unsigned int id = binder_.get(a->data());
+    unsigned int id = binder_.get(a->data(), is_assigned);
     //Scalar
     if(a->shape()[0]==1 && a->shape()[1]==1)
       return std::shared_ptr<mapped_object>(new mapped_array(dtype, id, 's'));
@@ -50,19 +50,13 @@ class map_functor : public traversal_functor
       return std::shared_ptr<mapped_object>(new mapped_array(dtype, id, 'm'));
   }
 
-  std::shared_ptr<mapped_object> create(repeat_infos const &) const
-  {
-    //TODO: Make it less specific!
-    return std::shared_ptr<mapped_object>(new mapped_tuple(size_type(device_),binder_.get(),4));
-  }
-
-  std::shared_ptr<mapped_object> create(lhs_rhs_element const & lhs_rhs) const
+  std::shared_ptr<mapped_object> create(lhs_rhs_element const & lhs_rhs, bool is_assigned = false) const
   {
     switch(lhs_rhs.type_family)
     {
-      case INFOS_TYPE_FAMILY: return create(lhs_rhs.tuple);
       case VALUE_TYPE_FAMILY: return create(lhs_rhs.dtype, lhs_rhs.vscalar);
-      case ARRAY_TYPE_FAMILY: return create(lhs_rhs.array);
+      case ARRAY_TYPE_FAMILY: return create(lhs_rhs.array, is_assigned);
+      case PLACEHOLDER_TYPE_FAMILY: return std::shared_ptr<mapped_object>(new mapped_placeholder(lhs_rhs.for_idx.level));
       default: throw "";
     }
   }
@@ -74,40 +68,40 @@ public:
   {
   }
 
-  void operator()(isaac::array_expression const & array_expression, size_t root_idx, leaf_t leaf_t) const
+  void operator()(isaac::math_expression const & math_expression, size_t root_idx, leaf_t leaf_t) const
   {
-      {
-        mapping_type::key_type key(root_idx, leaf_t);
-        array_expression::node const & root_node = array_expression.tree()[root_idx];
+    mapping_type::key_type key(root_idx, leaf_t);
+    math_expression::node const & root_node = math_expression.tree()[root_idx];
 
-        if (leaf_t == LHS_NODE_TYPE && root_node.lhs.type_family != COMPOSITE_OPERATOR_FAMILY)
-          mapping_.insert(mapping_type::value_type(key, create(root_node.lhs)));
-        else if (leaf_t == RHS_NODE_TYPE && root_node.rhs.type_family != COMPOSITE_OPERATOR_FAMILY)
-          mapping_.insert(mapping_type::value_type(key, create(root_node.rhs)));
-        else if ( leaf_t== PARENT_NODE_TYPE)
-        {
-          if (root_node.op.type==OPERATOR_VDIAG_TYPE)
-            mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_vdiag>(&array_expression, root_idx, &mapping_)));
-          else if (root_node.op.type==OPERATOR_MATRIX_DIAG_TYPE)
-            mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_matrix_diag>(&array_expression, root_idx, &mapping_)));
-          else if (root_node.op.type==OPERATOR_MATRIX_ROW_TYPE)
-            mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_matrix_row>(&array_expression, root_idx, &mapping_)));
-          else if (root_node.op.type==OPERATOR_MATRIX_COLUMN_TYPE)
-            mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_matrix_column>(&array_expression, root_idx, &mapping_)));
-          else if (detail::is_scalar_dot(root_node))
-            mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_scalar_dot>(&array_expression, root_idx, &mapping_)));
-          else if (detail::is_vector_dot(root_node))
-            mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_gemv>(&array_expression, root_idx, &mapping_)));
-          else if (root_node.op.type_family == OPERATOR_GEMM_TYPE_FAMILY)
-            mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_gemm>(&array_expression, root_idx, &mapping_)));
-          else if (root_node.op.type == OPERATOR_REPEAT_TYPE)
-            mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_repeat>(&array_expression, root_idx, &mapping_)));
-          else if (root_node.op.type == OPERATOR_OUTER_PROD_TYPE)
-            mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_outer>(&array_expression, root_idx, &mapping_)));
-          else if (detail::is_cast(root_node.op))
-            mapping_.insert(mapping_type::value_type(key, std::shared_ptr<mapped_object>(new mapped_cast(root_node.op.type, binder_.get()))));
-        }
-      }
+    if (leaf_t == LHS_NODE_TYPE && root_node.lhs.type_family != COMPOSITE_OPERATOR_FAMILY)
+      mapping_.insert(mapping_type::value_type(key, create(root_node.lhs, detail::is_assignment(root_node.op))));
+    else if (leaf_t == RHS_NODE_TYPE && root_node.rhs.type_family != COMPOSITE_OPERATOR_FAMILY)
+      mapping_.insert(mapping_type::value_type(key, create(root_node.rhs)));
+    else if ( leaf_t== PARENT_NODE_TYPE)
+    {
+      if (root_node.op.type==OPERATOR_VDIAG_TYPE)
+        mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_vdiag>(&math_expression, root_idx, &mapping_)));
+      else if (root_node.op.type==OPERATOR_MATRIX_DIAG_TYPE)
+        mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_matrix_diag>(&math_expression, root_idx, &mapping_)));
+      else if (root_node.op.type==OPERATOR_MATRIX_ROW_TYPE)
+        mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_matrix_row>(&math_expression, root_idx, &mapping_)));
+      else if (root_node.op.type==OPERATOR_MATRIX_COLUMN_TYPE)
+        mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_matrix_column>(&math_expression, root_idx, &mapping_)));
+      else if(root_node.op.type==OPERATOR_ACCESS_INDEX_TYPE)
+        mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_array_access>(&math_expression, root_idx, &mapping_)));
+      else if (detail::is_scalar_dot(root_node))
+        mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_scalar_dot>(&math_expression, root_idx, &mapping_)));
+      else if (detail::is_vector_dot(root_node))
+        mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_gemv>(&math_expression, root_idx, &mapping_)));
+      else if (root_node.op.type_family == OPERATOR_GEMM_TYPE_FAMILY)
+        mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_gemm>(&math_expression, root_idx, &mapping_)));
+      else if (root_node.op.type == OPERATOR_REPEAT_TYPE)
+        mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_repeat>(&math_expression, root_idx, &mapping_)));
+      else if (root_node.op.type == OPERATOR_OUTER_PROD_TYPE)
+        mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_outer>(&math_expression, root_idx, &mapping_)));
+      else if (detail::is_cast(root_node.op))
+        mapping_.insert(mapping_type::value_type(key, std::shared_ptr<mapped_object>(new mapped_cast(root_node.op.type, binder_.get()))));
+    }
   }
 private:
   symbolic_binder & binder_;
diff --git a/lib/kernels/templates/tools/reductions.hpp b/lib/kernels/templates/tools/reductions.hpp
index 757bcf611..0a28cd0a1 100644
--- a/lib/kernels/templates/tools/reductions.hpp
+++ b/lib/kernels/templates/tools/reductions.hpp
@@ -55,7 +55,7 @@ inline std::string neutral_element(op_element const & op, driver::backend_type b
   }
 }
 
-inline bool is_dot(array_expression::node const & node)
+inline bool is_dot(math_expression::node const & node)
 {
   return node.op.type_family==OPERATOR_VECTOR_DOT_TYPE_FAMILY
       || node.op.type_family==OPERATOR_COLUMNS_DOT_TYPE_FAMILY
diff --git a/lib/kernels/templates/tools/vector_types.hpp b/lib/kernels/templates/tools/vector_types.hpp
index b79d3ee46..1bb157a8a 100644
--- a/lib/kernels/templates/tools/vector_types.hpp
+++ b/lib/kernels/templates/tools/vector_types.hpp
@@ -39,58 +39,52 @@ inline std::string append_width(std::string const & str, unsigned int width)
 }
 
 
-inline std::string vstore(unsigned int simd_width, std::string const & dtype, std::string const & value, std::string const & offset, std::string const & ptr, driver::backend_type backend, bool aligned = true)
+inline std::string vstore(unsigned int simd_width, std::string const & dtype, std::string const & value, std::string const & offset, std::string const & ptr, std::string const & stride, driver::backend_type backend, bool aligned = true)
 {
     std::string vdtype = append_width(dtype,simd_width);
     if (simd_width==1)
       return "(" + ptr + ")[" + offset + "] = " + value;
     else
     {
-      switch(backend)
-      {
-        case driver::CUDA:
-          if(aligned)
-              return "reinterpret_cast<" + vdtype + "*>(" + ptr + ")[" + offset + "] = " + value;
-          else
-          {
-              std::string res;
-              for(unsigned int s = 0 ; s < simd_width ; ++s)
-                  res +=  (s>0?";(":"(") + ptr + ")[" + offset + " + " + tools::to_string(s) + "] = " + access_vector_type(value, s);
-              return res;
-          }
-        case driver::OPENCL:
+        if(backend == driver::CUDA && stride == "1" && aligned)
+          return "reinterpret_cast<" + vdtype + "*>(" + ptr + ")[" + offset + "] = " + value;
+        else if(backend == driver::OPENCL && stride == "1")
           return append_width("vstore", simd_width) + "(" + value + ", " + offset + ", " + ptr + ")";
-        default:
-          throw;
-      }
+        else
+        {
+          std::string stridestr = (stride=="1")?"":("*" + stride);
+          std::string res;
+          for(unsigned int s = 0 ; s < simd_width ; ++s)
+              res +=  (s>0?";(":"(") + ptr + ")[" + offset + " + " + tools::to_string(s) + stridestr + "] = " + access_vector_type(value, s);
+          return res;
+        }
     }
 }
 
 
-inline std::string vload(unsigned int simd_width, std::string const & dtype, std::string const & offset, std::string const & ptr, driver::backend_type backend, bool aligned = true)
+inline std::string vload(unsigned int simd_width, std::string const & dtype, std::string const & offset, std::string const & ptr, std::string const & stride, driver::backend_type backend, bool aligned = true)
 {
     std::string vdtype = append_width(dtype,simd_width);
     if (simd_width==1)
       return "(" + ptr + ")[" + offset + "]";
     else
     {
-      switch(backend)
-      {
-        case driver::CUDA:
-          if(aligned)
-            return "reinterpret_cast<" + vdtype + "*>(" + ptr + ")[" + offset + "]";
-          else
-          {
-            std::string res = "make_" + vdtype + "(";
-            for(unsigned int s = 0 ; s < simd_width ; ++s)
-                res += ((s>0)?",(":"(") + ptr + ")[" + offset + "*" + tools::to_string(simd_width) + " + " + tools::to_string(s) + "]";
-            res += ")";
-            return res;
-          }
-        case driver::OPENCL:
+      if(backend == driver::CUDA && stride == "1" && aligned)
+          return "reinterpret_cast<" + vdtype + "*>(" + ptr + ")[" + offset + "]";
+      else if(backend == driver::OPENCL && stride == "1")
           return append_width("vload", simd_width) + "(" + offset + ", " + ptr + ")";
-        default:
-          throw;
+      else
+      {
+        std::string stridestr = (stride=="1")?"":("*" + stride);
+        std::string res;
+        if(backend == driver::CUDA)
+          res = "make_" + vdtype + "(";
+        else
+          res = "(" + vdtype + ")(";
+        for(unsigned int s = 0 ; s < simd_width ; ++s)
+            res += ((s>0)?",(":"(") + ptr + ")[" + offset + "*" + tools::to_string(simd_width) + " + " + tools::to_string(s) + stridestr  + "]";
+        res += ")";
+        return res;
       }
     }
 }
diff --git a/lib/profiles/presets.cpp b/lib/profiles/presets.cpp
index f95e7948c..8123bd022 100644
--- a/lib/profiles/presets.cpp
+++ b/lib/profiles/presets.cpp
@@ -11,7 +11,7 @@ namespace isaac
             {std::make_tuple(driver::Device::Type::TYPE, driver::Device::Vendor::VENDOR, driver::Device::Architecture::ARCHITECTURE), STRING}
 
 const profiles::presets_type profiles::presets_ =
-            { DATABASE_ENTRY(GPU, INTEL, BROADWELL, presets::broadwell) };
+            {  };
 
 
 #undef DATABASE_ENTRY
diff --git a/lib/profiles/profiles.cpp b/lib/profiles/profiles.cpp
index ecdc609f0..c4321838b 100644
--- a/lib/profiles/profiles.cpp
+++ b/lib/profiles/profiles.cpp
@@ -28,46 +28,35 @@ static long time_event(long sum, driver::Event const & e)
     return sum + e.elapsed_time();
 }
 
-void profiles::value_type::fill_program_name(char* program_name, expressions_tuple const & expressions, binding_policy_t binding_policy)
+driver::Program const & profiles::value_type::init(execution_handler const & expression)
 {
-  if (expressions.order()==expressions_tuple::INDEPENDENT)
-    *program_name++='i';
-  else
-    *program_name++='s';
-  symbolic_binder* binder = NULL;
-  if(binding_policy==BIND_TO_HANDLE)
-    binder = new bind_to_handle();
-  else
-    binder = new bind_all_unique();
-  for (const auto & elem : expressions.data())
-    traverse(*elem, elem->root(), array_expression_representation_functor(*binder, program_name),true);
-  *program_name='\0';
-  delete binder;
-}
-
-driver::Program const & profiles::value_type::init(controller<expressions_tuple> const & expressions)
-{
-  driver::Context & context = (driver::Context&)expressions.x().context();
+  driver::Context & context = (driver::Context&)expression.x().context();
   std::string pname;
-  compilation_options_type const & opt = expressions.compilation_options();
+  compilation_options_type const & opt = expression.compilation_options();
   if(opt.program_name.empty())
   {
     char program_name[256];
-    fill_program_name(program_name, expressions.x(), BIND_TO_HANDLE);
+
+    char* ptr = program_name;
+    bind_independent binder;
+    traverse(expression.x(), expression.x().root(), math_expression_representation_functor(binder, ptr),true);
+    *ptr='\0';
     pname = std::string(program_name);
+
   }
   else
-    pname = expressions.compilation_options().program_name;
+    pname = expression.compilation_options().program_name;
 
   driver::Program const * program = cache_.find(pname);
+
   if(program)
       return *program;
 
   std::string srcs;
    for(unsigned int i = 0 ; i < templates_.size() ; ++i){
-     srcs += templates_[i]->generate(tools::to_string(i), expressions.x(), context.device());
+     srcs += templates_[i]->generate(tools::to_string(i), expression.x(), context.device());
    }
-   srcs += fallback_->generate("fallback", expressions.x(), context.device());
+   srcs += fallback_->generate("fallback", expression.x(), context.device());
    return cache_.add(context, pname, srcs);
 }
 
@@ -83,7 +72,7 @@ profiles::value_type::value_type(expression_type etype, numeric_type dtype, temp
   cache_.clear();
 }
 
-void profiles::value_type::execute(controller<expressions_tuple> const & expr)
+void profiles::value_type::execute(execution_handler const & expr)
 {
   driver::Program const & program = init(expr);
   std::vector<int_t> x = templates_[0]->input_sizes(expr.x());
@@ -101,7 +90,7 @@ void profiles::value_type::execute(controller<expressions_tuple> const & expr)
       }
       std::list<driver::Event> events;
       try{
-        templates_[i]->enqueue(queue_, program, tools::to_string(i), *fallback_, control(expr.x(), execution_options_type(0, &events)));
+        templates_[i]->enqueue(queue_, program, tools::to_string(i), *fallback_, execution_handler(expr.x(), execution_options_type(0, &events)));
         queue_.synchronize();
         timings[i] = 1e-9*std::accumulate(events.begin(), events.end(), 0, &time_event);
       }catch(...){
diff --git a/lib/symbolic/execute.cpp b/lib/symbolic/execute.cpp
index c13e0b1b7..c935e5d2f 100644
--- a/lib/symbolic/execute.cpp
+++ b/lib/symbolic/execute.cpp
@@ -85,6 +85,8 @@ namespace isaac
                 else if(left == AXPY_TYPE || right == AXPY_TYPE) return op.type==OPERATOR_OUTER_PROD_TYPE?GER_TYPE:AXPY_TYPE;
                 else if(left == GER_TYPE || right == GER_TYPE) return GER_TYPE;
                 else if(is_mmprod(left) || is_mmprod(right)) return GER_TYPE;
+                else if(right == INVALID_EXPRESSION_TYPE) return left;
+                else if(left == INVALID_EXPRESSION_TYPE) return right;
                 throw;
             case OPERATOR_VECTOR_DOT_TYPE_FAMILY:
                 return DOT_TYPE;
@@ -103,12 +105,12 @@ namespace isaac
     }
 
     /** @brief Parses the breakpoints for a given expression tree */
-    static void parse(array_expression::container_type&array, size_t idx,
+    static void parse(math_expression::container_type&array, size_t idx,
                breakpoints_t & breakpoints,
                expression_type & final_type,
                bool is_first = true)
     {
-      array_expression::node & node = array[idx];
+      math_expression::node & node = array[idx];
 
       //Left
       expression_type type_left = INVALID_EXPRESSION_TYPE;
@@ -144,17 +146,17 @@ namespace isaac
     }
   }
 
-  /** @brief Executes a array_expression on the given models map*/
-  void execute(controller<array_expression> const & c, profiles::map_type & profiles)
+  /** @brief Executes a math_expression on the given models map*/
+  void execute(execution_handler const & c, profiles::map_type & profiles)
   {
-    array_expression expression = c.x();
+    math_expression expression = c.x();
     driver::Context const & context = expression.context();
     size_t rootidx = expression.root();
-    array_expression::container_type & tree = const_cast<array_expression::container_type &>(expression.tree());
-    array_expression::node root_save = tree[rootidx];
+    math_expression::container_type & tree = const_cast<math_expression::container_type &>(expression.tree());
+    math_expression::node root_save = tree[rootidx];
 
     //Todo: technically the datatype should be per temporary
-    numeric_type dtype = root_save.lhs.dtype;
+    numeric_type dtype = expression.dtype();
 
     expression_type final_type;
     //GEMM
@@ -169,7 +171,7 @@ namespace isaac
 
         //Init
         expression_type current_type;
-        if(root_save.lhs.array->nshape()<=1)
+        if(expression.nshape()<=1)
           current_type=AXPY_TYPE;
         else
           current_type=GER_TYPE;
@@ -183,8 +185,8 @@ namespace isaac
         for(detail::breakpoints_t::iterator it = breakpoints.begin() ; it != breakpoints.end() ; ++it)
         {
           std::shared_ptr<profiles::value_type> const & profile = profiles[std::make_pair(it->first, dtype)];
-          array_expression::node const & node = tree[it->second->node_index];
-          array_expression::node const & lmost = lhs_most(tree, node);
+          math_expression::node const & node = tree[it->second->node_index];
+          math_expression::node const & lmost = lhs_most(tree, node);
 
           //Creates temporary
           std::shared_ptr<array> tmp;
@@ -211,16 +213,21 @@ namespace isaac
           tree[rootidx].rhs.type_family = it->second->type_family;
 
           //Execute
-          profile->execute(controller<expressions_tuple>(expression, c.execution_options(), c.dispatcher_options(), c.compilation_options()));
+          profile->execute(execution_handler(expression, c.execution_options(), c.dispatcher_options(), c.compilation_options()));
           tree[rootidx] = root_save;
 
-          //Incorporates the temporary within the array_expression
+          //Incorporates the temporary within the math_expression
           fill(*it->second, (array&)*tmp);
         }
     }
 
     /*-----Compute final expression-----*/
-    profiles[std::make_pair(final_type, dtype)]->execute(controller<expressions_tuple>(expression, c.execution_options(), c.dispatcher_options(), c.compilation_options()));
+    profiles[std::make_pair(final_type, dtype)]->execute(execution_handler(expression, c.execution_options(), c.dispatcher_options(), c.compilation_options()));
+  }
+
+  void execute(execution_handler const & c)
+  {
+    execute(c, isaac::profiles::get(c.execution_options().queue(c.x().context())));
   }
 
 }
diff --git a/lib/symbolic/expression.cpp b/lib/symbolic/expression.cpp
index ed25fe66b..aab553655 100644
--- a/lib/symbolic/expression.cpp
+++ b/lib/symbolic/expression.cpp
@@ -23,6 +23,14 @@ void fill(lhs_rhs_element & x, std::size_t node_index)
   x.node_index = node_index;
 }
 
+void fill(lhs_rhs_element & x, for_idx_t index)
+{
+  x.type_family = PLACEHOLDER_TYPE_FAMILY;
+  x.subtype = FOR_LOOP_INDEX_TYPE;
+  x.dtype = INVALID_NUMERIC_TYPE;
+  x.for_idx = index;
+}
+
 void fill(lhs_rhs_element & x, array const & a)
 {
   x.type_family = ARRAY_TYPE_FAMILY;
@@ -39,14 +47,6 @@ void fill(lhs_rhs_element & x, value_scalar const & v)
   x.vscalar = v.values();
 }
 
-void fill(lhs_rhs_element & x, repeat_infos const & r)
-{
-  x.type_family = INFOS_TYPE_FAMILY;
-  x.subtype = REPEAT_INFOS_TYPE;
-  x.dtype = INVALID_NUMERIC_TYPE;
-  x.tuple = r;
-}
-
 lhs_rhs_element::lhs_rhs_element(){}
 
 //
@@ -54,9 +54,38 @@ op_element::op_element() {}
 op_element::op_element(operation_node_type_family const & _type_family, operation_node_type const & _type) : type_family(_type_family), type(_type){}
 
 //
+math_expression::math_expression(for_idx_t const &lhs, for_idx_t const &rhs, const op_element &op)
+ : tree_(1), root_(0), context_(NULL), dtype_(INVALID_NUMERIC_TYPE), shape_(1)
+{
+  fill(tree_[0].lhs, lhs);
+  tree_[0].op = op;
+  fill(tree_[0].rhs, rhs);
+}
+
+math_expression::math_expression(for_idx_t const &lhs, value_scalar const &rhs, const op_element &op, const numeric_type &dtype)
+ : tree_(1), root_(0), context_(NULL), dtype_(dtype), shape_(1)
+{
+  fill(tree_[0].lhs, lhs);
+  tree_[0].op = op;
+  fill(tree_[0].rhs, rhs);
+}
+
+math_expression::math_expression(value_scalar const &lhs, for_idx_t const &rhs, const op_element &op, const numeric_type &dtype)
+ : tree_(1), root_(0), context_(NULL), dtype_(dtype), shape_(1)
+{
+  fill(tree_[0].lhs, lhs);
+  tree_[0].op = op;
+  fill(tree_[0].rhs, rhs);
+}
+
+
+
+//math_expression(for_idx_t const &lhs, for_idx_t const &rhs, const op_element &op);
+//math_expression(for_idx_t const &lhs, value_scalar const &rhs, const op_element &op, const numeric_type &dtype);
+
 template<class LT, class RT>
-array_expression::array_expression(LT const & lhs, RT const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape) :
-  tree_(1), root_(0), context_(context), dtype_(dtype), shape_(shape)
+math_expression::math_expression(LT const & lhs, RT const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape) :
+  tree_(1), root_(0), context_(&context), dtype_(dtype), shape_(shape)
 {
   fill(tree_[0].lhs, lhs);
   tree_[0].op = op;
@@ -64,8 +93,8 @@ array_expression::array_expression(LT const & lhs, RT const & rhs, op_element co
 }
 
 template<class RT>
-array_expression::array_expression(array_expression const & lhs, RT const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape) :
- tree_(lhs.tree_.size() + 1), root_(tree_.size()-1), context_(context), dtype_(dtype), shape_(shape)
+math_expression::math_expression(math_expression const & lhs, RT const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape) :
+ tree_(lhs.tree_.size() + 1), root_(tree_.size()-1), context_(&context), dtype_(dtype), shape_(shape)
 {
   std::copy(lhs.tree_.begin(), lhs.tree_.end(), tree_.begin());
   fill(tree_[root_].lhs, lhs.root_);
@@ -74,8 +103,8 @@ array_expression::array_expression(array_expression const & lhs, RT const & rhs,
 }
 
 template<class LT>
-array_expression::array_expression(LT const & lhs, array_expression const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape) :
-  tree_(rhs.tree_.size() + 1), root_(tree_.size() - 1), context_(context), dtype_(dtype), shape_(shape)
+math_expression::math_expression(LT const & lhs, math_expression const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape) :
+  tree_(rhs.tree_.size() + 1), root_(tree_.size() - 1), context_(&context), dtype_(dtype), shape_(shape)
 {
   std::copy(rhs.tree_.begin(), rhs.tree_.end(), tree_.begin());
   fill(tree_[root_].lhs, lhs);
@@ -83,8 +112,8 @@ array_expression::array_expression(LT const & lhs, array_expression const & rhs,
   fill(tree_[root_].rhs, rhs.root_);
 }
 
-array_expression::array_expression(array_expression const & lhs, array_expression const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape):
-  tree_(lhs.tree_.size() + rhs.tree_.size() + 1), root_(tree_.size()-1), context_(context), dtype_(dtype), shape_(shape)
+math_expression::math_expression(math_expression const & lhs, math_expression const & rhs, op_element const & op, driver::Context const & context, numeric_type const & dtype, size4 const & shape):
+  tree_(lhs.tree_.size() + rhs.tree_.size() + 1), root_(tree_.size()-1), context_(&context), dtype_(dtype), shape_(shape)
 {  
   std::size_t lsize = lhs.tree_.size();
   std::copy(lhs.tree_.begin(), lhs.tree_.end(), tree_.begin());
@@ -99,111 +128,84 @@ array_expression::array_expression(array_expression const & lhs, array_expressio
   root_ = tree_.size() - 1;
 }
 
-template array_expression::array_expression(array_expression const &, value_scalar const &, op_element const &,  driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(array_expression const &, invalid_node const &, op_element const &,  driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(array_expression const &, array const &,        op_element const &,  driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(array_expression const &, repeat_infos const &, op_element const &,  driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(math_expression const &, value_scalar const &, op_element const &,  driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(math_expression const &, invalid_node const &, op_element const &,  driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(math_expression const &, array const &,        op_element const &,  driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(math_expression const &, for_idx_t const &,        op_element const &,  driver::Context const &, numeric_type const &, size4 const &);
 
-template array_expression::array_expression(value_scalar const &, array_expression const &, op_element const &,  driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(invalid_node const &, array_expression const &, op_element const &,  driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(array const &, array_expression const &, op_element const &,         driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(repeat_infos const &, array_expression const &, op_element const &,  driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(value_scalar const &, value_scalar const &,        op_element const &, driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(value_scalar const &, invalid_node const &,        op_element const &, driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(value_scalar const &, array const &,        op_element const &, driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(value_scalar const &, math_expression const &, op_element const &,  driver::Context const &, numeric_type const &, size4 const &);
 
-template array_expression::array_expression(value_scalar const &, value_scalar const &, op_element const &, driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(invalid_node const &, value_scalar const &, op_element const &, driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(array const &,        value_scalar const &, op_element const &, driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(repeat_infos const &, value_scalar const &, op_element const &, driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(invalid_node const &, value_scalar const &, op_element const &,  driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(invalid_node const &, math_expression const &, op_element const &,  driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(invalid_node const &, invalid_node const &, op_element const &, driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(invalid_node const &, array const &,        op_element const &, driver::Context const &, numeric_type const &, size4 const &);
 
-template array_expression::array_expression(value_scalar const &, invalid_node const &, op_element const &, driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(invalid_node const &, invalid_node const &, op_element const &, driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(array const &,        invalid_node const &, op_element const &, driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(repeat_infos const &, invalid_node const &, op_element const &, driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(array const &, math_expression const &, op_element const &,         driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(array const &, value_scalar const &, op_element const &, driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(array const &, invalid_node const &, op_element const &, driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(array const &, array const &,        op_element const &, driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(array const &, for_idx_t const &, op_element const &,         driver::Context const &, numeric_type const &, size4 const &);
 
-template array_expression::array_expression(value_scalar const &, array const &,        op_element const &, driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(invalid_node const &, array const &,        op_element const &, driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(array const &,        array const &,        op_element const &, driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(repeat_infos const &, array const &,        op_element const &, driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(for_idx_t const &, math_expression const &, op_element const &,         driver::Context const &, numeric_type const &, size4 const &);
+template math_expression::math_expression(for_idx_t const &, array const &,        op_element const &, driver::Context const &, numeric_type const &, size4 const &);
 
-template array_expression::array_expression(value_scalar const &, repeat_infos const &, op_element const &, driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(invalid_node const &, repeat_infos const &, op_element const &, driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(array const &,        repeat_infos const &, op_element const &, driver::Context const &, numeric_type const &, size4 const &);
-template array_expression::array_expression(repeat_infos const &, repeat_infos const &, op_element const &, driver::Context const &, numeric_type const &, size4 const &);
-
-
-
-array_expression::container_type & array_expression::tree()
+math_expression::container_type & math_expression::tree()
 { return tree_; }
 
-array_expression::container_type const & array_expression::tree() const
+math_expression::container_type const & math_expression::tree() const
 { return tree_; }
 
-std::size_t array_expression::root() const
+std::size_t math_expression::root() const
 { return root_; }
 
-driver::Context const & array_expression::context() const
-{ return context_; }
+driver::Context const & math_expression::context() const
+{ return *context_; }
 
-numeric_type const & array_expression::dtype() const
+numeric_type const & math_expression::dtype() const
 { return dtype_; }
 
-size4 array_expression::shape() const
+size4 math_expression::shape() const
 { return shape_; }
 
-int_t array_expression::nshape() const
+int_t math_expression::nshape() const
 { return int_t((shape_[0] > 1) + (shape_[1] > 1)); }
 
-array_expression& array_expression::reshape(int_t size1, int_t size2)
+math_expression& math_expression::reshape(int_t size1, int_t size2)
 {
   assert(size1*size2==prod(shape_));
   shape_ = size4(size1, size2);
   return *this;
 }
 
-array_expression array_expression::operator-()
-{ return array_expression(*this,  invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_SUB_TYPE), context_, dtype_, shape_); }
+math_expression math_expression::operator-()
+{ return math_expression(*this,  invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_SUB_TYPE), *context_, dtype_, shape_); }
 
-array_expression array_expression::operator!()
-{ return array_expression(*this, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_NEGATE_TYPE), context_, INT_TYPE, shape_); }
+math_expression math_expression::operator!()
+{ return math_expression(*this, invalid_node(), op_element(OPERATOR_UNARY_TYPE_FAMILY, OPERATOR_NEGATE_TYPE), *context_, INT_TYPE, shape_); }
 
 //
-std::shared_ptr<array_expression> expressions_tuple::create(array_expression const & s)
+
+math_expression::node const & lhs_most(math_expression::container_type const & array, math_expression::node const & init)
 {
-  return std::shared_ptr<array_expression>(new array_expression(static_cast<array_expression const &>(s)));
-}
-
-expressions_tuple::expressions_tuple(data_type const & data, order_type order) : data_(data), order_(order)
-{ }
-
-expressions_tuple::expressions_tuple(array_expression const & s0) : order_(INDEPENDENT)
-{
-  data_.push_back(create(s0));
-}
-
-expressions_tuple::expressions_tuple(order_type order, array_expression const & s0, array_expression const & s1) : order_(order)
-{
-  data_.push_back(create(s0));
-  data_.push_back(create(s1));
-}
-
-expressions_tuple::data_type const & expressions_tuple::data() const
-{ return data_; }
-
-driver::Context const & expressions_tuple::context() const
-{ return data_.front()->context(); }
-
-expressions_tuple::order_type expressions_tuple::order() const
-{ return order_; }
-
-array_expression::node const & lhs_most(array_expression::container_type const & array, array_expression::node const & init)
-{
-  array_expression::node const * current = &init;
+  math_expression::node const * current = &init;
   while (current->lhs.type_family==COMPOSITE_OPERATOR_FAMILY)
     current = &array[current->lhs.node_index];
   return *current;
 }
 
-array_expression::node const & lhs_most(array_expression::container_type const & array, size_t root)
+math_expression::node const & lhs_most(math_expression::container_type const & array, size_t root)
 { return lhs_most(array, array[root]); }
 
+//
+math_expression for_idx_t::operator=(value_scalar const & r) const { return math_expression(*this, r, op_element(OPERATOR_BINARY_TYPE_FAMILY,OPERATOR_ASSIGN_TYPE), r.dtype()); }
+math_expression for_idx_t::operator=(math_expression const & r) const { return math_expression(*this, r, op_element(OPERATOR_BINARY_TYPE_FAMILY,OPERATOR_ASSIGN_TYPE), r.context(), r.dtype(), r.shape()); }
+
+math_expression for_idx_t::operator+=(value_scalar const & r) const { return *this = *this + r; }
+math_expression for_idx_t::operator-=(value_scalar const & r) const { return *this = *this - r; }
+math_expression for_idx_t::operator*=(value_scalar const & r) const { return *this = *this * r; }
+math_expression for_idx_t::operator/=(value_scalar const & r) const { return *this = *this / r; }
 
 }
diff --git a/lib/symbolic/io.cpp b/lib/symbolic/io.cpp
index 083291864..67dee93b4 100644
--- a/lib/symbolic/io.cpp
+++ b/lib/symbolic/io.cpp
@@ -10,7 +10,7 @@ namespace isaac
 
 #define ISAAC_MAP_TO_STRING(NAME) case NAME: return #NAME
 
-inline std::string to_string(array_expression_node_subtype const & f)
+inline std::string to_string(math_expression_node_subtype const & f)
 {
   switch(f)
   {
@@ -30,7 +30,7 @@ inline std::string to_string(lhs_rhs_element const & e)
   return tools::to_string(e.subtype);
 }
 
-inline std::ostream & operator<<(std::ostream & os, array_expression::node const & s_node)
+inline std::ostream & operator<<(std::ostream & os, math_expression::node const & s_node)
 {
   os << "LHS: " << to_string(s_node.lhs) << "|" << s_node.lhs.dtype << ", "
      << "OP: "  << s_node.op.type_family << " | " << s_node.op.type << ", "
@@ -42,11 +42,11 @@ inline std::ostream & operator<<(std::ostream & os, array_expression::node const
 
 namespace detail
 {
-  /** @brief Recursive worker routine for printing a whole array_expression */
-  inline void print_node(std::ostream & os, isaac::array_expression const & s, size_t node_index, size_t indent = 0)
+  /** @brief Recursive worker routine for printing a whole math_expression */
+  inline void print_node(std::ostream & os, isaac::math_expression const & s, size_t node_index, size_t indent = 0)
   {
-    array_expression::container_type const & nodes = s.tree();
-    array_expression::node const & current_node = nodes[node_index];
+    math_expression::container_type const & nodes = s.tree();
+    math_expression::node const & current_node = nodes[node_index];
 
     for (size_t i=0; i<indent; ++i)
       os << " ";
@@ -61,7 +61,7 @@ namespace detail
   }
 }
 
-std::string to_string(isaac::array_expression const & s)
+std::string to_string(isaac::math_expression const & s)
 {
   std::ostringstream os;
   detail::print_node(os, s, s.root());
diff --git a/lib/symbolic/preset.cpp b/lib/symbolic/preset.cpp
index 032ba13c6..fa969515c 100644
--- a/lib/symbolic/preset.cpp
+++ b/lib/symbolic/preset.cpp
@@ -9,7 +9,7 @@ namespace symbolic
 namespace preset
 {
 
-void gemm::handle_node(array_expression::container_type &tree, size_t rootidx, args & a)
+void gemm::handle_node(math_expression::container_type const & tree, size_t rootidx, args & a)
 {
     //Matrix-Matrix product node
     if(tree[rootidx].op.type_family==OPERATOR_GEMM_TYPE_FAMILY)
@@ -46,9 +46,9 @@ void gemm::handle_node(array_expression::container_type &tree, size_t rootidx, a
     }
 }
 
-gemm::args gemm::check(array_expression::container_type & tree, size_t rootidx)
+gemm::args gemm::check(math_expression::container_type const & tree, size_t rootidx)
 {
-    lhs_rhs_element * assigned = &tree[rootidx].lhs;
+    lhs_rhs_element const * assigned = &tree[rootidx].lhs;
     gemm::args result ;
     if(tree[rootidx].rhs.type_family==COMPOSITE_OPERATOR_FAMILY)
     {
diff --git a/lib/value_scalar.cpp b/lib/value_scalar.cpp
index 8105281dd..4b9bd59e7 100644
--- a/lib/value_scalar.cpp
+++ b/lib/value_scalar.cpp
@@ -50,7 +50,7 @@ INSTANTIATE(double)
 
 value_scalar::value_scalar(numeric_type dtype) : dtype_(dtype) {}
 value_scalar::value_scalar(scalar const & s) : dtype_(s.dtype()) { s.inject(values_); }
-value_scalar::value_scalar(array_expression const &expr) : dtype_(expr.dtype()) { scalar(expr).inject(values_); }
+value_scalar::value_scalar(math_expression const &expr) : dtype_(expr.dtype()) { scalar(expr).inject(values_); }
 value_scalar::value_scalar(values_holder values, numeric_type dtype) : values_(values), dtype_(dtype) {}
 values_holder value_scalar::values() const
 { return values_; }
diff --git a/lib/wrap/clBLAS.cpp b/lib/wrap/clBLAS.cpp
index 5d8ee8309..93a06bcb0 100644
--- a/lib/wrap/clBLAS.cpp
+++ b/lib/wrap/clBLAS.cpp
@@ -2,7 +2,7 @@
 #include "isaac/array.h"
 #include "isaac/symbolic/execute.h"
 
-namespace is = isaac;
+namespace sc = isaac;
 
 extern "C"
 {
@@ -18,25 +18,25 @@ extern "C"
         isaac::driver::backend::release();
     }
 
-    void execute(is::array_expression const & operation, is::driver::Context const & context,
+    void execute(sc::math_expression const & operation, sc::driver::Context const & context,
                  cl_uint numCommandQueues, cl_command_queue *commandQueues,
                  cl_uint numEventsInWaitList, const cl_event *eventWaitList,
                  cl_event *events)
     {
-        std::vector<is::driver::Event> waitlist;
+        std::vector<sc::driver::Event> waitlist;
         for(cl_uint i = 0 ; i < numEventsInWaitList ; ++i)
             waitlist.push_back(eventWaitList[i]);
         for(cl_uint i = 0 ; i < numCommandQueues ; ++i)
         {
-            std::list<is::driver::Event> levents;
-            is::execution_options_type options(is::driver::CommandQueue(commandQueues[i],false), &levents, &waitlist);
-            is::execute(is::control(operation, options), is::profiles::get(options.queue(context)));
+            std::list<sc::driver::Event> levents;
+            sc::execution_options_type options(sc::driver::CommandQueue(commandQueues[i],false), &levents, &waitlist);
+            sc::execute(sc::execution_handler(operation, options), sc::profiles::get(options.queue(context)));
             if(events)
             {
                 events[i] = levents.front().handle().cl();
-                is::driver::dispatch::clRetainEvent(events[i]);
+                sc::driver::dispatch::clRetainEvent(events[i]);
             }
-            is::driver::dispatch::clFlush(commandQueues[i]);
+            sc::driver::dispatch::clFlush(commandQueues[i]);
         }
 
     }
@@ -54,14 +54,14 @@ extern "C"
                             cl_uint numEventsInWaitList, const cl_event *eventWaitList, \
                             cl_event *events) \
     { \
-        is::array x((is::int_t)N, TYPE_ISAAC, is::driver::Buffer(mx,false), (is::int_t)offx, incx); \
-        is::array y((is::int_t)N, TYPE_ISAAC, is::driver::Buffer(my,false), (is::int_t)offy, incy); \
-        execute(is::assign(y, alpha*x + y), y.context(), numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events); \
+        sc::array x((sc::int_t)N, TYPE_ISAAC, sc::driver::Buffer(mx,false), (sc::int_t)offx, incx); \
+        sc::array y((sc::int_t)N, TYPE_ISAAC, sc::driver::Buffer(my,false), (sc::int_t)offy, incy); \
+        execute(sc::assign(y, alpha*x + y), y.context(), numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events); \
         return clblasSuccess; \
     }
 
-    MAKE_AXPY(S, is::FLOAT_TYPE, cl_float)
-    MAKE_AXPY(D, is::DOUBLE_TYPE, cl_double)
+    MAKE_AXPY(S, sc::FLOAT_TYPE, cl_float)
+    MAKE_AXPY(D, sc::DOUBLE_TYPE, cl_double)
 
     //SCAL
     #define MAKE_SCAL(TYPE_CHAR, TYPE_ISAAC, TYPE_CL) \
@@ -70,13 +70,13 @@ extern "C"
                              cl_uint numCommandQueues, cl_command_queue *commandQueues,\
                              cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *events)\
     {\
-        is::array x((is::int_t)N, TYPE_ISAAC, is::driver::Buffer(mx,false), (is::int_t)offx, incx);\
-        execute(is::assign(x, alpha*x), x.context(), numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
+        sc::array x((sc::int_t)N, TYPE_ISAAC, sc::driver::Buffer(mx,false), (sc::int_t)offx, incx);\
+        execute(sc::assign(x, alpha*x), x.context(), numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
         return clblasSuccess;\
     }
 
-    MAKE_SCAL(S, is::FLOAT_TYPE, cl_float)
-    MAKE_SCAL(D, is::DOUBLE_TYPE, cl_double)
+    MAKE_SCAL(S, sc::FLOAT_TYPE, cl_float)
+    MAKE_SCAL(D, sc::DOUBLE_TYPE, cl_double)
 
     //COPY
     #define MAKE_COPY(TYPE_CHAR, TYPE_ISAAC, TYPE_CL)\
@@ -86,14 +86,14 @@ extern "C"
                              cl_uint numCommandQueues, cl_command_queue *commandQueues,\
                              cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *events)\
     {\
-        const is::array x((is::int_t)N, TYPE_ISAAC, is::driver::Buffer(mx, false), (is::int_t)offx, incx);\
-        is::array y((is::int_t)N, TYPE_ISAAC, is::driver::Buffer(my, false), (is::int_t)offy, incy);\
-        execute(is::assign(y, x), y.context(), numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
+        const sc::array x((sc::int_t)N, TYPE_ISAAC, sc::driver::Buffer(mx, false), (sc::int_t)offx, incx);\
+        sc::array y((sc::int_t)N, TYPE_ISAAC, sc::driver::Buffer(my, false), (sc::int_t)offy, incy);\
+        execute(sc::assign(y, x), y.context(), numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
         return clblasSuccess;\
     }
 
-    MAKE_COPY(S, is::FLOAT_TYPE, cl_float)
-    MAKE_COPY(D, is::DOUBLE_TYPE, cl_double)
+    MAKE_COPY(S, sc::FLOAT_TYPE, cl_float)
+    MAKE_COPY(D, sc::DOUBLE_TYPE, cl_double)
 
     //DOT
     #define MAKE_DOT(TYPE_CHAR, TYPE_ISAAC, TYPE_CL) \
@@ -104,15 +104,15 @@ extern "C"
                cl_command_queue *commandQueues, cl_uint numEventsInWaitList, \
                const cl_event *eventWaitList, cl_event *events) \
     { \
-        is::array x((is::int_t)N, TYPE_ISAAC, is::driver::Buffer(mx, false), (is::int_t)offx, incx); \
-        is::array y((is::int_t)N, TYPE_ISAAC, is::driver::Buffer(my, false), (is::int_t)offy, incy); \
-        is::scalar s(TYPE_ISAAC, is::driver::Buffer(dotProduct, false), (is::int_t)offDP); \
-        execute(is::assign(s, dot(x,y)), s.context(), numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events); \
+        sc::array x((sc::int_t)N, TYPE_ISAAC, sc::driver::Buffer(mx, false), (sc::int_t)offx, incx); \
+        sc::array y((sc::int_t)N, TYPE_ISAAC, sc::driver::Buffer(my, false), (sc::int_t)offy, incy); \
+        sc::scalar s(TYPE_ISAAC, sc::driver::Buffer(dotProduct, false), (sc::int_t)offDP); \
+        execute(sc::assign(s, dot(x,y)), s.context(), numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events); \
         return clblasSuccess; \
     }
 
-    MAKE_DOT(S, is::FLOAT_TYPE, cl_float)
-    MAKE_DOT(D, is::DOUBLE_TYPE, cl_double)
+    MAKE_DOT(S, sc::FLOAT_TYPE, cl_float)
+    MAKE_DOT(D, sc::DOUBLE_TYPE, cl_double)
 
     //ASUM
     #define MAKE_ASUM(TYPE_CHAR, TYPE_ISAAC, TYPE_CL) \
@@ -121,14 +121,15 @@ extern "C"
                              cl_mem /*scratchBuff*/, cl_uint numCommandQueues, cl_command_queue *commandQueues,\
                              cl_uint numEventsInWaitList, const cl_event *eventWaitList, cl_event *events)\
     {\
-        is::array x((is::int_t)N, TYPE_ISAAC, is::driver::Buffer(mx, false), (is::int_t)offx, incx);\
-        is::scalar s(TYPE_ISAAC, is::driver::Buffer(asum, false), (is::int_t)offAsum);\
-        execute(is::assign(s, sum(abs(x))), s.context(), numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
+        sc::array x((sc::int_t)N, TYPE_ISAAC, sc::driver::Buffer(mx, false), (sc::int_t)offx, incx);\
+        sc::scalar s(TYPE_ISAAC, sc::driver::Buffer(asum, false), (sc::int_t)offAsum);\
+        execute(sc::assign(s, sum(abs(x))), s.context(), numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
         return clblasSuccess;\
     }
 
-    MAKE_ASUM(S, is::FLOAT_TYPE, cl_float)
-    MAKE_ASUM(D, is::DOUBLE_TYPE, cl_double)
+    MAKE_ASUM(S, sc::FLOAT_TYPE, cl_float)
+    MAKE_ASUM(D, sc::DOUBLE_TYPE, cl_double)
+
 
     //*****************
     //BLAS2
@@ -146,23 +147,23 @@ extern "C"
             std::swap(M, N);\
             transA = (transA==clblasTrans)?clblasNoTrans:clblasTrans;\
         }\
-        is::array A((is::int_t)M, (is::int_t)N, TYPE_ISAAC, is::driver::Buffer(mA, false), (is::int_t)offA, (is::int_t)lda);\
+        sc::array A((sc::int_t)M, (sc::int_t)N, TYPE_ISAAC, sc::driver::Buffer(mA, false), (sc::int_t)offA, (sc::int_t)lda);\
         \
-        is::int_t sx = (is::int_t)N, sy = (is::int_t)M;\
+        sc::int_t sx = (sc::int_t)N, sy = (sc::int_t)M;\
         if(transA) std::swap(sx, sy);\
-        is::array x(sx, TYPE_ISAAC, is::driver::Buffer(mx, false), (is::int_t)offx, incx);\
-        is::array y(sy, TYPE_ISAAC, is::driver::Buffer(my, false), (is::int_t)offy, incy);\
+        sc::array x(sx, TYPE_ISAAC, sc::driver::Buffer(mx, false), (sc::int_t)offx, incx);\
+        sc::array y(sy, TYPE_ISAAC, sc::driver::Buffer(my, false), (sc::int_t)offy, incy);\
         \
-        is::driver::Context const & context = A.context();\
+        sc::driver::Context const & context = A.context();\
         if(transA==clblasTrans)\
-            execute(is::assign(y, alpha*dot(A.T(), x) + beta*y), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
+            execute(sc::assign(y, alpha*dot(A.T(), x) + beta*y), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
         else\
-            execute(is::assign(y, alpha*dot(A, x) + beta*y), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
+            execute(sc::assign(y, alpha*dot(A, x) + beta*y), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
         return clblasSuccess;\
     }
 
-    MAKE_GEMV(S, is::FLOAT_TYPE, cl_float)
-    MAKE_GEMV(D, is::DOUBLE_TYPE, cl_double)
+    MAKE_GEMV(S, sc::FLOAT_TYPE, cl_float)
+    MAKE_GEMV(D, sc::DOUBLE_TYPE, cl_double)
 
     //*****************
     //BLAS3
@@ -186,29 +187,29 @@ extern "C"
             std::swap(M, N);\
             std::swap(transA, transB);\
         }\
-        is::int_t As1 = (is::int_t)M, As2 = (is::int_t)K;\
-        is::int_t Bs1 = (is::int_t)K, Bs2 = (is::int_t)N;\
+        sc::int_t As1 = (sc::int_t)M, As2 = (sc::int_t)K;\
+        sc::int_t Bs1 = (sc::int_t)K, Bs2 = (sc::int_t)N;\
         if(transA==clblasTrans) std::swap(As1, As2);\
         if(transB==clblasTrans) std::swap(Bs1, Bs2);\
         /*Struct*/\
-        is::array A(As1, As2, TYPE_ISAAC, is::driver::Buffer(mA, false), (is::int_t)offA, (is::int_t)lda);\
-        is::array B(Bs1, Bs2, TYPE_ISAAC, is::driver::Buffer(mB, false), (is::int_t)offB, (is::int_t)ldb);\
-        is::array C((is::int_t)M, (is::int_t)N, TYPE_ISAAC, is::driver::Buffer(mC, false), (is::int_t)offC, (is::int_t)ldc);\
-        is::driver::Context const & context = C.context();\
+        sc::array A(As1, As2, TYPE_ISAAC, sc::driver::Buffer(mA, false), (sc::int_t)offA, (sc::int_t)lda);\
+        sc::array B(Bs1, Bs2, TYPE_ISAAC, sc::driver::Buffer(mB, false), (sc::int_t)offB, (sc::int_t)ldb);\
+        sc::array C((sc::int_t)M, (sc::int_t)N, TYPE_ISAAC, sc::driver::Buffer(mC, false), (sc::int_t)offC, (sc::int_t)ldc);\
+        sc::driver::Context const & context = C.context();\
         /*Operation*/\
         if((transA==clblasTrans) && (transB==clblasTrans))\
-            execute(is::assign(C, alpha*dot(A.T(), B.T()) + beta*C), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
+            execute(sc::assign(C, alpha*dot(A.T(), B.T()) + beta*C), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
         else if((transA==clblasTrans) && (transB==clblasNoTrans))\
-            execute(is::assign(C, alpha*dot(A.T(), B) + beta*C), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
+            execute(sc::assign(C, alpha*dot(A.T(), B) + beta*C), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
         else if((transA==clblasNoTrans) && (transB==clblasTrans))\
-            execute(is::assign(C, alpha*dot(A, B.T()) + beta*C), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
+            execute(sc::assign(C, alpha*dot(A, B.T()) + beta*C), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
         else\
-            execute(is::assign(C, alpha*dot(A, B) + beta*C), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
+            execute(sc::assign(C, alpha*dot(A, B) + beta*C), context, numCommandQueues, commandQueues, numEventsInWaitList, eventWaitList, events);\
         return clblasSuccess;\
     }
 
-    MAKE_GEMM(S, is::FLOAT_TYPE, cl_float)
-    MAKE_GEMM(D, is::DOUBLE_TYPE, cl_double)
+    MAKE_GEMM(S, sc::FLOAT_TYPE, cl_float)
+    MAKE_GEMM(D, sc::DOUBLE_TYPE, cl_double)
 
 #undef DOT
 
diff --git a/python/setup.py b/python/setup.py
index a3d1628ce..a3fceffb7 100644
--- a/python/setup.py
+++ b/python/setup.py
@@ -73,7 +73,7 @@ def main():
       libraries += ['gnustl_shared']
 
     #Source files
-    src =  'src/lib/symbolic/preset.cpp src/lib/symbolic/execute.cpp src/lib/symbolic/io.cpp src/lib/symbolic/expression.cpp src/lib/array.cpp src/lib/value_scalar.cpp src/lib/driver/backend.cpp src/lib/driver/device.cpp src/lib/driver/kernel.cpp src/lib/driver/buffer.cpp src/lib/driver/platform.cpp src/lib/driver/check.cpp src/lib/driver/program.cpp src/lib/driver/command_queue.cpp src/lib/driver/dispatch.cpp src/lib/driver/program_cache.cpp src/lib/driver/context.cpp src/lib/driver/event.cpp src/lib/driver/ndrange.cpp src/lib/driver/handle.cpp src/lib/exception/unknown_datatype.cpp src/lib/exception/operation_not_supported.cpp src/lib/profiles/presets.cpp src/lib/profiles/profiles.cpp src/lib/profiles/predictors/random_forest.cpp src/lib/kernels/templates/gemv.cpp src/lib/kernels/templates/axpy.cpp src/lib/kernels/templates/gemm.cpp src/lib/kernels/templates/ger.cpp src/lib/kernels/templates/dot.cpp src/lib/kernels/templates/base.cpp src/lib/kernels/mapped_object.cpp src/lib/kernels/stream.cpp src/lib/kernels/parse.cpp src/lib/kernels/keywords.cpp src/lib/kernels/binder.cpp src/lib/wrap/clBLAS.cpp '.split() + [os.path.join('src', 'bind', sf)  for sf in ['_isaac.cpp', 'core.cpp', 'driver.cpp', 'kernels.cpp', 'exceptions.cpp']]
+    src =  'src/lib/value_scalar.cpp src/lib/wrap/clBLAS.cpp src/lib/profiles/predictors/random_forest.cpp src/lib/profiles/profiles.cpp src/lib/profiles/presets.cpp src/lib/exception/unknown_datatype.cpp src/lib/exception/operation_not_supported.cpp src/lib/driver/handle.cpp src/lib/driver/dispatch.cpp src/lib/driver/event.cpp src/lib/driver/ndrange.cpp src/lib/driver/program_cache.cpp src/lib/driver/command_queue.cpp src/lib/driver/buffer.cpp src/lib/driver/backend.cpp src/lib/driver/platform.cpp src/lib/driver/program.cpp src/lib/driver/kernel.cpp src/lib/driver/device.cpp src/lib/driver/check.cpp src/lib/driver/context.cpp src/lib/symbolic/preset.cpp src/lib/symbolic/execute.cpp src/lib/symbolic/expression.cpp src/lib/symbolic/io.cpp src/lib/array.cpp src/lib/kernels/parse.cpp src/lib/kernels/templates/ger.cpp src/lib/kernels/templates/axpy.cpp src/lib/kernels/templates/gemm.cpp src/lib/kernels/templates/base.cpp src/lib/kernels/templates/gemv.cpp src/lib/kernels/templates/dot.cpp src/lib/kernels/binder.cpp src/lib/kernels/keywords.cpp src/lib/kernels/mapped_object.cpp src/lib/kernels/stream.cpp '.split() + [os.path.join('src', 'bind', sf)  for sf in ['_isaac.cpp', 'core.cpp', 'driver.cpp', 'kernels.cpp', 'exceptions.cpp']]
     boostsrc = 'external/boost/libs/'
     for s in ['numpy','python','smart_ptr','system','thread']:
         src = src + [x for x in recursive_glob('external/boost/libs/' + s + '/src/','.cpp') if 'win32' not in x and 'pthread' not in x]
diff --git a/python/src/bind/core.cpp b/python/src/bind/core.cpp
index 4519baf02..33e53bb77 100644
--- a/python/src/bind/core.cpp
+++ b/python/src/bind/core.cpp
@@ -276,11 +276,11 @@ void export_core()
   .def(bp::self OP bp::self)\
   ADD_SCALAR_HANDLING(OP)
 
-  bp::class_<sc::expressions_tuple>
-      ("array_expression_container", bp::init<sc::array_expression const &>())
+  bp::class_<sc::math_expression>
+      ("math_expression_container", bp::init<sc::math_expression const &>())
   ;
 
-  bp::class_<sc::array_expression >("array_expression", bp::no_init)
+  bp::class_<sc::math_expression >("math_expression", bp::no_init)
       ADD_ARRAY_OPERATOR(+)
       ADD_ARRAY_OPERATOR(-)
       ADD_ARRAY_OPERATOR(*)
@@ -291,7 +291,7 @@ void export_core()
       ADD_ARRAY_OPERATOR(<=)
       ADD_ARRAY_OPERATOR(==)
       ADD_ARRAY_OPERATOR(!=)
-      .add_property("context", bp::make_function(&sc::array_expression::context, bp::return_internal_reference<>()))
+      .add_property("context", bp::make_function(&sc::math_expression::context, bp::return_internal_reference<>()))
       .def(bp::self_ns::abs(bp::self))
 //      .def(bp::self_ns::pow(bp::self))
   ;
@@ -299,15 +299,15 @@ void export_core()
 
 #define ADD_ARRAY_OPERATOR(OP) \
   .def(bp::self                            OP bp::self)\
-  .def(bp::self                            OP bp::other<sc::array_expression>())\
-  .def(bp::other<sc::array_expression>() OP bp::self) \
+  .def(bp::self                            OP bp::other<sc::math_expression>())\
+  .def(bp::other<sc::math_expression>() OP bp::self) \
   ADD_SCALAR_HANDLING(OP)
 
   bp::class_<sc::array,
           std::shared_ptr<sc::array> >
   ( "array", bp::no_init)
       .def("__init__", bp::make_constructor(detail::create_array, bp::default_call_policies(), (bp::arg("obj"), bp::arg("dtype") = bp::scope().attr("float32"), bp::arg("context")= bp::object())))
-      .def(bp::init<sc::array_expression>())
+      .def(bp::init<sc::math_expression>())
       .add_property("dtype", &sc::array::dtype)
       .add_property("context", bp::make_function(&sc::array::context, bp::return_internal_reference<>()))
       .add_property("T", &sc::array::T)
@@ -336,15 +336,15 @@ void export_core()
   bp::def("empty", &detail::create_empty_array, (bp::arg("shape"), bp::arg("dtype") = bp::scope().attr("float32"), bp::arg("context")=bp::object()));
 
 //Assign
-    bp::def("assign", static_cast<sc::array_expression (*)(sc::array const &, sc::array const &)>(&sc::assign));\
-    bp::def("assign", static_cast<sc::array_expression (*)(sc::array const &, sc::array_expression const &)>(&sc::assign));\
+    bp::def("assign", static_cast<sc::math_expression (*)(sc::array const &, sc::array const &)>(&sc::assign));\
+    bp::def("assign", static_cast<sc::math_expression (*)(sc::array const &, sc::math_expression const &)>(&sc::assign));\
 
 //Binary
 #define MAP_FUNCTION(name) \
-      bp::def(#name, static_cast<sc::array_expression (*)(sc::array const &, sc::array const &)>(&sc::name));\
-      bp::def(#name, static_cast<sc::array_expression (*)(sc::array_expression const &, sc::array const &)>(&sc::name));\
-      bp::def(#name, static_cast<sc::array_expression (*)(sc::array const &, sc::array_expression const &)>(&sc::name));\
-      bp::def(#name, static_cast<sc::array_expression (*)(sc::array_expression const &, sc::array_expression const &)>(&sc::name));
+      bp::def(#name, static_cast<sc::math_expression (*)(sc::array const &, sc::array const &)>(&sc::name));\
+      bp::def(#name, static_cast<sc::math_expression (*)(sc::math_expression const &, sc::array const &)>(&sc::name));\
+      bp::def(#name, static_cast<sc::math_expression (*)(sc::array const &, sc::math_expression const &)>(&sc::name));\
+      bp::def(#name, static_cast<sc::math_expression (*)(sc::math_expression const &, sc::math_expression const &)>(&sc::name));
 
   MAP_FUNCTION(maximum)
   MAP_FUNCTION(minimum)
@@ -354,8 +354,8 @@ void export_core()
 
 //Unary
 #define MAP_FUNCTION(name) \
-      bp::def(#name, static_cast<sc::array_expression (*)(sc::array const &)>(&sc::name));\
-      bp::def(#name, static_cast<sc::array_expression (*)(sc::array_expression const &)>(&sc::name));
+      bp::def(#name, static_cast<sc::math_expression (*)(sc::array const &)>(&sc::name));\
+      bp::def(#name, static_cast<sc::math_expression (*)(sc::math_expression const &)>(&sc::name));
 
       bp::def("zeros", &detail::create_zeros_array, (bp::arg("shape"), bp::arg("dtype") = bp::scope().attr("float32"), bp::arg("context")=bp::object()));
 
@@ -380,8 +380,8 @@ void export_core()
   /*--- Reduction operators----*/
   //---------------------------------------
 #define MAP_FUNCTION(name) \
-      bp::def(#name, static_cast<sc::array_expression (*)(sc::array const &, sc::int_t)>(&sc::name));\
-      bp::def(#name, static_cast<sc::array_expression (*)(sc::array_expression const &, sc::int_t)>(&sc::name));
+      bp::def(#name, static_cast<sc::math_expression (*)(sc::array const &, sc::int_t)>(&sc::name));\
+      bp::def(#name, static_cast<sc::math_expression (*)(sc::math_expression const &, sc::int_t)>(&sc::name));
 
   MAP_FUNCTION(sum)
   MAP_FUNCTION(max)
diff --git a/python/src/bind/driver.cpp b/python/src/bind/driver.cpp
index d4b86cc76..a3331a96f 100644
--- a/python/src/bind/driver.cpp
+++ b/python/src/bind/driver.cpp
@@ -62,7 +62,7 @@ namespace detail
   std::shared_ptr<sc::driver::Context> make_context(sc::driver::Device const & dev)
   { return std::shared_ptr<sc::driver::Context>(new sc::driver::Context(dev)); }
 
-  bp::object enqueue(sc::array_expression const & expression, unsigned int queue_id, bp::list dependencies, bool tune, int label, std::string const & program_name, bool force_recompile)
+  bp::object enqueue(sc::math_expression const & expression, unsigned int queue_id, bp::list dependencies, bool tune, int label, std::string const & program_name, bool force_recompile)
   {
       std::list<sc::driver::Event> events;
       std::vector<sc::driver::Event> cdependencies = tools::to_vector<sc::driver::Event>(dependencies);
@@ -70,15 +70,15 @@ namespace detail
       sc::execution_options_type execution_options(queue_id, &events, &cdependencies);
       sc::dispatcher_options_type dispatcher_options(tune, label);
       sc::compilation_options_type compilation_options(program_name, force_recompile);
-      sc::array_expression::container_type::value_type root = expression.tree()[expression.root()];
+      sc::math_expression::container_type::value_type root = expression.tree()[expression.root()];
       if(sc::detail::is_assignment(root.op))
       {
-          sc::execute(sc::control(expression, execution_options, dispatcher_options, compilation_options), isaac::profiles::get(execution_options.queue(expression.context())));
+          sc::execute(sc::execution_handler(expression, execution_options, dispatcher_options, compilation_options), isaac::profiles::get(execution_options.queue(expression.context())));
           return bp::make_tuple(bp::ptr(root.lhs.array), tools::to_list(events.begin(), events.end()));
       }
       else
       {
-          std::shared_ptr<sc::array> parray(new sc::array(sc::control(expression, execution_options, dispatcher_options, compilation_options)));
+          std::shared_ptr<sc::array> parray(new sc::array(sc::execution_handler(expression, execution_options, dispatcher_options, compilation_options)));
           return bp::make_tuple(parray, tools::to_list(events.begin(), events.end()));
       }
   }
diff --git a/python/src/bind/kernels.cpp b/python/src/bind/kernels.cpp
index 2358da8dd..dbef9378c 100644
--- a/python/src/bind/kernels.cpp
+++ b/python/src/bind/kernels.cpp
@@ -13,7 +13,7 @@ namespace tpt = isaac::templates;
 
 namespace detail
 {
-  bp::list input_sizes(tpt::base & temp, sc::expressions_tuple const & tree)
+  bp::list input_sizes(tpt::base & temp, sc::math_expression const & tree)
   {
       std::vector<isaac::int_t> tmp = temp.input_sizes(tree);
       return tools::to_list(tmp.begin(), tmp.end());
diff --git a/tests/linalg/CMakeLists.txt b/tests/linalg/CMakeLists.txt
index 5c3bee289..5e582bb83 100644
--- a/tests/linalg/CMakeLists.txt
+++ b/tests/linalg/CMakeLists.txt
@@ -1,5 +1,13 @@
-foreach(PROG axpy dot ger gemv gemm)
-     add_executable(${PROG}-test ${PROG}.cpp)
-     add_test(${PROG} ${PROG}-test)
-     target_link_libraries(${PROG}-test isaac)
-endforeach(PROG)
+set(_CLAPACK_SRC slasr xerbla lsame)
+set(CLAPACK_SRC "")
+foreach(FNAME ${_CLAPACK_SRC})
+    list(APPEND CLAPACK_SRC "${CMAKE_CURRENT_SOURCE_DIR}/external/${FNAME}.c")
+endforeach()
+
+add_library(lapack-subset SHARED ${CLAPACK_SRC})
+
+foreach(PROG axpy dot ger gemv gemm gesvd)
+     add_executable(${PROG} ${PROG}.cpp)
+     add_test(${PROG}-test ${PROG})
+     target_link_libraries(${PROG} isaac lapack-subset)
+endforeach()
diff --git a/tests/linalg/axpy.cpp b/tests/linalg/axpy.cpp
index ffe70c9cd..972a69b2c 100644
--- a/tests/linalg/axpy.cpp
+++ b/tests/linalg/axpy.cpp
@@ -9,7 +9,7 @@ namespace sc = isaac;
 typedef isaac::int_t int_t;
 
 template<typename T>
-void test_element_wise_vector(T epsilon, simple_vector_base<T> & cx, simple_vector_base<T>& cy, simple_vector_base<T>& cz,
+void test_impl(T epsilon, simple_vector_base<T> & cx, simple_vector_base<T>& cy, simple_vector_base<T>& cz,
                                                  sc::array& x, sc::array& y, sc::array& z, interface_t interf)
 {
   using namespace std;
@@ -27,7 +27,7 @@ void test_element_wise_vector(T epsilon, simple_vector_base<T> & cx, simple_vect
 
   simple_vector<T> buffer(N);
 #define CONVERT
-#define RUN_TEST_VECTOR_AXPY(NAME, CPU_LOOP, GPU_EXPR) \
+#define RUN_TEST(NAME, CPU_LOOP, GPU_EXPR) \
   {\
   std::cout << NAME "..." << std::flush;\
   for(int_t i = 0 ; i < N ; ++i)\
@@ -50,64 +50,64 @@ void test_element_wise_vector(T epsilon, simple_vector_base<T> & cx, simple_vect
   {
       cl_command_queue clqueue = queue.handle().cl();
 
-      RUN_TEST_VECTOR_AXPY("AXPY", cz[i] = a*cx[i] + cz[i], BLAS<T>::F(clblasSaxpy, clblasDaxpy)(N, a, CHANDLE(x), x.start()[0], x.stride()[0],
+      RUN_TEST("AXPY", cz[i] = a*cx[i] + cz[i], BLAS<T>::F(clblasSaxpy, clblasDaxpy)(N, a, CHANDLE(x), x.start()[0], x.stride()[0],
                                                                                                  CHANDLE(z), z.start()[0], z.stride()[0],
                                                                                                  1, &clqueue, 0, NULL, NULL));
 
-      RUN_TEST_VECTOR_AXPY("COPY", cz[i] = cx[i], BLAS<T>::F(clblasScopy, clblasDcopy)(N, CHANDLE(x), x.start()[0], x.stride()[0],
+      RUN_TEST("COPY", cz[i] = cx[i], BLAS<T>::F(clblasScopy, clblasDcopy)(N, CHANDLE(x), x.start()[0], x.stride()[0],
                                                                                      CHANDLE(z), z.start()[0], z.stride()[0],
                                                                                      1, &clqueue, 0, NULL, NULL));
 
-      RUN_TEST_VECTOR_AXPY("SCAL", cz[i] = a*cz[i], BLAS<T>::F(clblasSscal, clblasDscal)(N, a, CHANDLE(z), z.start()[0], z.stride()[0],
+      RUN_TEST("SCAL", cz[i] = a*cz[i], BLAS<T>::F(clblasSscal, clblasDscal)(N, a, CHANDLE(z), z.start()[0], z.stride()[0],
                                                                                          1, &clqueue, 0, NULL, NULL));
   }
 
-  RUN_TEST_VECTOR_AXPY("z = 0", cz[i] = 0, z = zeros(N, 1, dtype, context))
-  RUN_TEST_VECTOR_AXPY("z = x", cz[i] = cx[i], z = x)
-  RUN_TEST_VECTOR_AXPY("z = -x", cz[i] = -cx[i], z = -x)
+  RUN_TEST("z = 0", cz[i] = 0, z = zeros(N, 1, dtype, context))
+  RUN_TEST("z = x", cz[i] = cx[i], z = x)
+  RUN_TEST("z = -x", cz[i] = -cx[i], z = -x)
 
-  RUN_TEST_VECTOR_AXPY("z = x + y", cz[i] = cx[i] + cy[i], z = x + y)
-  RUN_TEST_VECTOR_AXPY("z = x - y", cz[i] = cx[i] - cy[i], z = x - y)
-  RUN_TEST_VECTOR_AXPY("z = x + y + z", cz[i] = cx[i] + cy[i] + cz[i], z = x + y + z)
+  RUN_TEST("z = x + y", cz[i] = cx[i] + cy[i], z = x + y)
+  RUN_TEST("z = x - y", cz[i] = cx[i] - cy[i], z = x - y)
+  RUN_TEST("z = x + y + z", cz[i] = cx[i] + cy[i] + cz[i], z = x + y + z)
 
-  RUN_TEST_VECTOR_AXPY("z = a*x", cz[i] = aa*cx[i], z = a*x)
-  RUN_TEST_VECTOR_AXPY("z = da*x", cz[i] = aa*cx[i], z = da*x)
-  RUN_TEST_VECTOR_AXPY("z = a*x + b*y", cz[i] = aa*cx[i] + bb*cy[i], z= a*x + b*y)
-  RUN_TEST_VECTOR_AXPY("z = da*x + b*y", cz[i] = aa*cx[i] + bb*cy[i], z= da*x + b*y)
-  RUN_TEST_VECTOR_AXPY("z = a*x + db*y", cz[i] = aa*cx[i] + bb*cy[i], z= a*x + db*y)
-  RUN_TEST_VECTOR_AXPY("z = da*x + db*y", cz[i] = aa*cx[i] + bb*cy[i], z= da*x + db*y)
+  RUN_TEST("z = a*x", cz[i] = aa*cx[i], z = a*x)
+  RUN_TEST("z = da*x", cz[i] = aa*cx[i], z = da*x)
+  RUN_TEST("z = a*x + b*y", cz[i] = aa*cx[i] + bb*cy[i], z= a*x + b*y)
+  RUN_TEST("z = da*x + b*y", cz[i] = aa*cx[i] + bb*cy[i], z= da*x + b*y)
+  RUN_TEST("z = a*x + db*y", cz[i] = aa*cx[i] + bb*cy[i], z= a*x + db*y)
+  RUN_TEST("z = da*x + db*y", cz[i] = aa*cx[i] + bb*cy[i], z= da*x + db*y)
 
-  RUN_TEST_VECTOR_AXPY("z = exp(x)", cz[i] = exp(cx[i]), z= exp(x))
-  RUN_TEST_VECTOR_AXPY("z = abs(x)", cz[i] = abs(cx[i]), z= abs(x))
-  RUN_TEST_VECTOR_AXPY("z = acos(x)", cz[i] = acos(cx[i]), z= acos(x))
-  RUN_TEST_VECTOR_AXPY("z = asin(x)", cz[i] = asin(cx[i]), z= asin(x))
-  RUN_TEST_VECTOR_AXPY("z = atan(x)", cz[i] = atan(cx[i]), z= atan(x))
-  RUN_TEST_VECTOR_AXPY("z = ceil(x)", cz[i] = ceil(cx[i]), z= ceil(x))
-  RUN_TEST_VECTOR_AXPY("z = cos(x)", cz[i] = cos(cx[i]), z= cos(x))
-  RUN_TEST_VECTOR_AXPY("z = cosh(x)", cz[i] = cosh(cx[i]), z= cosh(x))
-  RUN_TEST_VECTOR_AXPY("z = floor(x)", cz[i] = floor(cx[i]), z= floor(x))
-  RUN_TEST_VECTOR_AXPY("z = log(x)", cz[i] = log(cx[i]), z= log(x))
-  RUN_TEST_VECTOR_AXPY("z = log10(x)", cz[i] = log10(cx[i]), z= log10(x))
-  RUN_TEST_VECTOR_AXPY("z = sin(x)", cz[i] = sin(cx[i]), z= sin(x))
-  RUN_TEST_VECTOR_AXPY("z = sinh(x)", cz[i] = sinh(cx[i]), z= sinh(x))
-  RUN_TEST_VECTOR_AXPY("z = sqrt(x)", cz[i] = sqrt(cx[i]), z= sqrt(x))
-  RUN_TEST_VECTOR_AXPY("z = tan(x)", cz[i] = tan(cx[i]), z= tan(x))
-  RUN_TEST_VECTOR_AXPY("z = tanh(x)", cz[i] = tanh(cx[i]), z= tanh(x))
+  RUN_TEST("z = exp(x)", cz[i] = exp(cx[i]), z= exp(x))
+  RUN_TEST("z = abs(x)", cz[i] = abs(cx[i]), z= abs(x))
+  RUN_TEST("z = acos(x)", cz[i] = acos(cx[i]), z= acos(x))
+  RUN_TEST("z = asin(x)", cz[i] = asin(cx[i]), z= asin(x))
+  RUN_TEST("z = atan(x)", cz[i] = atan(cx[i]), z= atan(x))
+  RUN_TEST("z = ceil(x)", cz[i] = ceil(cx[i]), z= ceil(x))
+  RUN_TEST("z = cos(x)", cz[i] = cos(cx[i]), z= cos(x))
+  RUN_TEST("z = cosh(x)", cz[i] = cosh(cx[i]), z= cosh(x))
+  RUN_TEST("z = floor(x)", cz[i] = floor(cx[i]), z= floor(x))
+  RUN_TEST("z = log(x)", cz[i] = log(cx[i]), z= log(x))
+  RUN_TEST("z = log10(x)", cz[i] = log10(cx[i]), z= log10(x))
+  RUN_TEST("z = sin(x)", cz[i] = sin(cx[i]), z= sin(x))
+  RUN_TEST("z = sinh(x)", cz[i] = sinh(cx[i]), z= sinh(x))
+  RUN_TEST("z = sqrt(x)", cz[i] = sqrt(cx[i]), z= sqrt(x))
+  RUN_TEST("z = tan(x)", cz[i] = tan(cx[i]), z= tan(x))
+  RUN_TEST("z = tanh(x)", cz[i] = tanh(cx[i]), z= tanh(x))
 
-  RUN_TEST_VECTOR_AXPY("z = x.*y", cz[i] = cx[i]*cy[i], z= x*y)
-  RUN_TEST_VECTOR_AXPY("z = x./y", cz[i] = cx[i]/cy[i], z= x/y)
+  RUN_TEST("z = x.*y", cz[i] = cx[i]*cy[i], z= x*y)
+  RUN_TEST("z = x./y", cz[i] = cx[i]/cy[i], z= x/y)
 
-  RUN_TEST_VECTOR_AXPY("z = pow(x,y)", cz[i] = pow(cx[i], cy[i]), z= pow(x,y))
+  RUN_TEST("z = pow(x,y)", cz[i] = pow(cx[i], cy[i]), z= pow(x,y))
 
 #undef CONVERT
 #define CONVERT for(int_t i = 0 ; i < N ; ++i) {cz[i] = !!cz[i] ; buffer[i] = !!buffer[i];}
-  RUN_TEST_VECTOR_AXPY("z = x==y", cz[i] = cx[i]==cy[i], z= cast(x==y, dtype))
-  RUN_TEST_VECTOR_AXPY("z = x>=y", cz[i] = cx[i]>=cy[i], z= cast(x>=y, dtype))
-  RUN_TEST_VECTOR_AXPY("z = x>y", cz[i] = cx[i]>cy[i], z= cast(x>y, dtype))
-  RUN_TEST_VECTOR_AXPY("z = x<=y", cz[i] = cx[i]<=cy[i], z= cast(x<=y, dtype))
-  RUN_TEST_VECTOR_AXPY("z = x<y", cz[i] = cx[i]<cy[i], z= cast(x<y, dtype))
-  RUN_TEST_VECTOR_AXPY("z = x!=y", cz[i] = cx[i]!=cy[i], z= cast(x!=y, dtype))
-#undef RUN_TEST_VECTOR_AXPY
+  RUN_TEST("z = x==y", cz[i] = cx[i]==cy[i], z= cast(x==y, dtype))
+  RUN_TEST("z = x>=y", cz[i] = cx[i]>=cy[i], z= cast(x>=y, dtype))
+  RUN_TEST("z = x>y", cz[i] = cx[i]>cy[i], z= cast(x>y, dtype))
+  RUN_TEST("z = x<=y", cz[i] = cx[i]<=cy[i], z= cast(x<=y, dtype))
+  RUN_TEST("z = x<y", cz[i] = cx[i]<cy[i], z= cast(x<y, dtype))
+  RUN_TEST("z = x!=y", cz[i] = cx[i]!=cy[i], z= cast(x!=y, dtype))
+#undef RUN_TEST
 
 
   if(failure_count > 0)
@@ -115,12 +115,12 @@ void test_element_wise_vector(T epsilon, simple_vector_base<T> & cx, simple_vect
 }
 
 template<typename T>
-void test_impl(T epsilon, sc::driver::Context const & ctx)
+void test(T epsilon, sc::driver::Context const & ctx)
 {
   using isaac::_;
 
-    int_t N = 10007;
-    int_t SUBN = 7;
+  int_t N = 10007;
+  int_t SUBN = 7;
 
 
   INIT_VECTOR(N, SUBN, 5, 3, cx, x, ctx);
@@ -129,7 +129,7 @@ void test_impl(T epsilon, sc::driver::Context const & ctx)
 
 
 #define TEST_OPERATIONS(TYPE, INTERF)\
-  test_element_wise_vector(epsilon, cx_ ## TYPE, cy_ ## TYPE, cz_ ## TYPE,\
+  test_impl(epsilon, cx_ ## TYPE, cy_ ## TYPE, cz_ ## TYPE,\
                                     x_ ## TYPE, y_ ## TYPE, z_ ## TYPE, INTERF);\
 
   std::cout << "> standard..." << std::endl;
@@ -153,11 +153,11 @@ int main()
     std::cout << "Device: " << device.name() << " on " << device.platform().name() << " " << device.platform().version() << std::endl;
     std::cout << "---" << std::endl;
     std::cout << ">> float" << std::endl;
-    test_impl<float>(eps_float, *context);
+    test<float>(eps_float, *context);
     if(device.fp64_support())
     {
         std::cout << ">> double" << std::endl;
-        test_impl<double>(eps_double, *context);
+        test<double>(eps_double, *context);
     }
     std::cout << "---" << std::endl;
   }
diff --git a/tests/linalg/dot.cpp b/tests/linalg/dot.cpp
index 40eb1f015..3f8a7b3da 100644
--- a/tests/linalg/dot.cpp
+++ b/tests/linalg/dot.cpp
@@ -9,7 +9,7 @@ namespace sc = isaac;
 typedef sc::int_t int_t;
 
 template<typename T>
-void test_reduction(T epsilon,  simple_vector_base<T> & cx, simple_vector_base<T> & cy,
+void test_impl(T epsilon,  simple_vector_base<T> & cx, simple_vector_base<T> & cy,
                                 sc::array & x, sc::array & y, interface_t interf)
 {
   using namespace std;
@@ -70,7 +70,7 @@ void test_reduction(T epsilon,  simple_vector_base<T> & cx, simple_vector_base<T
 }
 
 template<typename T>
-void test_impl(T epsilon, sc::driver::Context const & ctx)
+void test(T epsilon, sc::driver::Context const & ctx)
 {
   using isaac::_;
 
@@ -81,7 +81,7 @@ void test_impl(T epsilon, sc::driver::Context const & ctx)
   INIT_VECTOR(N, SUBN, 0, 1, cy, y, ctx);
 
 #define TEST_OPERATIONS(TYPE, ITF)\
-  test_reduction(epsilon, cx_ ## TYPE, cy_ ## TYPE,\
+  test_impl(epsilon, cx_ ## TYPE, cy_ ## TYPE,\
                                     x_ ## TYPE, y_ ## TYPE, ITF);\
 
   std::cout << "> standard..." << std::endl;
@@ -104,11 +104,11 @@ int main()
     std::cout << "Device: " << device.name() << " on " << device.platform().name() << " " << device.platform().version() << std::endl;
     std::cout << "---" << std::endl;
     std::cout << ">> float" << std::endl;
-    test_impl<float>(eps_float, *context);
+    test<float>(eps_float, *context);
     if(device.fp64_support())
     {
         std::cout << ">> double" << std::endl;
-        test_impl<double>(eps_double, *context);
+        test<double>(eps_double, *context);
     }
     std::cout << "---" << std::endl;
   }
diff --git a/tests/linalg/external/clapack.h b/tests/linalg/external/clapack.h
new file mode 100644
index 000000000..4b28d3c14
--- /dev/null
+++ b/tests/linalg/external/clapack.h
@@ -0,0 +1,7262 @@
+/* header file for clapack 3.2.1 */
+
+#ifndef __CLAPACK_H
+#define __CLAPACK_H
+
+#ifdef __cplusplus 	
+extern "C" {	
+#endif		
+
+/* Subroutine */ int caxpy_(integer *n, complex *ca, complex *cx, integer *
+	incx, complex *cy, integer *incy);
+
+/* Subroutine */ int ccopy_(integer *n, complex *cx, integer *incx, complex *
+	cy, integer *incy);
+
+/* Complex */ VOID cdotc_(complex * ret_val, integer *n, complex *cx, integer 
+	*incx, complex *cy, integer *incy);
+
+/* Complex */ VOID cdotu_(complex * ret_val, integer *n, complex *cx, integer 
+	*incx, complex *cy, integer *incy);
+
+/* Subroutine */ int cgbmv_(char *trans, integer *m, integer *n, integer *kl, 
+	integer *ku, complex *alpha, complex *a, integer *lda, complex *x, 
+	integer *incx, complex *beta, complex *y, integer *incy);
+
+/* Subroutine */ int cgemm_(char *transa, char *transb, integer *m, integer *
+	n, integer *k, complex *alpha, complex *a, integer *lda, complex *b, 
+	integer *ldb, complex *beta, complex *c__, integer *ldc);
+
+/* Subroutine */ int cgemv_(char *trans, integer *m, integer *n, complex *
+	alpha, complex *a, integer *lda, complex *x, integer *incx, complex *
+	beta, complex *y, integer *incy);
+
+/* Subroutine */ int cgerc_(integer *m, integer *n, complex *alpha, complex *
+	x, integer *incx, complex *y, integer *incy, complex *a, integer *lda);
+
+/* Subroutine */ int cgeru_(integer *m, integer *n, complex *alpha, complex *
+	x, integer *incx, complex *y, integer *incy, complex *a, integer *lda);
+
+/* Subroutine */ int chbmv_(char *uplo, integer *n, integer *k, complex *
+	alpha, complex *a, integer *lda, complex *x, integer *incx, complex *
+	beta, complex *y, integer *incy);
+
+/* Subroutine */ int chemm_(char *side, char *uplo, integer *m, integer *n, 
+	complex *alpha, complex *a, integer *lda, complex *b, integer *ldb, 
+	complex *beta, complex *c__, integer *ldc);
+
+/* Subroutine */ int chemv_(char *uplo, integer *n, complex *alpha, complex *
+	a, integer *lda, complex *x, integer *incx, complex *beta, complex *y, 
+	 integer *incy);
+
+/* Subroutine */ int cher_(char *uplo, integer *n, real *alpha, complex *x, 
+	integer *incx, complex *a, integer *lda);
+
+/* Subroutine */ int cher2_(char *uplo, integer *n, complex *alpha, complex *
+	x, integer *incx, complex *y, integer *incy, complex *a, integer *lda);
+
+/* Subroutine */ int cher2k_(char *uplo, char *trans, integer *n, integer *k, 
+	complex *alpha, complex *a, integer *lda, complex *b, integer *ldb, 
+	real *beta, complex *c__, integer *ldc);
+
+/* Subroutine */ int cherk_(char *uplo, char *trans, integer *n, integer *k, 
+	real *alpha, complex *a, integer *lda, real *beta, complex *c__, 
+	integer *ldc);
+
+/* Subroutine */ int chpmv_(char *uplo, integer *n, complex *alpha, complex *
+	ap, complex *x, integer *incx, complex *beta, complex *y, integer *
+	incy);
+
+/* Subroutine */ int chpr_(char *uplo, integer *n, real *alpha, complex *x, 
+	integer *incx, complex *ap);
+
+/* Subroutine */ int chpr2_(char *uplo, integer *n, complex *alpha, complex *
+	x, integer *incx, complex *y, integer *incy, complex *ap);
+
+/* Subroutine */ int crotg_(complex *ca, complex *cb, real *c__, complex *s);
+
+/* Subroutine */ int cscal_(integer *n, complex *ca, complex *cx, integer *
+	incx);
+
+/* Subroutine */ int csrot_(integer *n, complex *cx, integer *incx, complex *
+	cy, integer *incy, real *c__, real *s);
+
+/* Subroutine */ int csscal_(integer *n, real *sa, complex *cx, integer *incx);
+
+/* Subroutine */ int cswap_(integer *n, complex *cx, integer *incx, complex *
+	cy, integer *incy);
+
+/* Subroutine */ int csymm_(char *side, char *uplo, integer *m, integer *n, 
+	complex *alpha, complex *a, integer *lda, complex *b, integer *ldb, 
+	complex *beta, complex *c__, integer *ldc);
+
+/* Subroutine */ int csyr2k_(char *uplo, char *trans, integer *n, integer *k, 
+	complex *alpha, complex *a, integer *lda, complex *b, integer *ldb, 
+	complex *beta, complex *c__, integer *ldc);
+
+/* Subroutine */ int csyrk_(char *uplo, char *trans, integer *n, integer *k, 
+	complex *alpha, complex *a, integer *lda, complex *beta, complex *c__, 
+	 integer *ldc);
+
+/* Subroutine */ int ctbmv_(char *uplo, char *trans, char *diag, integer *n, 
+	integer *k, complex *a, integer *lda, complex *x, integer *incx);
+
+/* Subroutine */ int ctbsv_(char *uplo, char *trans, char *diag, integer *n, 
+	integer *k, complex *a, integer *lda, complex *x, integer *incx);
+
+/* Subroutine */ int ctpmv_(char *uplo, char *trans, char *diag, integer *n, 
+	complex *ap, complex *x, integer *incx);
+
+/* Subroutine */ int ctpsv_(char *uplo, char *trans, char *diag, integer *n, 
+	complex *ap, complex *x, integer *incx);
+
+/* Subroutine */ int ctrmm_(char *side, char *uplo, char *transa, char *diag, 
+	integer *m, integer *n, complex *alpha, complex *a, integer *lda, 
+	complex *b, integer *ldb);
+
+/* Subroutine */ int ctrmv_(char *uplo, char *trans, char *diag, integer *n, 
+	complex *a, integer *lda, complex *x, integer *incx);
+
+/* Subroutine */ int ctrsm_(char *side, char *uplo, char *transa, char *diag, 
+	integer *m, integer *n, complex *alpha, complex *a, integer *lda, 
+	complex *b, integer *ldb);
+
+/* Subroutine */ int ctrsv_(char *uplo, char *trans, char *diag, integer *n, 
+	complex *a, integer *lda, complex *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, complex *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_(complex *z__);
+
+doublereal scasum_(integer *n, complex *cx, integer *incx);
+
+doublereal scnrm2_(integer *n, complex *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 Complex */ VOID zdotc_(doublecomplex * ret_val, integer *n, 
+	doublecomplex *zx, integer *incx, doublecomplex *zy, integer *incy);
+
+/* Double Complex */ 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, complex *vt, integer *ldvt, 
+	complex *u, integer *ldu, complex *c__, integer *ldc, real *rwork, 
+	integer *info);
+
+/* Subroutine */ int cgbbrd_(char *vect, integer *m, integer *n, integer *ncc, 
+	 integer *kl, integer *ku, complex *ab, integer *ldab, real *d__, 
+	real *e, complex *q, integer *ldq, complex *pt, integer *ldpt, 
+	complex *c__, integer *ldc, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgbcon_(char *norm, integer *n, integer *kl, integer *ku, 
+	 complex *ab, integer *ldab, integer *ipiv, real *anorm, real *rcond, 
+	complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgbequ_(integer *m, integer *n, integer *kl, integer *ku, 
+	 complex *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, complex *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, complex *ab, integer *ldab, complex *afb, integer *
+	ldafb, integer *ipiv, complex *b, integer *ldb, complex *x, integer *
+	ldx, real *ferr, real *berr, complex *work, real *rwork, integer *
+	info);
+
+/* Subroutine */ int cgbrfsx_(char *trans, char *equed, integer *n, integer *
+	kl, integer *ku, integer *nrhs, complex *ab, integer *ldab, complex *
+	afb, integer *ldafb, integer *ipiv, real *r__, real *c__, complex *b, 
+	integer *ldb, complex *x, integer *ldx, real *rcond, real *berr, 
+	integer *n_err_bnds__, real *err_bnds_norm__, real *err_bnds_comp__, 
+	integer *nparams, real *params, complex *work, real *rwork, integer *
+	info);
+
+/* Subroutine */ int cgbsv_(integer *n, integer *kl, integer *ku, integer *
+	nrhs, complex *ab, integer *ldab, integer *ipiv, complex *b, integer *
+	ldb, integer *info);
+
+/* Subroutine */ int cgbsvx_(char *fact, char *trans, integer *n, integer *kl, 
+	 integer *ku, integer *nrhs, complex *ab, integer *ldab, complex *afb, 
+	 integer *ldafb, integer *ipiv, char *equed, real *r__, real *c__, 
+	complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real 
+	*ferr, real *berr, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgbsvxx_(char *fact, char *trans, integer *n, integer *
+	kl, integer *ku, integer *nrhs, complex *ab, integer *ldab, complex *
+	afb, integer *ldafb, integer *ipiv, char *equed, real *r__, real *c__, 
+	 complex *b, integer *ldb, complex *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, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgbtf2_(integer *m, integer *n, integer *kl, integer *ku, 
+	 complex *ab, integer *ldab, integer *ipiv, integer *info);
+
+/* Subroutine */ int cgbtrf_(integer *m, integer *n, integer *kl, integer *ku, 
+	 complex *ab, integer *ldab, integer *ipiv, integer *info);
+
+/* Subroutine */ int cgbtrs_(char *trans, integer *n, integer *kl, integer *
+	ku, integer *nrhs, complex *ab, integer *ldab, integer *ipiv, complex 
+	*b, integer *ldb, integer *info);
+
+/* Subroutine */ int cgebak_(char *job, char *side, integer *n, integer *ilo, 
+	integer *ihi, real *scale, integer *m, complex *v, integer *ldv, 
+	integer *info);
+
+/* Subroutine */ int cgebal_(char *job, integer *n, complex *a, integer *lda, 
+	integer *ilo, integer *ihi, real *scale, integer *info);
+
+/* Subroutine */ int cgebd2_(integer *m, integer *n, complex *a, integer *lda, 
+	 real *d__, real *e, complex *tauq, complex *taup, complex *work, 
+	integer *info);
+
+/* Subroutine */ int cgebrd_(integer *m, integer *n, complex *a, integer *lda, 
+	 real *d__, real *e, complex *tauq, complex *taup, complex *work, 
+	integer *lwork, integer *info);
+
+/* Subroutine */ int cgecon_(char *norm, integer *n, complex *a, integer *lda, 
+	 real *anorm, real *rcond, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgeequ_(integer *m, integer *n, complex *a, integer *lda, 
+	 real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, 
+	integer *info);
+
+/* Subroutine */ int cgeequb_(integer *m, integer *n, complex *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, 
+	complex *a, integer *lda, integer *sdim, complex *w, complex *vs, 
+	integer *ldvs, complex *work, integer *lwork, real *rwork, logical *
+	bwork, integer *info);
+
+/* Subroutine */ int cgeesx_(char *jobvs, char *sort, L_fp select, char *
+	sense, integer *n, complex *a, integer *lda, integer *sdim, complex *
+	w, complex *vs, integer *ldvs, real *rconde, real *rcondv, complex *
+	work, integer *lwork, real *rwork, logical *bwork, integer *info);
+
+/* Subroutine */ int cgeev_(char *jobvl, char *jobvr, integer *n, complex *a, 
+	integer *lda, complex *w, complex *vl, integer *ldvl, complex *vr, 
+	integer *ldvr, complex *work, integer *lwork, real *rwork, integer *
+	info);
+
+/* Subroutine */ int cgeevx_(char *balanc, char *jobvl, char *jobvr, char *
+	sense, integer *n, complex *a, integer *lda, complex *w, complex *vl, 
+	integer *ldvl, complex *vr, integer *ldvr, integer *ilo, integer *ihi, 
+	 real *scale, real *abnrm, real *rconde, real *rcondv, complex *work, 
+	integer *lwork, real *rwork, integer *info);
+
+/* Subroutine */ int cgegs_(char *jobvsl, char *jobvsr, integer *n, complex *
+	a, integer *lda, complex *b, integer *ldb, complex *alpha, complex *
+	beta, complex *vsl, integer *ldvsl, complex *vsr, integer *ldvsr, 
+	complex *work, integer *lwork, real *rwork, integer *info);
+
+/* Subroutine */ int cgegv_(char *jobvl, char *jobvr, integer *n, complex *a, 
+	integer *lda, complex *b, integer *ldb, complex *alpha, complex *beta, 
+	 complex *vl, integer *ldvl, complex *vr, integer *ldvr, complex *
+	work, integer *lwork, real *rwork, integer *info);
+
+/* Subroutine */ int cgehd2_(integer *n, integer *ilo, integer *ihi, complex *
+	a, integer *lda, complex *tau, complex *work, integer *info);
+
+/* Subroutine */ int cgehrd_(integer *n, integer *ilo, integer *ihi, complex *
+	a, integer *lda, complex *tau, complex *work, integer *lwork, integer 
+	*info);
+
+/* Subroutine */ int cgelq2_(integer *m, integer *n, complex *a, integer *lda, 
+	 complex *tau, complex *work, integer *info);
+
+/* Subroutine */ int cgelqf_(integer *m, integer *n, complex *a, integer *lda, 
+	 complex *tau, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cgels_(char *trans, integer *m, integer *n, integer *
+	nrhs, complex *a, integer *lda, complex *b, integer *ldb, complex *
+	work, integer *lwork, integer *info);
+
+/* Subroutine */ int cgelsd_(integer *m, integer *n, integer *nrhs, complex *
+	a, integer *lda, complex *b, integer *ldb, real *s, real *rcond, 
+	integer *rank, complex *work, integer *lwork, real *rwork, integer *
+	iwork, integer *info);
+
+/* Subroutine */ int cgelss_(integer *m, integer *n, integer *nrhs, complex *
+	a, integer *lda, complex *b, integer *ldb, real *s, real *rcond, 
+	integer *rank, complex *work, integer *lwork, real *rwork, integer *
+	info);
+
+/* Subroutine */ int cgelsx_(integer *m, integer *n, integer *nrhs, complex *
+	a, integer *lda, complex *b, integer *ldb, integer *jpvt, real *rcond, 
+	 integer *rank, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgelsy_(integer *m, integer *n, integer *nrhs, complex *
+	a, integer *lda, complex *b, integer *ldb, integer *jpvt, real *rcond, 
+	 integer *rank, complex *work, integer *lwork, real *rwork, integer *
+	info);
+
+/* Subroutine */ int cgeql2_(integer *m, integer *n, complex *a, integer *lda, 
+	 complex *tau, complex *work, integer *info);
+
+/* Subroutine */ int cgeqlf_(integer *m, integer *n, complex *a, integer *lda, 
+	 complex *tau, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cgeqp3_(integer *m, integer *n, complex *a, integer *lda, 
+	 integer *jpvt, complex *tau, complex *work, integer *lwork, real *
+	rwork, integer *info);
+
+/* Subroutine */ int cgeqpf_(integer *m, integer *n, complex *a, integer *lda, 
+	 integer *jpvt, complex *tau, complex *work, real *rwork, integer *
+	info);
+
+/* Subroutine */ int cgeqr2_(integer *m, integer *n, complex *a, integer *lda, 
+	 complex *tau, complex *work, integer *info);
+
+/* Subroutine */ int cgeqrf_(integer *m, integer *n, complex *a, integer *lda, 
+	 complex *tau, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cgerfs_(char *trans, integer *n, integer *nrhs, complex *
+	a, integer *lda, complex *af, integer *ldaf, integer *ipiv, complex *
+	b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, 
+	complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgerfsx_(char *trans, char *equed, integer *n, integer *
+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer *
+	ipiv, real *r__, real *c__, complex *b, integer *ldb, complex *x, 
+	integer *ldx, real *rcond, real *berr, integer *n_err_bnds__, real *
+	err_bnds_norm__, real *err_bnds_comp__, integer *nparams, real *
+	params, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgerq2_(integer *m, integer *n, complex *a, integer *lda, 
+	 complex *tau, complex *work, integer *info);
+
+/* Subroutine */ int cgerqf_(integer *m, integer *n, complex *a, integer *lda, 
+	 complex *tau, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cgesc2_(integer *n, complex *a, integer *lda, complex *
+	rhs, integer *ipiv, integer *jpiv, real *scale);
+
+/* Subroutine */ int cgesdd_(char *jobz, integer *m, integer *n, complex *a, 
+	integer *lda, real *s, complex *u, integer *ldu, complex *vt, integer 
+	*ldvt, complex *work, integer *lwork, real *rwork, integer *iwork, 
+	integer *info);
+
+/* Subroutine */ int cgesv_(integer *n, integer *nrhs, complex *a, integer *
+	lda, integer *ipiv, complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cgesvd_(char *jobu, char *jobvt, integer *m, integer *n, 
+	complex *a, integer *lda, real *s, complex *u, integer *ldu, complex *
+	vt, integer *ldvt, complex *work, integer *lwork, real *rwork, 
+	integer *info);
+
+/* Subroutine */ int cgesvx_(char *fact, char *trans, integer *n, integer *
+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer *
+	ipiv, char *equed, real *r__, real *c__, complex *b, integer *ldb, 
+	complex *x, integer *ldx, real *rcond, real *ferr, real *berr, 
+	complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgesvxx_(char *fact, char *trans, integer *n, integer *
+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer *
+	ipiv, char *equed, real *r__, real *c__, complex *b, integer *ldb, 
+	complex *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, complex *work, real *rwork, integer *
+	info);
+
+/* Subroutine */ int cgetc2_(integer *n, complex *a, integer *lda, integer *
+	ipiv, integer *jpiv, integer *info);
+
+/* Subroutine */ int cgetf2_(integer *m, integer *n, complex *a, integer *lda, 
+	 integer *ipiv, integer *info);
+
+/* Subroutine */ int cgetrf_(integer *m, integer *n, complex *a, integer *lda, 
+	 integer *ipiv, integer *info);
+
+/* Subroutine */ int cgetri_(integer *n, complex *a, integer *lda, integer *
+	ipiv, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cgetrs_(char *trans, integer *n, integer *nrhs, complex *
+	a, integer *lda, integer *ipiv, complex *b, integer *ldb, integer *
+	info);
+
+/* Subroutine */ int cggbak_(char *job, char *side, integer *n, integer *ilo, 
+	integer *ihi, real *lscale, real *rscale, integer *m, complex *v, 
+	integer *ldv, integer *info);
+
+/* Subroutine */ int cggbal_(char *job, integer *n, complex *a, integer *lda, 
+	complex *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, complex *a, integer *lda, complex *b, integer *
+	ldb, integer *sdim, complex *alpha, complex *beta, complex *vsl, 
+	integer *ldvsl, complex *vsr, integer *ldvsr, complex *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, complex *a, integer *lda, complex *b, 
+	 integer *ldb, integer *sdim, complex *alpha, complex *beta, complex *
+	vsl, integer *ldvsl, complex *vsr, integer *ldvsr, real *rconde, real 
+	*rcondv, complex *work, integer *lwork, real *rwork, integer *iwork, 
+	integer *liwork, logical *bwork, integer *info);
+
+/* Subroutine */ int cggev_(char *jobvl, char *jobvr, integer *n, complex *a, 
+	integer *lda, complex *b, integer *ldb, complex *alpha, complex *beta, 
+	 complex *vl, integer *ldvl, complex *vr, integer *ldvr, complex *
+	work, integer *lwork, real *rwork, integer *info);
+
+/* Subroutine */ int cggevx_(char *balanc, char *jobvl, char *jobvr, char *
+	sense, integer *n, complex *a, integer *lda, complex *b, integer *ldb, 
+	 complex *alpha, complex *beta, complex *vl, integer *ldvl, complex *
+	vr, integer *ldvr, integer *ilo, integer *ihi, real *lscale, real *
+	rscale, real *abnrm, real *bbnrm, real *rconde, real *rcondv, complex 
+	*work, integer *lwork, real *rwork, integer *iwork, logical *bwork, 
+	integer *info);
+
+/* Subroutine */ int cggglm_(integer *n, integer *m, integer *p, complex *a, 
+	integer *lda, complex *b, integer *ldb, complex *d__, complex *x, 
+	complex *y, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cgghrd_(char *compq, char *compz, integer *n, integer *
+	ilo, integer *ihi, complex *a, integer *lda, complex *b, integer *ldb, 
+	 complex *q, integer *ldq, complex *z__, integer *ldz, integer *info);
+
+/* Subroutine */ int cgglse_(integer *m, integer *n, integer *p, complex *a, 
+	integer *lda, complex *b, integer *ldb, complex *c__, complex *d__, 
+	complex *x, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cggqrf_(integer *n, integer *m, integer *p, complex *a, 
+	integer *lda, complex *taua, complex *b, integer *ldb, complex *taub, 
+	complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cggrqf_(integer *m, integer *p, integer *n, complex *a, 
+	integer *lda, complex *taua, complex *b, integer *ldb, complex *taub, 
+	complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cggsvd_(char *jobu, char *jobv, char *jobq, integer *m, 
+	integer *n, integer *p, integer *k, integer *l, complex *a, integer *
+	lda, complex *b, integer *ldb, real *alpha, real *beta, complex *u, 
+	integer *ldu, complex *v, integer *ldv, complex *q, integer *ldq, 
+	complex *work, real *rwork, integer *iwork, integer *info);
+
+/* Subroutine */ int cggsvp_(char *jobu, char *jobv, char *jobq, integer *m, 
+	integer *p, integer *n, complex *a, integer *lda, complex *b, integer 
+	*ldb, real *tola, real *tolb, integer *k, integer *l, complex *u, 
+	integer *ldu, complex *v, integer *ldv, complex *q, integer *ldq, 
+	integer *iwork, real *rwork, complex *tau, complex *work, integer *
+	info);
+
+/* Subroutine */ int cgtcon_(char *norm, integer *n, complex *dl, complex *
+	d__, complex *du, complex *du2, integer *ipiv, real *anorm, real *
+	rcond, complex *work, integer *info);
+
+/* Subroutine */ int cgtrfs_(char *trans, integer *n, integer *nrhs, complex *
+	dl, complex *d__, complex *du, complex *dlf, complex *df, complex *
+	duf, complex *du2, integer *ipiv, complex *b, integer *ldb, complex *
+	x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, 
+	integer *info);
+
+/* Subroutine */ int cgtsv_(integer *n, integer *nrhs, complex *dl, complex *
+	d__, complex *du, complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cgtsvx_(char *fact, char *trans, integer *n, integer *
+	nrhs, complex *dl, complex *d__, complex *du, complex *dlf, complex *
+	df, complex *duf, complex *du2, integer *ipiv, complex *b, integer *
+	ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, 
+	complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cgttrf_(integer *n, complex *dl, complex *d__, complex *
+	du, complex *du2, integer *ipiv, integer *info);
+
+/* Subroutine */ int cgttrs_(char *trans, integer *n, integer *nrhs, complex *
+	dl, complex *d__, complex *du, complex *du2, integer *ipiv, complex *
+	b, integer *ldb, integer *info);
+
+/* Subroutine */ int cgtts2_(integer *itrans, integer *n, integer *nrhs, 
+	complex *dl, complex *d__, complex *du, complex *du2, integer *ipiv, 
+	complex *b, integer *ldb);
+
+/* Subroutine */ int chbev_(char *jobz, char *uplo, integer *n, integer *kd, 
+	complex *ab, integer *ldab, real *w, complex *z__, integer *ldz, 
+	complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int chbevd_(char *jobz, char *uplo, integer *n, integer *kd, 
+	complex *ab, integer *ldab, real *w, complex *z__, integer *ldz, 
+	complex *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, complex *ab, integer *ldab, complex *q, integer *ldq, 
+	real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *
+	m, real *w, complex *z__, integer *ldz, complex *work, real *rwork, 
+	integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int chbgst_(char *vect, char *uplo, integer *n, integer *ka, 
+	integer *kb, complex *ab, integer *ldab, complex *bb, integer *ldbb, 
+	complex *x, integer *ldx, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int chbgv_(char *jobz, char *uplo, integer *n, integer *ka, 
+	integer *kb, complex *ab, integer *ldab, complex *bb, integer *ldbb, 
+	real *w, complex *z__, integer *ldz, complex *work, real *rwork, 
+	integer *info);
+
+/* Subroutine */ int chbgvd_(char *jobz, char *uplo, integer *n, integer *ka, 
+	integer *kb, complex *ab, integer *ldab, complex *bb, integer *ldbb, 
+	real *w, complex *z__, integer *ldz, complex *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, complex *ab, integer *ldab, complex *bb, 
+	integer *ldbb, complex *q, integer *ldq, real *vl, real *vu, integer *
+	il, integer *iu, real *abstol, integer *m, real *w, complex *z__, 
+	integer *ldz, complex *work, real *rwork, integer *iwork, integer *
+	ifail, integer *info);
+
+/* Subroutine */ int chbtrd_(char *vect, char *uplo, integer *n, integer *kd, 
+	complex *ab, integer *ldab, real *d__, real *e, complex *q, integer *
+	ldq, complex *work, integer *info);
+
+/* Subroutine */ int checon_(char *uplo, integer *n, complex *a, integer *lda, 
+	 integer *ipiv, real *anorm, real *rcond, complex *work, integer *
+	info);
+
+/* Subroutine */ int cheequb_(char *uplo, integer *n, complex *a, integer *
+	lda, real *s, real *scond, real *amax, complex *work, integer *info);
+
+/* Subroutine */ int cheev_(char *jobz, char *uplo, integer *n, complex *a, 
+	integer *lda, real *w, complex *work, integer *lwork, real *rwork, 
+	integer *info);
+
+/* Subroutine */ int cheevd_(char *jobz, char *uplo, integer *n, complex *a, 
+	integer *lda, real *w, complex *work, integer *lwork, real *rwork, 
+	integer *lrwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int cheevr_(char *jobz, char *range, char *uplo, integer *n, 
+	complex *a, integer *lda, real *vl, real *vu, integer *il, integer *
+	iu, real *abstol, integer *m, real *w, complex *z__, integer *ldz, 
+	integer *isuppz, complex *work, integer *lwork, real *rwork, integer *
+	lrwork, integer *iwork, integer *liwork, integer *info);
+
+/* Subroutine */ int cheevx_(char *jobz, char *range, char *uplo, integer *n, 
+	complex *a, integer *lda, real *vl, real *vu, integer *il, integer *
+	iu, real *abstol, integer *m, real *w, complex *z__, integer *ldz, 
+	complex *work, integer *lwork, real *rwork, integer *iwork, integer *
+	ifail, integer *info);
+
+/* Subroutine */ int chegs2_(integer *itype, char *uplo, integer *n, complex *
+	a, integer *lda, complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int chegst_(integer *itype, char *uplo, integer *n, complex *
+	a, integer *lda, complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int chegv_(integer *itype, char *jobz, char *uplo, integer *
+	n, complex *a, integer *lda, complex *b, integer *ldb, real *w, 
+	complex *work, integer *lwork, real *rwork, integer *info);
+
+/* Subroutine */ int chegvd_(integer *itype, char *jobz, char *uplo, integer *
+	n, complex *a, integer *lda, complex *b, integer *ldb, real *w, 
+	complex *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, complex *a, integer *lda, complex *b, integer *ldb, 
+	real *vl, real *vu, integer *il, integer *iu, real *abstol, integer *
+	m, real *w, complex *z__, integer *ldz, complex *work, integer *lwork, 
+	 real *rwork, integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int cherfs_(char *uplo, integer *n, integer *nrhs, complex *
+	a, integer *lda, complex *af, integer *ldaf, integer *ipiv, complex *
+	b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, 
+	complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cherfsx_(char *uplo, char *equed, integer *n, integer *
+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer *
+	ipiv, real *s, complex *b, integer *ldb, complex *x, integer *ldx, 
+	real *rcond, real *berr, integer *n_err_bnds__, real *err_bnds_norm__, 
+	 real *err_bnds_comp__, integer *nparams, real *params, complex *work, 
+	 real *rwork, integer *info);
+
+/* Subroutine */ int chesv_(char *uplo, integer *n, integer *nrhs, complex *a, 
+	 integer *lda, integer *ipiv, complex *b, integer *ldb, complex *work, 
+	 integer *lwork, integer *info);
+
+/* Subroutine */ int chesvx_(char *fact, char *uplo, integer *n, integer *
+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer *
+	ipiv, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, 
+	 real *ferr, real *berr, complex *work, integer *lwork, real *rwork, 
+	integer *info);
+
+/* Subroutine */ int chesvxx_(char *fact, char *uplo, integer *n, integer *
+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer *
+	ipiv, char *equed, real *s, complex *b, integer *ldb, complex *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, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int chetd2_(char *uplo, integer *n, complex *a, integer *lda, 
+	 real *d__, real *e, complex *tau, integer *info);
+
+/* Subroutine */ int chetf2_(char *uplo, integer *n, complex *a, integer *lda, 
+	 integer *ipiv, integer *info);
+
+/* Subroutine */ int chetrd_(char *uplo, integer *n, complex *a, integer *lda, 
+	 real *d__, real *e, complex *tau, complex *work, integer *lwork, 
+	integer *info);
+
+/* Subroutine */ int chetrf_(char *uplo, integer *n, complex *a, integer *lda, 
+	 integer *ipiv, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int chetri_(char *uplo, integer *n, complex *a, integer *lda, 
+	 integer *ipiv, complex *work, integer *info);
+
+/* Subroutine */ int chetrs_(char *uplo, integer *n, integer *nrhs, complex *
+	a, integer *lda, integer *ipiv, complex *b, integer *ldb, integer *
+	info);
+
+/* Subroutine */ int chfrk_(char *transr, char *uplo, char *trans, integer *n, 
+	 integer *k, real *alpha, complex *a, integer *lda, real *beta, 
+	complex *c__);
+
+/* Subroutine */ int chgeqz_(char *job, char *compq, char *compz, integer *n, 
+	integer *ilo, integer *ihi, complex *h__, integer *ldh, complex *t, 
+	integer *ldt, complex *alpha, complex *beta, complex *q, integer *ldq, 
+	 complex *z__, integer *ldz, complex *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, complex *ap, integer *
+	ipiv, real *anorm, real *rcond, complex *work, integer *info);
+
+/* Subroutine */ int chpev_(char *jobz, char *uplo, integer *n, complex *ap, 
+	real *w, complex *z__, integer *ldz, complex *work, real *rwork, 
+	integer *info);
+
+/* Subroutine */ int chpevd_(char *jobz, char *uplo, integer *n, complex *ap, 
+	real *w, complex *z__, integer *ldz, complex *work, integer *lwork, 
+	real *rwork, integer *lrwork, integer *iwork, integer *liwork, 
+	integer *info);
+
+/* Subroutine */ int chpevx_(char *jobz, char *range, char *uplo, integer *n, 
+	complex *ap, real *vl, real *vu, integer *il, integer *iu, real *
+	abstol, integer *m, real *w, complex *z__, integer *ldz, complex *
+	work, real *rwork, integer *iwork, integer *ifail, integer *info);
+
+/* Subroutine */ int chpgst_(integer *itype, char *uplo, integer *n, complex *
+	ap, complex *bp, integer *info);
+
+/* Subroutine */ int chpgv_(integer *itype, char *jobz, char *uplo, integer *
+	n, complex *ap, complex *bp, real *w, complex *z__, integer *ldz, 
+	complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int chpgvd_(integer *itype, char *jobz, char *uplo, integer *
+	n, complex *ap, complex *bp, real *w, complex *z__, integer *ldz, 
+	complex *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, complex *ap, complex *bp, real *vl, real *vu, 
+	integer *il, integer *iu, real *abstol, integer *m, real *w, complex *
+	z__, integer *ldz, complex *work, real *rwork, integer *iwork, 
+	integer *ifail, integer *info);
+
+/* Subroutine */ int chprfs_(char *uplo, integer *n, integer *nrhs, complex *
+	ap, complex *afp, integer *ipiv, complex *b, integer *ldb, complex *x, 
+	 integer *ldx, real *ferr, real *berr, complex *work, real *rwork, 
+	integer *info);
+
+/* Subroutine */ int chpsv_(char *uplo, integer *n, integer *nrhs, complex *
+	ap, integer *ipiv, complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int chpsvx_(char *fact, char *uplo, integer *n, integer *
+	nrhs, complex *ap, complex *afp, integer *ipiv, complex *b, integer *
+	ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, 
+	complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int chptrd_(char *uplo, integer *n, complex *ap, real *d__, 
+	real *e, complex *tau, integer *info);
+
+/* Subroutine */ int chptrf_(char *uplo, integer *n, complex *ap, integer *
+	ipiv, integer *info);
+
+/* Subroutine */ int chptri_(char *uplo, integer *n, complex *ap, integer *
+	ipiv, complex *work, integer *info);
+
+/* Subroutine */ int chptrs_(char *uplo, integer *n, integer *nrhs, complex *
+	ap, integer *ipiv, complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int chsein_(char *side, char *eigsrc, char *initv, logical *
+	select, integer *n, complex *h__, integer *ldh, complex *w, complex *
+	vl, integer *ldvl, complex *vr, integer *ldvr, integer *mm, integer *
+	m, complex *work, real *rwork, integer *ifaill, integer *ifailr, 
+	integer *info);
+
+/* Subroutine */ int chseqr_(char *job, char *compz, integer *n, integer *ilo, 
+	 integer *ihi, complex *h__, integer *ldh, complex *w, complex *z__, 
+	integer *ldz, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cla_gbamv__(integer *trans, integer *m, integer *n, 
+	integer *kl, integer *ku, real *alpha, complex *ab, integer *ldab, 
+	complex *x, integer *incx, real *beta, real *y, integer *incy);
+
+doublereal cla_gbrcond_c__(char *trans, integer *n, integer *kl, integer *ku, 
+	complex *ab, integer *ldab, complex *afb, integer *ldafb, integer *
+	ipiv, real *c__, logical *capply, integer *info, complex *work, real *
+	rwork, ftnlen trans_len);
+
+doublereal cla_gbrcond_x__(char *trans, integer *n, integer *kl, integer *ku, 
+	complex *ab, integer *ldab, complex *afb, integer *ldafb, integer *
+	ipiv, complex *x, integer *info, complex *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, 
+	complex *ab, integer *ldab, complex *afb, integer *ldafb, integer *
+	ipiv, logical *colequ, real *c__, complex *b, integer *ldb, complex *
+	y, integer *ldy, real *berr_out__, integer *n_norms__, real *errs_n__,
+	 real *errs_c__, complex *res, real *ayb, complex *dy, complex *
+	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, complex *ab, integer *ldab, complex *afb, integer *ldafb);
+
+/* Subroutine */ int cla_geamv__(integer *trans, integer *m, integer *n, real 
+	*alpha, complex *a, integer *lda, complex *x, integer *incx, real *
+	beta, real *y, integer *incy);
+
+doublereal cla_gercond_c__(char *trans, integer *n, complex *a, integer *lda, 
+	complex *af, integer *ldaf, integer *ipiv, real *c__, logical *capply,
+	 integer *info, complex *work, real *rwork, ftnlen trans_len);
+
+doublereal cla_gercond_x__(char *trans, integer *n, complex *a, integer *lda, 
+	complex *af, integer *ldaf, integer *ipiv, complex *x, integer *info, 
+	complex *work, real *rwork, ftnlen trans_len);
+
+/* Subroutine */ int cla_gerfsx_extended__(integer *prec_type__, integer *
+	trans_type__, integer *n, integer *nrhs, complex *a, integer *lda, 
+	complex *af, integer *ldaf, integer *ipiv, logical *colequ, real *c__,
+	 complex *b, integer *ldb, complex *y, integer *ldy, real *berr_out__,
+	 integer *n_norms__, real *errs_n__, real *errs_c__, complex *res, 
+	real *ayb, complex *dy, complex *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, 
+	complex *a, integer *lda, complex *x, integer *incx, real *beta, real 
+	*y, integer *incy);
+
+doublereal cla_hercond_c__(char *uplo, integer *n, complex *a, integer *lda, 
+	complex *af, integer *ldaf, integer *ipiv, real *c__, logical *capply,
+	 integer *info, complex *work, real *rwork, ftnlen uplo_len);
+
+doublereal cla_hercond_x__(char *uplo, integer *n, complex *a, integer *lda, 
+	complex *af, integer *ldaf, integer *ipiv, complex *x, integer *info, 
+	complex *work, real *rwork, ftnlen uplo_len);
+
+/* Subroutine */ int cla_herfsx_extended__(integer *prec_type__, char *uplo, 
+	integer *n, integer *nrhs, complex *a, integer *lda, complex *af, 
+	integer *ldaf, integer *ipiv, logical *colequ, real *c__, complex *b, 
+	integer *ldb, complex *y, integer *ldy, real *berr_out__, integer *
+	n_norms__, real *errs_n__, real *errs_c__, complex *res, real *ayb, 
+	complex *dy, complex *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, complex *a, 
+	integer *lda, complex *af, integer *ldaf, integer *ipiv, real *work, 
+	ftnlen uplo_len);
+
+/* Subroutine */ int cla_lin_berr__(integer *n, integer *nz, integer *nrhs, 
+	complex *res, real *ayb, real *berr);
+
+doublereal cla_porcond_c__(char *uplo, integer *n, complex *a, integer *lda, 
+	complex *af, integer *ldaf, real *c__, logical *capply, integer *info,
+	 complex *work, real *rwork, ftnlen uplo_len);
+
+doublereal cla_porcond_x__(char *uplo, integer *n, complex *a, integer *lda, 
+	complex *af, integer *ldaf, complex *x, integer *info, complex *work, 
+	real *rwork, ftnlen uplo_len);
+
+/* Subroutine */ int cla_porfsx_extended__(integer *prec_type__, char *uplo, 
+	integer *n, integer *nrhs, complex *a, integer *lda, complex *af, 
+	integer *ldaf, logical *colequ, real *c__, complex *b, integer *ldb, 
+	complex *y, integer *ldy, real *berr_out__, integer *n_norms__, real *
+	errs_n__, real *errs_c__, complex *res, real *ayb, complex *dy, 
+	complex *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, complex *a, integer *
+	lda, complex *af, integer *ldaf, real *work, ftnlen uplo_len);
+
+doublereal cla_rpvgrw__(integer *n, integer *ncols, complex *a, integer *lda, 
+	complex *af, integer *ldaf);
+
+/* Subroutine */ int cla_syamv__(integer *uplo, integer *n, real *alpha, 
+	complex *a, integer *lda, complex *x, integer *incx, real *beta, real 
+	*y, integer *incy);
+
+doublereal cla_syrcond_c__(char *uplo, integer *n, complex *a, integer *lda, 
+	complex *af, integer *ldaf, integer *ipiv, real *c__, logical *capply,
+	 integer *info, complex *work, real *rwork, ftnlen uplo_len);
+
+doublereal cla_syrcond_x__(char *uplo, integer *n, complex *a, integer *lda, 
+	complex *af, integer *ldaf, integer *ipiv, complex *x, integer *info, 
+	complex *work, real *rwork, ftnlen uplo_len);
+
+/* Subroutine */ int cla_syrfsx_extended__(integer *prec_type__, char *uplo, 
+	integer *n, integer *nrhs, complex *a, integer *lda, complex *af, 
+	integer *ldaf, integer *ipiv, logical *colequ, real *c__, complex *b, 
+	integer *ldb, complex *y, integer *ldy, real *berr_out__, integer *
+	n_norms__, real *errs_n__, real *errs_c__, complex *res, real *ayb, 
+	complex *dy, complex *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, complex *a, 
+	integer *lda, complex *af, integer *ldaf, integer *ipiv, real *work, 
+	ftnlen uplo_len);
+
+/* Subroutine */ int cla_wwaddw__(integer *n, complex *x, complex *y, complex 
+	*w);
+
+/* Subroutine */ int clabrd_(integer *m, integer *n, integer *nb, complex *a, 
+	integer *lda, real *d__, real *e, complex *tauq, complex *taup, 
+	complex *x, integer *ldx, complex *y, integer *ldy);
+
+/* Subroutine */ int clacgv_(integer *n, complex *x, integer *incx);
+
+/* Subroutine */ int clacn2_(integer *n, complex *v, complex *x, real *est, 
+	integer *kase, integer *isave);
+
+/* Subroutine */ int clacon_(integer *n, complex *v, complex *x, real *est, 
+	integer *kase);
+
+/* Subroutine */ int clacp2_(char *uplo, integer *m, integer *n, real *a, 
+	integer *lda, complex *b, integer *ldb);
+
+/* Subroutine */ int clacpy_(char *uplo, integer *m, integer *n, complex *a, 
+	integer *lda, complex *b, integer *ldb);
+
+/* Subroutine */ int clacrm_(integer *m, integer *n, complex *a, integer *lda, 
+	 real *b, integer *ldb, complex *c__, integer *ldc, real *rwork);
+
+/* Subroutine */ int clacrt_(integer *n, complex *cx, integer *incx, complex *
+	cy, integer *incy, complex *c__, complex *s);
+
+/* Complex */ VOID cladiv_(complex * ret_val, complex *x, complex *y);
+
+/* Subroutine */ int claed0_(integer *qsiz, integer *n, real *d__, real *e, 
+	complex *q, integer *ldq, complex *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__, complex *
+	q, integer *ldq, real *rho, integer *indxq, real *qstore, integer *
+	qptr, integer *prmptr, integer *perm, integer *givptr, integer *
+	givcol, real *givnum, complex *work, real *rwork, integer *iwork, 
+	integer *info);
+
+/* Subroutine */ int claed8_(integer *k, integer *n, integer *qsiz, complex *
+	q, integer *ldq, real *d__, real *rho, integer *cutpnt, real *z__, 
+	real *dlamda, complex *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, 
+	complex *h__, integer *ldh, complex *w, complex *v, complex *b, 
+	integer *ldb, real *rwork, real *eps3, real *smlnum, integer *info);
+
+/* Subroutine */ int claesy_(complex *a, complex *b, complex *c__, complex *
+	rt1, complex *rt2, complex *evscal, complex *cs1, complex *sn1);
+
+/* Subroutine */ int claev2_(complex *a, complex *b, complex *c__, real *rt1, 
+	real *rt2, real *cs1, complex *sn1);
+
+/* Subroutine */ int clag2z_(integer *m, integer *n, complex *sa, integer *
+	ldsa, doublecomplex *a, integer *lda, integer *info);
+
+/* Subroutine */ int clags2_(logical *upper, real *a1, complex *a2, real *a3, 
+	real *b1, complex *b2, real *b3, real *csu, complex *snu, real *csv, 
+	complex *snv, real *csq, complex *snq);
+
+/* Subroutine */ int clagtm_(char *trans, integer *n, integer *nrhs, real *
+	alpha, complex *dl, complex *d__, complex *du, complex *x, integer *
+	ldx, real *beta, complex *b, integer *ldb);
+
+/* Subroutine */ int clahef_(char *uplo, integer *n, integer *nb, integer *kb, 
+	 complex *a, integer *lda, integer *ipiv, complex *w, integer *ldw, 
+	integer *info);
+
+/* Subroutine */ int clahqr_(logical *wantt, logical *wantz, integer *n, 
+	integer *ilo, integer *ihi, complex *h__, integer *ldh, complex *w, 
+	integer *iloz, integer *ihiz, complex *z__, integer *ldz, integer *
+	info);
+
+/* Subroutine */ int clahr2_(integer *n, integer *k, integer *nb, complex *a, 
+	integer *lda, complex *tau, complex *t, integer *ldt, complex *y, 
+	integer *ldy);
+
+/* Subroutine */ int clahrd_(integer *n, integer *k, integer *nb, complex *a, 
+	integer *lda, complex *tau, complex *t, integer *ldt, complex *y, 
+	integer *ldy);
+
+/* Subroutine */ int claic1_(integer *job, integer *j, complex *x, real *sest, 
+	 complex *w, complex *gamma, real *sestpr, complex *s, complex *c__);
+
+/* Subroutine */ int clals0_(integer *icompq, integer *nl, integer *nr, 
+	integer *sqre, integer *nrhs, complex *b, integer *ldb, complex *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, complex *b, integer *ldb, complex *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, complex *b, integer *ldb, real *rcond, 
+	integer *rank, complex *work, real *rwork, integer *iwork, integer *
+	info);
+
+doublereal clangb_(char *norm, integer *n, integer *kl, integer *ku, complex *
+	ab, integer *ldab, real *work);
+
+doublereal clange_(char *norm, integer *m, integer *n, complex *a, integer *
+	lda, real *work);
+
+doublereal clangt_(char *norm, integer *n, complex *dl, complex *d__, complex 
+	*du);
+
+doublereal clanhb_(char *norm, char *uplo, integer *n, integer *k, complex *
+	ab, integer *ldab, real *work);
+
+doublereal clanhe_(char *norm, char *uplo, integer *n, complex *a, integer *
+	lda, real *work);
+
+doublereal clanhf_(char *norm, char *transr, char *uplo, integer *n, complex *
+	a, real *work);
+
+doublereal clanhp_(char *norm, char *uplo, integer *n, complex *ap, real *
+	work);
+
+doublereal clanhs_(char *norm, integer *n, complex *a, integer *lda, real *
+	work);
+
+doublereal clanht_(char *norm, integer *n, real *d__, complex *e);
+
+doublereal clansb_(char *norm, char *uplo, integer *n, integer *k, complex *
+	ab, integer *ldab, real *work);
+
+doublereal clansp_(char *norm, char *uplo, integer *n, complex *ap, real *
+	work);
+
+doublereal clansy_(char *norm, char *uplo, integer *n, complex *a, integer *
+	lda, real *work);
+
+doublereal clantb_(char *norm, char *uplo, char *diag, integer *n, integer *k, 
+	 complex *ab, integer *ldab, real *work);
+
+doublereal clantp_(char *norm, char *uplo, char *diag, integer *n, complex *
+	ap, real *work);
+
+doublereal clantr_(char *norm, char *uplo, char *diag, integer *m, integer *n, 
+	 complex *a, integer *lda, real *work);
+
+/* Subroutine */ int clapll_(integer *n, complex *x, integer *incx, complex *
+	y, integer *incy, real *ssmin);
+
+/* Subroutine */ int clapmt_(logical *forwrd, integer *m, integer *n, complex 
+	*x, integer *ldx, integer *k);
+
+/* Subroutine */ int claqgb_(integer *m, integer *n, integer *kl, integer *ku, 
+	 complex *ab, integer *ldab, real *r__, real *c__, real *rowcnd, real 
+	*colcnd, real *amax, char *equed);
+
+/* Subroutine */ int claqge_(integer *m, integer *n, complex *a, integer *lda, 
+	 real *r__, real *c__, real *rowcnd, real *colcnd, real *amax, char *
+	equed);
+
+/* Subroutine */ int claqhb_(char *uplo, integer *n, integer *kd, complex *ab, 
+	 integer *ldab, real *s, real *scond, real *amax, char *equed);
+
+/* Subroutine */ int claqhe_(char *uplo, integer *n, complex *a, integer *lda, 
+	 real *s, real *scond, real *amax, char *equed);
+
+/* Subroutine */ int claqhp_(char *uplo, integer *n, complex *ap, real *s, 
+	real *scond, real *amax, char *equed);
+
+/* Subroutine */ int claqp2_(integer *m, integer *n, integer *offset, complex 
+	*a, integer *lda, integer *jpvt, complex *tau, real *vn1, real *vn2, 
+	complex *work);
+
+/* Subroutine */ int claqps_(integer *m, integer *n, integer *offset, integer 
+	*nb, integer *kb, complex *a, integer *lda, integer *jpvt, complex *
+	tau, real *vn1, real *vn2, complex *auxv, complex *f, integer *ldf);
+
+/* Subroutine */ int claqr0_(logical *wantt, logical *wantz, integer *n, 
+	integer *ilo, integer *ihi, complex *h__, integer *ldh, complex *w, 
+	integer *iloz, integer *ihiz, complex *z__, integer *ldz, complex *
+	work, integer *lwork, integer *info);
+
+/* Subroutine */ int claqr1_(integer *n, complex *h__, integer *ldh, complex *
+	s1, complex *s2, complex *v);
+
+/* Subroutine */ int claqr2_(logical *wantt, logical *wantz, integer *n, 
+	integer *ktop, integer *kbot, integer *nw, complex *h__, integer *ldh, 
+	 integer *iloz, integer *ihiz, complex *z__, integer *ldz, integer *
+	ns, integer *nd, complex *sh, complex *v, integer *ldv, integer *nh, 
+	complex *t, integer *ldt, integer *nv, complex *wv, integer *ldwv, 
+	complex *work, integer *lwork);
+
+/* Subroutine */ int claqr3_(logical *wantt, logical *wantz, integer *n, 
+	integer *ktop, integer *kbot, integer *nw, complex *h__, integer *ldh, 
+	 integer *iloz, integer *ihiz, complex *z__, integer *ldz, integer *
+	ns, integer *nd, complex *sh, complex *v, integer *ldv, integer *nh, 
+	complex *t, integer *ldt, integer *nv, complex *wv, integer *ldwv, 
+	complex *work, integer *lwork);
+
+/* Subroutine */ int claqr4_(logical *wantt, logical *wantz, integer *n, 
+	integer *ilo, integer *ihi, complex *h__, integer *ldh, complex *w, 
+	integer *iloz, integer *ihiz, complex *z__, integer *ldz, complex *
+	work, integer *lwork, integer *info);
+
+/* Subroutine */ int claqr5_(logical *wantt, logical *wantz, integer *kacc22, 
+	integer *n, integer *ktop, integer *kbot, integer *nshfts, complex *s, 
+	 complex *h__, integer *ldh, integer *iloz, integer *ihiz, complex *
+	z__, integer *ldz, complex *v, integer *ldv, complex *u, integer *ldu, 
+	 integer *nv, complex *wv, integer *ldwv, integer *nh, complex *wh, 
+	integer *ldwh);
+
+/* Subroutine */ int claqsb_(char *uplo, integer *n, integer *kd, complex *ab, 
+	 integer *ldab, real *s, real *scond, real *amax, char *equed);
+
+/* Subroutine */ int claqsp_(char *uplo, integer *n, complex *ap, real *s, 
+	real *scond, real *amax, char *equed);
+
+/* Subroutine */ int claqsy_(char *uplo, integer *n, complex *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, complex *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, complex *x, complex *y, complex *z__, 
+	 integer *incx, real *c__, complex *s, integer *incc);
+
+/* Subroutine */ int clarcm_(integer *m, integer *n, real *a, integer *lda, 
+	complex *b, integer *ldb, complex *c__, integer *ldc, real *rwork);
+
+/* Subroutine */ int clarf_(char *side, integer *m, integer *n, complex *v, 
+	integer *incv, complex *tau, complex *c__, integer *ldc, complex *
+	work);
+
+/* Subroutine */ int clarfb_(char *side, char *trans, char *direct, char *
+	storev, integer *m, integer *n, integer *k, complex *v, integer *ldv, 
+	complex *t, integer *ldt, complex *c__, integer *ldc, complex *work, 
+	integer *ldwork);
+
+/* Subroutine */ int clarfg_(integer *n, complex *alpha, complex *x, integer *
+	incx, complex *tau);
+
+/* Subroutine */ int clarfp_(integer *n, complex *alpha, complex *x, integer *
+	incx, complex *tau);
+
+/* Subroutine */ int clarft_(char *direct, char *storev, integer *n, integer *
+	k, complex *v, integer *ldv, complex *tau, complex *t, integer *ldt);
+
+/* Subroutine */ int clarfx_(char *side, integer *m, integer *n, complex *v, 
+	complex *tau, complex *c__, integer *ldc, complex *work);
+
+/* Subroutine */ int clargv_(integer *n, complex *x, integer *incx, complex *
+	y, integer *incy, real *c__, integer *incc);
+
+/* Subroutine */ int clarnv_(integer *idist, integer *iseed, integer *n, 
+	complex *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, complex *
+	z__, integer *ldz, integer *isuppz, real *work, integer *iwork, 
+	integer *info);
+
+/* Subroutine */ int clarscl2_(integer *m, integer *n, real *d__, complex *x, 
+	integer *ldx);
+
+/* Subroutine */ int clartg_(complex *f, complex *g, real *cs, complex *sn, 
+	complex *r__);
+
+/* Subroutine */ int clartv_(integer *n, complex *x, integer *incx, complex *
+	y, integer *incy, real *c__, complex *s, integer *incc);
+
+/* Subroutine */ int clarz_(char *side, integer *m, integer *n, integer *l, 
+	complex *v, integer *incv, complex *tau, complex *c__, integer *ldc, 
+	complex *work);
+
+/* Subroutine */ int clarzb_(char *side, char *trans, char *direct, char *
+	storev, integer *m, integer *n, integer *k, integer *l, complex *v, 
+	integer *ldv, complex *t, integer *ldt, complex *c__, integer *ldc, 
+	complex *work, integer *ldwork);
+
+/* Subroutine */ int clarzt_(char *direct, char *storev, integer *n, integer *
+	k, complex *v, integer *ldv, complex *tau, complex *t, integer *ldt);
+
+/* Subroutine */ int clascl_(char *type__, integer *kl, integer *ku, real *
+	cfrom, real *cto, integer *m, integer *n, complex *a, integer *lda, 
+	integer *info);
+
+/* Subroutine */ int clascl2_(integer *m, integer *n, real *d__, complex *x, 
+	integer *ldx);
+
+/* Subroutine */ int claset_(char *uplo, integer *m, integer *n, complex *
+	alpha, complex *beta, complex *a, integer *lda);
+
+/* Subroutine */ int clasr_(char *side, char *pivot, char *direct, integer *m, 
+	 integer *n, real *c__, real *s, complex *a, integer *lda);
+
+/* Subroutine */ int classq_(integer *n, complex *x, integer *incx, real *
+	scale, real *sumsq);
+
+/* Subroutine */ int claswp_(integer *n, complex *a, integer *lda, integer *
+	k1, integer *k2, integer *ipiv, integer *incx);
+
+/* Subroutine */ int clasyf_(char *uplo, integer *n, integer *nb, integer *kb, 
+	 complex *a, integer *lda, integer *ipiv, complex *w, integer *ldw, 
+	integer *info);
+
+/* Subroutine */ int clatbs_(char *uplo, char *trans, char *diag, char *
+	normin, integer *n, integer *kd, complex *ab, integer *ldab, complex *
+	x, real *scale, real *cnorm, integer *info);
+
+/* Subroutine */ int clatdf_(integer *ijob, integer *n, complex *z__, integer 
+	*ldz, complex *rhs, real *rdsum, real *rdscal, integer *ipiv, integer 
+	*jpiv);
+
+/* Subroutine */ int clatps_(char *uplo, char *trans, char *diag, char *
+	normin, integer *n, complex *ap, complex *x, real *scale, real *cnorm, 
+	 integer *info);
+
+/* Subroutine */ int clatrd_(char *uplo, integer *n, integer *nb, complex *a, 
+	integer *lda, real *e, complex *tau, complex *w, integer *ldw);
+
+/* Subroutine */ int clatrs_(char *uplo, char *trans, char *diag, char *
+	normin, integer *n, complex *a, integer *lda, complex *x, real *scale, 
+	 real *cnorm, integer *info);
+
+/* Subroutine */ int clatrz_(integer *m, integer *n, integer *l, complex *a, 
+	integer *lda, complex *tau, complex *work);
+
+/* Subroutine */ int clatzm_(char *side, integer *m, integer *n, complex *v, 
+	integer *incv, complex *tau, complex *c1, complex *c2, integer *ldc, 
+	complex *work);
+
+/* Subroutine */ int clauu2_(char *uplo, integer *n, complex *a, integer *lda, 
+	 integer *info);
+
+/* Subroutine */ int clauum_(char *uplo, integer *n, complex *a, integer *lda, 
+	 integer *info);
+
+/* Subroutine */ int cpbcon_(char *uplo, integer *n, integer *kd, complex *ab, 
+	 integer *ldab, real *anorm, real *rcond, complex *work, real *rwork, 
+	integer *info);
+
+/* Subroutine */ int cpbequ_(char *uplo, integer *n, integer *kd, complex *ab, 
+	 integer *ldab, real *s, real *scond, real *amax, integer *info);
+
+/* Subroutine */ int cpbrfs_(char *uplo, integer *n, integer *kd, integer *
+	nrhs, complex *ab, integer *ldab, complex *afb, integer *ldafb, 
+	complex *b, integer *ldb, complex *x, integer *ldx, real *ferr, real *
+	berr, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cpbstf_(char *uplo, integer *n, integer *kd, complex *ab, 
+	 integer *ldab, integer *info);
+
+/* Subroutine */ int cpbsv_(char *uplo, integer *n, integer *kd, integer *
+	nrhs, complex *ab, integer *ldab, complex *b, integer *ldb, integer *
+	info);
+
+/* Subroutine */ int cpbsvx_(char *fact, char *uplo, integer *n, integer *kd, 
+	integer *nrhs, complex *ab, integer *ldab, complex *afb, integer *
+	ldafb, char *equed, real *s, complex *b, integer *ldb, complex *x, 
+	integer *ldx, real *rcond, real *ferr, real *berr, complex *work, 
+	real *rwork, integer *info);
+
+/* Subroutine */ int cpbtf2_(char *uplo, integer *n, integer *kd, complex *ab, 
+	 integer *ldab, integer *info);
+
+/* Subroutine */ int cpbtrf_(char *uplo, integer *n, integer *kd, complex *ab, 
+	 integer *ldab, integer *info);
+
+/* Subroutine */ int cpbtrs_(char *uplo, integer *n, integer *kd, integer *
+	nrhs, complex *ab, integer *ldab, complex *b, integer *ldb, integer *
+	info);
+
+/* Subroutine */ int cpftrf_(char *transr, char *uplo, integer *n, complex *a, 
+	 integer *info);
+
+/* Subroutine */ int cpftri_(char *transr, char *uplo, integer *n, complex *a, 
+	 integer *info);
+
+/* Subroutine */ int cpftrs_(char *transr, char *uplo, integer *n, integer *
+	nrhs, complex *a, complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cpocon_(char *uplo, integer *n, complex *a, integer *lda, 
+	 real *anorm, real *rcond, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cpoequ_(integer *n, complex *a, integer *lda, real *s, 
+	real *scond, real *amax, integer *info);
+
+/* Subroutine */ int cpoequb_(integer *n, complex *a, integer *lda, real *s, 
+	real *scond, real *amax, integer *info);
+
+/* Subroutine */ int cporfs_(char *uplo, integer *n, integer *nrhs, complex *
+	a, integer *lda, complex *af, integer *ldaf, complex *b, integer *ldb, 
+	 complex *x, integer *ldx, real *ferr, real *berr, complex *work, 
+	real *rwork, integer *info);
+
+/* Subroutine */ int cporfsx_(char *uplo, char *equed, integer *n, integer *
+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, real *s, 
+	complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, real 
+	*berr, integer *n_err_bnds__, real *err_bnds_norm__, real *
+	err_bnds_comp__, integer *nparams, real *params, complex *work, real *
+	rwork, integer *info);
+
+/* Subroutine */ int cposv_(char *uplo, integer *n, integer *nrhs, complex *a, 
+	 integer *lda, complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cposvx_(char *fact, char *uplo, integer *n, integer *
+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, char *
+	equed, real *s, complex *b, integer *ldb, complex *x, integer *ldx, 
+	real *rcond, real *ferr, real *berr, complex *work, real *rwork, 
+	integer *info);
+
+/* Subroutine */ int cposvxx_(char *fact, char *uplo, integer *n, integer *
+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, char *
+	equed, real *s, complex *b, integer *ldb, complex *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, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cpotf2_(char *uplo, integer *n, complex *a, integer *lda, 
+	 integer *info);
+
+/* Subroutine */ int cpotrf_(char *uplo, integer *n, complex *a, integer *lda, 
+	 integer *info);
+
+/* Subroutine */ int cpotri_(char *uplo, integer *n, complex *a, integer *lda, 
+	 integer *info);
+
+/* Subroutine */ int cpotrs_(char *uplo, integer *n, integer *nrhs, complex *
+	a, integer *lda, complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cppcon_(char *uplo, integer *n, complex *ap, real *anorm, 
+	 real *rcond, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cppequ_(char *uplo, integer *n, complex *ap, real *s, 
+	real *scond, real *amax, integer *info);
+
+/* Subroutine */ int cpprfs_(char *uplo, integer *n, integer *nrhs, complex *
+	ap, complex *afp, complex *b, integer *ldb, complex *x, integer *ldx, 
+	real *ferr, real *berr, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cppsv_(char *uplo, integer *n, integer *nrhs, complex *
+	ap, complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cppsvx_(char *fact, char *uplo, integer *n, integer *
+	nrhs, complex *ap, complex *afp, char *equed, real *s, complex *b, 
+	integer *ldb, complex *x, integer *ldx, real *rcond, real *ferr, real 
+	*berr, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int cpptrf_(char *uplo, integer *n, complex *ap, integer *
+	info);
+
+/* Subroutine */ int cpptri_(char *uplo, integer *n, complex *ap, integer *
+	info);
+
+/* Subroutine */ int cpptrs_(char *uplo, integer *n, integer *nrhs, complex *
+	ap, complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cpstf2_(char *uplo, integer *n, complex *a, integer *lda, 
+	 integer *piv, integer *rank, real *tol, real *work, integer *info);
+
+/* Subroutine */ int cpstrf_(char *uplo, integer *n, complex *a, integer *lda, 
+	 integer *piv, integer *rank, real *tol, real *work, integer *info);
+
+/* Subroutine */ int cptcon_(integer *n, real *d__, complex *e, real *anorm, 
+	real *rcond, real *rwork, integer *info);
+
+/* Subroutine */ int cpteqr_(char *compz, integer *n, real *d__, real *e, 
+	complex *z__, integer *ldz, real *work, integer *info);
+
+/* Subroutine */ int cptrfs_(char *uplo, integer *n, integer *nrhs, real *d__, 
+	 complex *e, real *df, complex *ef, complex *b, integer *ldb, complex 
+	*x, integer *ldx, real *ferr, real *berr, complex *work, real *rwork, 
+	integer *info);
+
+/* Subroutine */ int cptsv_(integer *n, integer *nrhs, real *d__, complex *e, 
+	complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cptsvx_(char *fact, integer *n, integer *nrhs, real *d__, 
+	 complex *e, real *df, complex *ef, complex *b, integer *ldb, complex 
+	*x, integer *ldx, real *rcond, real *ferr, real *berr, complex *work, 
+	real *rwork, integer *info);
+
+/* Subroutine */ int cpttrf_(integer *n, real *d__, complex *e, integer *info);
+
+/* Subroutine */ int cpttrs_(char *uplo, integer *n, integer *nrhs, real *d__, 
+	 complex *e, complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cptts2_(integer *iuplo, integer *n, integer *nrhs, real *
+	d__, complex *e, complex *b, integer *ldb);
+
+/* Subroutine */ int crot_(integer *n, complex *cx, integer *incx, complex *
+	cy, integer *incy, real *c__, complex *s);
+
+/* Subroutine */ int cspcon_(char *uplo, integer *n, complex *ap, integer *
+	ipiv, real *anorm, real *rcond, complex *work, integer *info);
+
+/* Subroutine */ int cspmv_(char *uplo, integer *n, complex *alpha, complex *
+	ap, complex *x, integer *incx, complex *beta, complex *y, integer *
+	incy);
+
+/* Subroutine */ int cspr_(char *uplo, integer *n, complex *alpha, complex *x, 
+	 integer *incx, complex *ap);
+
+/* Subroutine */ int csprfs_(char *uplo, integer *n, integer *nrhs, complex *
+	ap, complex *afp, integer *ipiv, complex *b, integer *ldb, complex *x, 
+	 integer *ldx, real *ferr, real *berr, complex *work, real *rwork, 
+	integer *info);
+
+/* Subroutine */ int cspsv_(char *uplo, integer *n, integer *nrhs, complex *
+	ap, integer *ipiv, complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int cspsvx_(char *fact, char *uplo, integer *n, integer *
+	nrhs, complex *ap, complex *afp, integer *ipiv, complex *b, integer *
+	ldb, complex *x, integer *ldx, real *rcond, real *ferr, real *berr, 
+	complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int csptrf_(char *uplo, integer *n, complex *ap, integer *
+	ipiv, integer *info);
+
+/* Subroutine */ int csptri_(char *uplo, integer *n, complex *ap, integer *
+	ipiv, complex *work, integer *info);
+
+/* Subroutine */ int csptrs_(char *uplo, integer *n, integer *nrhs, complex *
+	ap, integer *ipiv, complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int csrscl_(integer *n, real *sa, complex *sx, integer *incx);
+
+/* Subroutine */ int cstedc_(char *compz, integer *n, real *d__, real *e, 
+	complex *z__, integer *ldz, complex *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, complex *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, complex *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, complex *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, 
+	complex *z__, integer *ldz, real *work, integer *info);
+
+/* Subroutine */ int csycon_(char *uplo, integer *n, complex *a, integer *lda, 
+	 integer *ipiv, real *anorm, real *rcond, complex *work, integer *
+	info);
+
+/* Subroutine */ int csyequb_(char *uplo, integer *n, complex *a, integer *
+	lda, real *s, real *scond, real *amax, complex *work, integer *info);
+
+/* Subroutine */ int csymv_(char *uplo, integer *n, complex *alpha, complex *
+	a, integer *lda, complex *x, integer *incx, complex *beta, complex *y, 
+	 integer *incy);
+
+/* Subroutine */ int csyr_(char *uplo, integer *n, complex *alpha, complex *x, 
+	 integer *incx, complex *a, integer *lda);
+
+/* Subroutine */ int csyrfs_(char *uplo, integer *n, integer *nrhs, complex *
+	a, integer *lda, complex *af, integer *ldaf, integer *ipiv, complex *
+	b, integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, 
+	complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int csyrfsx_(char *uplo, char *equed, integer *n, integer *
+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer *
+	ipiv, real *s, complex *b, integer *ldb, complex *x, integer *ldx, 
+	real *rcond, real *berr, integer *n_err_bnds__, real *err_bnds_norm__, 
+	 real *err_bnds_comp__, integer *nparams, real *params, complex *work, 
+	 real *rwork, integer *info);
+
+/* Subroutine */ int csysv_(char *uplo, integer *n, integer *nrhs, complex *a, 
+	 integer *lda, integer *ipiv, complex *b, integer *ldb, complex *work, 
+	 integer *lwork, integer *info);
+
+/* Subroutine */ int csysvx_(char *fact, char *uplo, integer *n, integer *
+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer *
+	ipiv, complex *b, integer *ldb, complex *x, integer *ldx, real *rcond, 
+	 real *ferr, real *berr, complex *work, integer *lwork, real *rwork, 
+	integer *info);
+
+/* Subroutine */ int csysvxx_(char *fact, char *uplo, integer *n, integer *
+	nrhs, complex *a, integer *lda, complex *af, integer *ldaf, integer *
+	ipiv, char *equed, real *s, complex *b, integer *ldb, complex *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, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int csytf2_(char *uplo, integer *n, complex *a, integer *lda, 
+	 integer *ipiv, integer *info);
+
+/* Subroutine */ int csytrf_(char *uplo, integer *n, complex *a, integer *lda, 
+	 integer *ipiv, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int csytri_(char *uplo, integer *n, complex *a, integer *lda, 
+	 integer *ipiv, complex *work, integer *info);
+
+/* Subroutine */ int csytrs_(char *uplo, integer *n, integer *nrhs, complex *
+	a, integer *lda, integer *ipiv, complex *b, integer *ldb, integer *
+	info);
+
+/* Subroutine */ int ctbcon_(char *norm, char *uplo, char *diag, integer *n, 
+	integer *kd, complex *ab, integer *ldab, real *rcond, complex *work, 
+	real *rwork, integer *info);
+
+/* Subroutine */ int ctbrfs_(char *uplo, char *trans, char *diag, integer *n, 
+	integer *kd, integer *nrhs, complex *ab, integer *ldab, complex *b, 
+	integer *ldb, complex *x, integer *ldx, real *ferr, real *berr, 
+	complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int ctbtrs_(char *uplo, char *trans, char *diag, integer *n, 
+	integer *kd, integer *nrhs, complex *ab, integer *ldab, complex *b, 
+	integer *ldb, integer *info);
+
+/* Subroutine */ int ctfsm_(char *transr, char *side, char *uplo, char *trans, 
+	 char *diag, integer *m, integer *n, complex *alpha, complex *a, 
+	complex *b, integer *ldb);
+
+/* Subroutine */ int ctftri_(char *transr, char *uplo, char *diag, integer *n, 
+	 complex *a, integer *info);
+
+/* Subroutine */ int ctfttp_(char *transr, char *uplo, integer *n, complex *
+	arf, complex *ap, integer *info);
+
+/* Subroutine */ int ctfttr_(char *transr, char *uplo, integer *n, complex *
+	arf, complex *a, integer *lda, integer *info);
+
+/* Subroutine */ int ctgevc_(char *side, char *howmny, logical *select, 
+	integer *n, complex *s, integer *lds, complex *p, integer *ldp, 
+	complex *vl, integer *ldvl, complex *vr, integer *ldvr, integer *mm, 
+	integer *m, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int ctgex2_(logical *wantq, logical *wantz, integer *n, 
+	complex *a, integer *lda, complex *b, integer *ldb, complex *q, 
+	integer *ldq, complex *z__, integer *ldz, integer *j1, integer *info);
+
+/* Subroutine */ int ctgexc_(logical *wantq, logical *wantz, integer *n, 
+	complex *a, integer *lda, complex *b, integer *ldb, complex *q, 
+	integer *ldq, complex *z__, integer *ldz, integer *ifst, integer *
+	ilst, integer *info);
+
+/* Subroutine */ int ctgsen_(integer *ijob, logical *wantq, logical *wantz, 
+	logical *select, integer *n, complex *a, integer *lda, complex *b, 
+	integer *ldb, complex *alpha, complex *beta, complex *q, integer *ldq, 
+	 complex *z__, integer *ldz, integer *m, real *pl, real *pr, real *
+	dif, complex *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, complex *a, integer *
+	lda, complex *b, integer *ldb, real *tola, real *tolb, real *alpha, 
+	real *beta, complex *u, integer *ldu, complex *v, integer *ldv, 
+	complex *q, integer *ldq, complex *work, integer *ncycle, integer *
+	info);
+
+/* Subroutine */ int ctgsna_(char *job, char *howmny, logical *select, 
+	integer *n, complex *a, integer *lda, complex *b, integer *ldb, 
+	complex *vl, integer *ldvl, complex *vr, integer *ldvr, real *s, real 
+	*dif, integer *mm, integer *m, complex *work, integer *lwork, integer 
+	*iwork, integer *info);
+
+/* Subroutine */ int ctgsy2_(char *trans, integer *ijob, integer *m, integer *
+	n, complex *a, integer *lda, complex *b, integer *ldb, complex *c__, 
+	integer *ldc, complex *d__, integer *ldd, complex *e, integer *lde, 
+	complex *f, integer *ldf, real *scale, real *rdsum, real *rdscal, 
+	integer *info);
+
+/* Subroutine */ int ctgsyl_(char *trans, integer *ijob, integer *m, integer *
+	n, complex *a, integer *lda, complex *b, integer *ldb, complex *c__, 
+	integer *ldc, complex *d__, integer *ldd, complex *e, integer *lde, 
+	complex *f, integer *ldf, real *scale, real *dif, complex *work, 
+	integer *lwork, integer *iwork, integer *info);
+
+/* Subroutine */ int ctpcon_(char *norm, char *uplo, char *diag, integer *n, 
+	complex *ap, real *rcond, complex *work, real *rwork, integer *info);
+
+/* Subroutine */ int ctprfs_(char *uplo, char *trans, char *diag, integer *n, 
+	integer *nrhs, complex *ap, complex *b, integer *ldb, complex *x, 
+	integer *ldx, real *ferr, real *berr, complex *work, real *rwork, 
+	integer *info);
+
+/* Subroutine */ int ctptri_(char *uplo, char *diag, integer *n, complex *ap, 
+	integer *info);
+
+/* Subroutine */ int ctptrs_(char *uplo, char *trans, char *diag, integer *n, 
+	integer *nrhs, complex *ap, complex *b, integer *ldb, integer *info);
+
+/* Subroutine */ int ctpttf_(char *transr, char *uplo, integer *n, complex *
+	ap, complex *arf, integer *info);
+
+/* Subroutine */ int ctpttr_(char *uplo, integer *n, complex *ap, complex *a, 
+	integer *lda, integer *info);
+
+/* Subroutine */ int ctrcon_(char *norm, char *uplo, char *diag, integer *n, 
+	complex *a, integer *lda, real *rcond, complex *work, real *rwork, 
+	integer *info);
+
+/* Subroutine */ int ctrevc_(char *side, char *howmny, logical *select, 
+	integer *n, complex *t, integer *ldt, complex *vl, integer *ldvl, 
+	complex *vr, integer *ldvr, integer *mm, integer *m, complex *work, 
+	real *rwork, integer *info);
+
+/* Subroutine */ int ctrexc_(char *compq, integer *n, complex *t, integer *
+	ldt, complex *q, integer *ldq, integer *ifst, integer *ilst, integer *
+	info);
+
+/* Subroutine */ int ctrrfs_(char *uplo, char *trans, char *diag, integer *n, 
+	integer *nrhs, complex *a, integer *lda, complex *b, integer *ldb, 
+	complex *x, integer *ldx, real *ferr, real *berr, complex *work, real 
+	*rwork, integer *info);
+
+/* Subroutine */ int ctrsen_(char *job, char *compq, logical *select, integer 
+	*n, complex *t, integer *ldt, complex *q, integer *ldq, complex *w, 
+	integer *m, real *s, real *sep, complex *work, integer *lwork, 
+	integer *info);
+
+/* Subroutine */ int ctrsna_(char *job, char *howmny, logical *select, 
+	integer *n, complex *t, integer *ldt, complex *vl, integer *ldvl, 
+	complex *vr, integer *ldvr, real *s, real *sep, integer *mm, integer *
+	m, complex *work, integer *ldwork, real *rwork, integer *info);
+
+/* Subroutine */ int ctrsyl_(char *trana, char *tranb, integer *isgn, integer 
+	*m, integer *n, complex *a, integer *lda, complex *b, integer *ldb, 
+	complex *c__, integer *ldc, real *scale, integer *info);
+
+/* Subroutine */ int ctrti2_(char *uplo, char *diag, integer *n, complex *a, 
+	integer *lda, integer *info);
+
+/* Subroutine */ int ctrtri_(char *uplo, char *diag, integer *n, complex *a, 
+	integer *lda, integer *info);
+
+/* Subroutine */ int ctrtrs_(char *uplo, char *trans, char *diag, integer *n, 
+	integer *nrhs, complex *a, integer *lda, complex *b, integer *ldb, 
+	integer *info);
+
+/* Subroutine */ int ctrttf_(char *transr, char *uplo, integer *n, complex *a, 
+	 integer *lda, complex *arf, integer *info);
+
+/* Subroutine */ int ctrttp_(char *uplo, integer *n, complex *a, integer *lda, 
+	 complex *ap, integer *info);
+
+/* Subroutine */ int ctzrqf_(integer *m, integer *n, complex *a, integer *lda, 
+	 complex *tau, integer *info);
+
+/* Subroutine */ int ctzrzf_(integer *m, integer *n, complex *a, integer *lda, 
+	 complex *tau, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cung2l_(integer *m, integer *n, integer *k, complex *a, 
+	integer *lda, complex *tau, complex *work, integer *info);
+
+/* Subroutine */ int cung2r_(integer *m, integer *n, integer *k, complex *a, 
+	integer *lda, complex *tau, complex *work, integer *info);
+
+/* Subroutine */ int cungbr_(char *vect, integer *m, integer *n, integer *k, 
+	complex *a, integer *lda, complex *tau, complex *work, integer *lwork, 
+	 integer *info);
+
+/* Subroutine */ int cunghr_(integer *n, integer *ilo, integer *ihi, complex *
+	a, integer *lda, complex *tau, complex *work, integer *lwork, integer 
+	*info);
+
+/* Subroutine */ int cungl2_(integer *m, integer *n, integer *k, complex *a, 
+	integer *lda, complex *tau, complex *work, integer *info);
+
+/* Subroutine */ int cunglq_(integer *m, integer *n, integer *k, complex *a, 
+	integer *lda, complex *tau, complex *work, integer *lwork, integer *
+	info);
+
+/* Subroutine */ int cungql_(integer *m, integer *n, integer *k, complex *a, 
+	integer *lda, complex *tau, complex *work, integer *lwork, integer *
+	info);
+
+/* Subroutine */ int cungqr_(integer *m, integer *n, integer *k, complex *a, 
+	integer *lda, complex *tau, complex *work, integer *lwork, integer *
+	info);
+
+/* Subroutine */ int cungr2_(integer *m, integer *n, integer *k, complex *a, 
+	integer *lda, complex *tau, complex *work, integer *info);
+
+/* Subroutine */ int cungrq_(integer *m, integer *n, integer *k, complex *a, 
+	integer *lda, complex *tau, complex *work, integer *lwork, integer *
+	info);
+
+/* Subroutine */ int cungtr_(char *uplo, integer *n, complex *a, integer *lda, 
+	 complex *tau, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cunm2l_(char *side, char *trans, integer *m, integer *n, 
+	integer *k, complex *a, integer *lda, complex *tau, complex *c__, 
+	integer *ldc, complex *work, integer *info);
+
+/* Subroutine */ int cunm2r_(char *side, char *trans, integer *m, integer *n, 
+	integer *k, complex *a, integer *lda, complex *tau, complex *c__, 
+	integer *ldc, complex *work, integer *info);
+
+/* Subroutine */ int cunmbr_(char *vect, char *side, char *trans, integer *m, 
+	integer *n, integer *k, complex *a, integer *lda, complex *tau, 
+	complex *c__, integer *ldc, complex *work, integer *lwork, integer *
+	info);
+
+/* Subroutine */ int cunmhr_(char *side, char *trans, integer *m, integer *n, 
+	integer *ilo, integer *ihi, complex *a, integer *lda, complex *tau, 
+	complex *c__, integer *ldc, complex *work, integer *lwork, integer *
+	info);
+
+/* Subroutine */ int cunml2_(char *side, char *trans, integer *m, integer *n, 
+	integer *k, complex *a, integer *lda, complex *tau, complex *c__, 
+	integer *ldc, complex *work, integer *info);
+
+/* Subroutine */ int cunmlq_(char *side, char *trans, integer *m, integer *n, 
+	integer *k, complex *a, integer *lda, complex *tau, complex *c__, 
+	integer *ldc, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cunmql_(char *side, char *trans, integer *m, integer *n, 
+	integer *k, complex *a, integer *lda, complex *tau, complex *c__, 
+	integer *ldc, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cunmqr_(char *side, char *trans, integer *m, integer *n, 
+	integer *k, complex *a, integer *lda, complex *tau, complex *c__, 
+	integer *ldc, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cunmr2_(char *side, char *trans, integer *m, integer *n, 
+	integer *k, complex *a, integer *lda, complex *tau, complex *c__, 
+	integer *ldc, complex *work, integer *info);
+
+/* Subroutine */ int cunmr3_(char *side, char *trans, integer *m, integer *n, 
+	integer *k, integer *l, complex *a, integer *lda, complex *tau, 
+	complex *c__, integer *ldc, complex *work, integer *info);
+
+/* Subroutine */ int cunmrq_(char *side, char *trans, integer *m, integer *n, 
+	integer *k, complex *a, integer *lda, complex *tau, complex *c__, 
+	integer *ldc, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cunmrz_(char *side, char *trans, integer *m, integer *n, 
+	integer *k, integer *l, complex *a, integer *lda, complex *tau, 
+	complex *c__, integer *ldc, complex *work, integer *lwork, integer *
+	info);
+
+/* Subroutine */ int cunmtr_(char *side, char *uplo, char *trans, integer *m, 
+	integer *n, complex *a, integer *lda, complex *tau, complex *c__, 
+	integer *ldc, complex *work, integer *lwork, integer *info);
+
+/* Subroutine */ int cupgtr_(char *uplo, integer *n, complex *ap, complex *
+	tau, complex *q, integer *ldq, complex *work, integer *info);
+
+/* Subroutine */ int cupmtr_(char *side, char *uplo, char *trans, integer *m, 
+	integer *n, complex *ap, complex *tau, complex *c__, integer *ldc, 
+	complex *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 *small, 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, complex *cx, integer *incx);
+
+integer ieeeck_(integer *ispec, real *zero, real *one);
+
+integer ilaclc_(integer *m, integer *n, complex *a, integer *lda);
+
+integer ilaclr_(integer *m, integer *n, complex *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, complex *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 *small, 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, complex *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, complex *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 Complex */ 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, complex *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, complex *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);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* __CLAPACK_H */
diff --git a/tests/linalg/external/dlasr.c b/tests/linalg/external/dlasr.c
new file mode 100644
index 000000000..6abfa8140
--- /dev/null
+++ b/tests/linalg/external/dlasr.c
@@ -0,0 +1,453 @@
+/* dlasr.f -- translated by f2c (version 20061008).
+   You must link the resulting object file with libf2c:
+	on Microsoft Windows system, link with libf2c.lib;
+	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
+	or, if you install libf2c.a in a standard place, with -lf2c -lm
+	-- in that order, at the end of the command line, as in
+		cc *.o -lf2c -lm
+	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
+
+		http://www.netlib.org/f2c/libf2c.zip
+*/
+
+#include "f2c.h"
+#include "blaswrap.h"
+
+/* Subroutine */ int dlasr_(char *side, char *pivot, char *direct, integer *m, 
+	 integer *n, doublereal *c__, doublereal *s, doublereal *a, integer *
+	lda)
+{
+    /* System generated locals */
+    integer a_dim1, a_offset, i__1, i__2;
+
+    /* Local variables */
+    integer i__, j, info;
+    doublereal temp;
+    extern logical lsame_(char *, char *);
+    doublereal ctemp, stemp;
+    extern /* Subroutine */ int xerbla_(char *, integer *);
+
+
+/*  -- LAPACK auxiliary routine (version 3.2) -- */
+/*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
+/*     November 2006 */
+
+/*     .. Scalar Arguments .. */
+/*     .. */
+/*     .. Array Arguments .. */
+/*     .. */
+
+/*  Purpose */
+/*  ======= */
+
+/*  DLASR applies a sequence of plane rotations to a real matrix A, */
+/*  from either the left or the right. */
+
+/*  When SIDE = 'L', the transformation takes the form */
+
+/*     A := P*A */
+
+/*  and when SIDE = 'R', the transformation takes the form */
+
+/*     A := A*P**T */
+
+/*  where P is an orthogonal matrix consisting of a sequence of z plane */
+/*  rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R', */
+/*  and P**T is the transpose of P. */
+
+/*  When DIRECT = 'F' (Forward sequence), then */
+
+/*     P = P(z-1) * ... * P(2) * P(1) */
+
+/*  and when DIRECT = 'B' (Backward sequence), then */
+
+/*     P = P(1) * P(2) * ... * P(z-1) */
+
+/*  where P(k) is a plane rotation matrix defined by the 2-by-2 rotation */
+
+/*     R(k) = (  c(k)  s(k) ) */
+/*          = ( -s(k)  c(k) ). */
+
+/*  When PIVOT = 'V' (Variable pivot), the rotation is performed */
+/*  for the plane (k,k+1), i.e., P(k) has the form */
+
+/*     P(k) = (  1                                            ) */
+/*            (       ...                                     ) */
+/*            (              1                                ) */
+/*            (                   c(k)  s(k)                  ) */
+/*            (                  -s(k)  c(k)                  ) */
+/*            (                                1              ) */
+/*            (                                     ...       ) */
+/*            (                                            1  ) */
+
+/*  where R(k) appears as a rank-2 modification to the identity matrix in */
+/*  rows and columns k and k+1. */
+
+/*  When PIVOT = 'T' (Top pivot), the rotation is performed for the */
+/*  plane (1,k+1), so P(k) has the form */
+
+/*     P(k) = (  c(k)                    s(k)                 ) */
+/*            (         1                                     ) */
+/*            (              ...                              ) */
+/*            (                     1                         ) */
+/*            ( -s(k)                    c(k)                 ) */
+/*            (                                 1             ) */
+/*            (                                      ...      ) */
+/*            (                                             1 ) */
+
+/*  where R(k) appears in rows and columns 1 and k+1. */
+
+/*  Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is */
+/*  performed for the plane (k,z), giving P(k) the form */
+
+/*     P(k) = ( 1                                             ) */
+/*            (      ...                                      ) */
+/*            (             1                                 ) */
+/*            (                  c(k)                    s(k) ) */
+/*            (                         1                     ) */
+/*            (                              ...              ) */
+/*            (                                     1         ) */
+/*            (                 -s(k)                    c(k) ) */
+
+/*  where R(k) appears in rows and columns k and z.  The rotations are */
+/*  performed without ever forming P(k) explicitly. */
+
+/*  Arguments */
+/*  ========= */
+
+/*  SIDE    (input) CHARACTER*1 */
+/*          Specifies whether the plane rotation matrix P is applied to */
+/*          A on the left or the right. */
+/*          = 'L':  Left, compute A := P*A */
+/*          = 'R':  Right, compute A:= A*P**T */
+
+/*  PIVOT   (input) CHARACTER*1 */
+/*          Specifies the plane for which P(k) is a plane rotation */
+/*          matrix. */
+/*          = 'V':  Variable pivot, the plane (k,k+1) */
+/*          = 'T':  Top pivot, the plane (1,k+1) */
+/*          = 'B':  Bottom pivot, the plane (k,z) */
+
+/*  DIRECT  (input) CHARACTER*1 */
+/*          Specifies whether P is a forward or backward sequence of */
+/*          plane rotations. */
+/*          = 'F':  Forward, P = P(z-1)*...*P(2)*P(1) */
+/*          = 'B':  Backward, P = P(1)*P(2)*...*P(z-1) */
+
+/*  M       (input) INTEGER */
+/*          The number of rows of the matrix A.  If m <= 1, an immediate */
+/*          return is effected. */
+
+/*  N       (input) INTEGER */
+/*          The number of columns of the matrix A.  If n <= 1, an */
+/*          immediate return is effected. */
+
+/*  C       (input) DOUBLE PRECISION array, dimension */
+/*                  (M-1) if SIDE = 'L' */
+/*                  (N-1) if SIDE = 'R' */
+/*          The cosines c(k) of the plane rotations. */
+
+/*  S       (input) DOUBLE PRECISION array, dimension */
+/*                  (M-1) if SIDE = 'L' */
+/*                  (N-1) if SIDE = 'R' */
+/*          The sines s(k) of the plane rotations.  The 2-by-2 plane */
+/*          rotation part of the matrix P(k), R(k), has the form */
+/*          R(k) = (  c(k)  s(k) ) */
+/*                 ( -s(k)  c(k) ). */
+
+/*  A       (input/output) DOUBLE PRECISION array, dimension (LDA,N) */
+/*          The M-by-N matrix A.  On exit, A is overwritten by P*A if */
+/*          SIDE = 'R' or by A*P**T if SIDE = 'L'. */
+
+/*  LDA     (input) INTEGER */
+/*          The leading dimension of the array A.  LDA >= max(1,M). */
+
+/*  ===================================================================== */
+
+/*     .. Parameters .. */
+/*     .. */
+/*     .. Local Scalars .. */
+/*     .. */
+/*     .. External Functions .. */
+/*     .. */
+/*     .. External Subroutines .. */
+/*     .. */
+/*     .. Intrinsic Functions .. */
+/*     .. */
+/*     .. Executable Statements .. */
+
+/*     Test the input parameters */
+
+    /* Parameter adjustments */
+    --c__;
+    --s;
+    a_dim1 = *lda;
+    a_offset = 1 + a_dim1;
+    a -= a_offset;
+
+    /* Function Body */
+    info = 0;
+    if (! (lsame_(side, "L") || lsame_(side, "R"))) {
+	info = 1;
+    } else if (! (lsame_(pivot, "V") || lsame_(pivot, 
+	    "T") || lsame_(pivot, "B"))) {
+	info = 2;
+    } else if (! (lsame_(direct, "F") || lsame_(direct, 
+	    "B"))) {
+	info = 3;
+    } else if (*m < 0) {
+	info = 4;
+    } else if (*n < 0) {
+	info = 5;
+    } else if (*lda < max(1,*m)) {
+	info = 9;
+    }
+    if (info != 0) {
+	xerbla_("DLASR ", &info);
+	return 0;
+    }
+
+/*     Quick return if possible */
+
+    if (*m == 0 || *n == 0) {
+	return 0;
+    }
+    if (lsame_(side, "L")) {
+
+/*        Form  P * A */
+
+	if (lsame_(pivot, "V")) {
+	    if (lsame_(direct, "F")) {
+		i__1 = *m - 1;
+		for (j = 1; j <= i__1; ++j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1. || stemp != 0.) {
+			i__2 = *n;
+			for (i__ = 1; i__ <= i__2; ++i__) {
+			    temp = a[j + 1 + i__ * a_dim1];
+			    a[j + 1 + i__ * a_dim1] = ctemp * temp - stemp * 
+				    a[j + i__ * a_dim1];
+			    a[j + i__ * a_dim1] = stemp * temp + ctemp * a[j 
+				    + i__ * a_dim1];
+/* L10: */
+			}
+		    }
+/* L20: */
+		}
+	    } else if (lsame_(direct, "B")) {
+		for (j = *m - 1; j >= 1; --j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1. || stemp != 0.) {
+			i__1 = *n;
+			for (i__ = 1; i__ <= i__1; ++i__) {
+			    temp = a[j + 1 + i__ * a_dim1];
+			    a[j + 1 + i__ * a_dim1] = ctemp * temp - stemp * 
+				    a[j + i__ * a_dim1];
+			    a[j + i__ * a_dim1] = stemp * temp + ctemp * a[j 
+				    + i__ * a_dim1];
+/* L30: */
+			}
+		    }
+/* L40: */
+		}
+	    }
+	} else if (lsame_(pivot, "T")) {
+	    if (lsame_(direct, "F")) {
+		i__1 = *m;
+		for (j = 2; j <= i__1; ++j) {
+		    ctemp = c__[j - 1];
+		    stemp = s[j - 1];
+		    if (ctemp != 1. || stemp != 0.) {
+			i__2 = *n;
+			for (i__ = 1; i__ <= i__2; ++i__) {
+			    temp = a[j + i__ * a_dim1];
+			    a[j + i__ * a_dim1] = ctemp * temp - stemp * a[
+				    i__ * a_dim1 + 1];
+			    a[i__ * a_dim1 + 1] = stemp * temp + ctemp * a[
+				    i__ * a_dim1 + 1];
+/* L50: */
+			}
+		    }
+/* L60: */
+		}
+	    } else if (lsame_(direct, "B")) {
+		for (j = *m; j >= 2; --j) {
+		    ctemp = c__[j - 1];
+		    stemp = s[j - 1];
+		    if (ctemp != 1. || stemp != 0.) {
+			i__1 = *n;
+			for (i__ = 1; i__ <= i__1; ++i__) {
+			    temp = a[j + i__ * a_dim1];
+			    a[j + i__ * a_dim1] = ctemp * temp - stemp * a[
+				    i__ * a_dim1 + 1];
+			    a[i__ * a_dim1 + 1] = stemp * temp + ctemp * a[
+				    i__ * a_dim1 + 1];
+/* L70: */
+			}
+		    }
+/* L80: */
+		}
+	    }
+	} else if (lsame_(pivot, "B")) {
+	    if (lsame_(direct, "F")) {
+		i__1 = *m - 1;
+		for (j = 1; j <= i__1; ++j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1. || stemp != 0.) {
+			i__2 = *n;
+			for (i__ = 1; i__ <= i__2; ++i__) {
+			    temp = a[j + i__ * a_dim1];
+			    a[j + i__ * a_dim1] = stemp * a[*m + i__ * a_dim1]
+				     + ctemp * temp;
+			    a[*m + i__ * a_dim1] = ctemp * a[*m + i__ * 
+				    a_dim1] - stemp * temp;
+/* L90: */
+			}
+		    }
+/* L100: */
+		}
+	    } else if (lsame_(direct, "B")) {
+		for (j = *m - 1; j >= 1; --j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1. || stemp != 0.) {
+			i__1 = *n;
+			for (i__ = 1; i__ <= i__1; ++i__) {
+			    temp = a[j + i__ * a_dim1];
+			    a[j + i__ * a_dim1] = stemp * a[*m + i__ * a_dim1]
+				     + ctemp * temp;
+			    a[*m + i__ * a_dim1] = ctemp * a[*m + i__ * 
+				    a_dim1] - stemp * temp;
+/* L110: */
+			}
+		    }
+/* L120: */
+		}
+	    }
+	}
+    } else if (lsame_(side, "R")) {
+
+/*        Form A * P' */
+
+	if (lsame_(pivot, "V")) {
+	    if (lsame_(direct, "F")) {
+		i__1 = *n - 1;
+		for (j = 1; j <= i__1; ++j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1. || stemp != 0.) {
+			i__2 = *m;
+			for (i__ = 1; i__ <= i__2; ++i__) {
+			    temp = a[i__ + (j + 1) * a_dim1];
+			    a[i__ + (j + 1) * a_dim1] = ctemp * temp - stemp *
+				     a[i__ + j * a_dim1];
+			    a[i__ + j * a_dim1] = stemp * temp + ctemp * a[
+				    i__ + j * a_dim1];
+/* L130: */
+			}
+		    }
+/* L140: */
+		}
+	    } else if (lsame_(direct, "B")) {
+		for (j = *n - 1; j >= 1; --j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1. || stemp != 0.) {
+			i__1 = *m;
+			for (i__ = 1; i__ <= i__1; ++i__) {
+			    temp = a[i__ + (j + 1) * a_dim1];
+			    a[i__ + (j + 1) * a_dim1] = ctemp * temp - stemp *
+				     a[i__ + j * a_dim1];
+			    a[i__ + j * a_dim1] = stemp * temp + ctemp * a[
+				    i__ + j * a_dim1];
+/* L150: */
+			}
+		    }
+/* L160: */
+		}
+	    }
+	} else if (lsame_(pivot, "T")) {
+	    if (lsame_(direct, "F")) {
+		i__1 = *n;
+		for (j = 2; j <= i__1; ++j) {
+		    ctemp = c__[j - 1];
+		    stemp = s[j - 1];
+		    if (ctemp != 1. || stemp != 0.) {
+			i__2 = *m;
+			for (i__ = 1; i__ <= i__2; ++i__) {
+			    temp = a[i__ + j * a_dim1];
+			    a[i__ + j * a_dim1] = ctemp * temp - stemp * a[
+				    i__ + a_dim1];
+			    a[i__ + a_dim1] = stemp * temp + ctemp * a[i__ + 
+				    a_dim1];
+/* L170: */
+			}
+		    }
+/* L180: */
+		}
+	    } else if (lsame_(direct, "B")) {
+		for (j = *n; j >= 2; --j) {
+		    ctemp = c__[j - 1];
+		    stemp = s[j - 1];
+		    if (ctemp != 1. || stemp != 0.) {
+			i__1 = *m;
+			for (i__ = 1; i__ <= i__1; ++i__) {
+			    temp = a[i__ + j * a_dim1];
+			    a[i__ + j * a_dim1] = ctemp * temp - stemp * a[
+				    i__ + a_dim1];
+			    a[i__ + a_dim1] = stemp * temp + ctemp * a[i__ + 
+				    a_dim1];
+/* L190: */
+			}
+		    }
+/* L200: */
+		}
+	    }
+	} else if (lsame_(pivot, "B")) {
+	    if (lsame_(direct, "F")) {
+		i__1 = *n - 1;
+		for (j = 1; j <= i__1; ++j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1. || stemp != 0.) {
+			i__2 = *m;
+			for (i__ = 1; i__ <= i__2; ++i__) {
+			    temp = a[i__ + j * a_dim1];
+			    a[i__ + j * a_dim1] = stemp * a[i__ + *n * a_dim1]
+				     + ctemp * temp;
+			    a[i__ + *n * a_dim1] = ctemp * a[i__ + *n * 
+				    a_dim1] - stemp * temp;
+/* L210: */
+			}
+		    }
+/* L220: */
+		}
+	    } else if (lsame_(direct, "B")) {
+		for (j = *n - 1; j >= 1; --j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1. || stemp != 0.) {
+			i__1 = *m;
+			for (i__ = 1; i__ <= i__1; ++i__) {
+			    temp = a[i__ + j * a_dim1];
+			    a[i__ + j * a_dim1] = stemp * a[i__ + *n * a_dim1]
+				     + ctemp * temp;
+			    a[i__ + *n * a_dim1] = ctemp * a[i__ + *n * 
+				    a_dim1] - stemp * temp;
+/* L230: */
+			}
+		    }
+/* L240: */
+		}
+	    }
+	}
+    }
+
+    return 0;
+
+/*     End of DLASR */
+
+} /* dlasr_ */
diff --git a/tests/linalg/external/f2c.h b/tests/linalg/external/f2c.h
new file mode 100644
index 000000000..b94ee7c8e
--- /dev/null
+++ b/tests/linalg/external/f2c.h
@@ -0,0 +1,223 @@
+/* f2c.h  --  Standard Fortran to C header file */
+
+/**  barf  [ba:rf]  2.  "He suggested using FORTRAN, and everybody barfed."
+
+	- From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */
+
+#ifndef F2C_INCLUDE
+#define F2C_INCLUDE
+
+typedef long int integer;
+typedef unsigned long int uinteger;
+typedef char *address;
+typedef short int shortint;
+typedef float real;
+typedef double doublereal;
+typedef struct { real r, i; } complex;
+typedef struct { doublereal r, i; } doublecomplex;
+typedef long int logical;
+typedef short int shortlogical;
+typedef char logical1;
+typedef char integer1;
+#ifdef INTEGER_STAR_8	/* Adjust for integer*8. */
+typedef long long longint;		/* system-dependent */
+typedef unsigned long long ulongint;	/* system-dependent */
+#define qbit_clear(a,b)	((a) & ~((ulongint)1 << (b)))
+#define qbit_set(a,b)	((a) |  ((ulongint)1 << (b)))
+#endif
+
+#define TRUE_ (1)
+#define FALSE_ (0)
+
+/* Extern is for use with -E */
+#ifndef Extern
+#define Extern extern
+#endif
+
+/* I/O stuff */
+
+#ifdef f2c_i2
+/* for -i2 */
+typedef short flag;
+typedef short ftnlen;
+typedef short ftnint;
+#else
+typedef long int flag;
+typedef long int ftnlen;
+typedef long int ftnint;
+#endif
+
+/*external read, write*/
+typedef struct
+{	flag cierr;
+	ftnint ciunit;
+	flag ciend;
+	char *cifmt;
+	ftnint cirec;
+} cilist;
+
+/*internal read, write*/
+typedef struct
+{	flag icierr;
+	char *iciunit;
+	flag iciend;
+	char *icifmt;
+	ftnint icirlen;
+	ftnint icirnum;
+} icilist;
+
+/*open*/
+typedef struct
+{	flag oerr;
+	ftnint ounit;
+	char *ofnm;
+	ftnlen ofnmlen;
+	char *osta;
+	char *oacc;
+	char *ofm;
+	ftnint orl;
+	char *oblnk;
+} olist;
+
+/*close*/
+typedef struct
+{	flag cerr;
+	ftnint cunit;
+	char *csta;
+} cllist;
+
+/*rewind, backspace, endfile*/
+typedef struct
+{	flag aerr;
+	ftnint aunit;
+} alist;
+
+/* inquire */
+typedef struct
+{	flag inerr;
+	ftnint inunit;
+	char *infile;
+	ftnlen infilen;
+	ftnint	*inex;	/*parameters in standard's order*/
+	ftnint	*inopen;
+	ftnint	*innum;
+	ftnint	*innamed;
+	char	*inname;
+	ftnlen	innamlen;
+	char	*inacc;
+	ftnlen	inacclen;
+	char	*inseq;
+	ftnlen	inseqlen;
+	char 	*indir;
+	ftnlen	indirlen;
+	char	*infmt;
+	ftnlen	infmtlen;
+	char	*inform;
+	ftnint	informlen;
+	char	*inunf;
+	ftnlen	inunflen;
+	ftnint	*inrecl;
+	ftnint	*innrec;
+	char	*inblank;
+	ftnlen	inblanklen;
+} inlist;
+
+#define VOID void
+
+union Multitype {	/* for multiple entry points */
+	integer1 g;
+	shortint h;
+	integer i;
+	/* longint j; */
+	real r;
+	doublereal d;
+	complex c;
+	doublecomplex z;
+	};
+
+typedef union Multitype Multitype;
+
+/*typedef long int Long;*/	/* No longer used; formerly in Namelist */
+
+struct Vardesc {	/* for Namelist */
+	char *name;
+	char *addr;
+	ftnlen *dims;
+	int  type;
+	};
+typedef struct Vardesc Vardesc;
+
+struct Namelist {
+	char *name;
+	Vardesc **vars;
+	int nvars;
+	};
+typedef struct Namelist Namelist;
+
+#define abs(x) ((x) >= 0 ? (x) : -(x))
+#define dabs(x) (doublereal)abs(x)
+#define min(a,b) ((a) <= (b) ? (a) : (b))
+#define max(a,b) ((a) >= (b) ? (a) : (b))
+#define dmin(a,b) (doublereal)min(a,b)
+#define dmax(a,b) (doublereal)max(a,b)
+#define bit_test(a,b)	((a) >> (b) & 1)
+#define bit_clear(a,b)	((a) & ~((uinteger)1 << (b)))
+#define bit_set(a,b)	((a) |  ((uinteger)1 << (b)))
+
+/* procedure parameter types for -A and -C++ */
+
+#define F2C_proc_par_types 1
+#ifdef __cplusplus
+typedef int /* Unknown procedure type */ (*U_fp)(...);
+typedef shortint (*J_fp)(...);
+typedef integer (*I_fp)(...);
+typedef real (*R_fp)(...);
+typedef doublereal (*D_fp)(...), (*E_fp)(...);
+typedef /* Complex */ VOID (*C_fp)(...);
+typedef /* Double Complex */ VOID (*Z_fp)(...);
+typedef logical (*L_fp)(...);
+typedef shortlogical (*K_fp)(...);
+typedef /* Character */ VOID (*H_fp)(...);
+typedef /* Subroutine */ int (*S_fp)(...);
+#else
+typedef int /* Unknown procedure type */ (*U_fp)();
+typedef shortint (*J_fp)();
+typedef integer (*I_fp)();
+typedef real (*R_fp)();
+typedef doublereal (*D_fp)(), (*E_fp)();
+typedef /* Complex */ VOID (*C_fp)();
+typedef /* Double Complex */ VOID (*Z_fp)();
+typedef logical (*L_fp)();
+typedef shortlogical (*K_fp)();
+typedef /* Character */ VOID (*H_fp)();
+typedef /* Subroutine */ int (*S_fp)();
+#endif
+/* E_fp is for real functions when -R is not specified */
+typedef VOID C_f;	/* complex function */
+typedef VOID H_f;	/* character function */
+typedef VOID Z_f;	/* double complex function */
+typedef doublereal E_f;	/* real function with -R not specified */
+
+/* undef any lower-case symbols that your C compiler predefines, e.g.: */
+
+#ifndef Skip_f2c_Undefs
+#undef cray
+#undef gcos
+#undef mc68010
+#undef mc68020
+#undef mips
+#undef pdp11
+#undef sgi
+#undef sparc
+#undef sun
+#undef sun2
+#undef sun3
+#undef sun4
+#undef u370
+#undef u3b
+#undef u3b2
+#undef u3b5
+#undef unix
+#undef vax
+#endif
+#endif
diff --git a/tests/linalg/external/lsame.c b/tests/linalg/external/lsame.c
new file mode 100644
index 000000000..00768b59e
--- /dev/null
+++ b/tests/linalg/external/lsame.c
@@ -0,0 +1,109 @@
+/*  -- translated by f2c (version 19940927).
+   You must link the resulting object file with the libraries:
+	-lf2c -lm   (in that order)
+*/
+
+#include "f2c.h"
+
+logical lsame_(char *ca, char *cb)
+{
+
+
+    /* System generated locals */
+    logical ret_val;
+
+    /* Local variables */
+    static integer inta, intb, zcode;
+
+
+/*  -- LAPACK auxiliary routine (version 2.0) --   
+       Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,   
+       Courant Institute, Argonne National Lab, and Rice University   
+       January 31, 1994   
+
+
+    Purpose   
+    =======   
+
+    LSAME returns .TRUE. if CA is the same letter as CB regardless of   
+    case.   
+
+    Arguments   
+    =========   
+
+    CA      (input) CHARACTER*1   
+    CB      (input) CHARACTER*1   
+            CA and CB specify the single characters to be compared.   
+
+   ===================================================================== 
+  
+
+
+       Test if the characters are equal */
+
+    ret_val = *(unsigned char *)ca == *(unsigned char *)cb;
+    if (ret_val) {
+	return ret_val;
+    }
+
+/*     Now test for equivalence if both characters are alphabetic. */
+
+    zcode = 'Z';
+
+/*     Use 'Z' rather than 'A' so that ASCII can be detected on Prime   
+       machines, on which ICHAR returns a value with bit 8 set.   
+       ICHAR('A') on Prime machines returns 193 which is the same as   
+       ICHAR('A') on an EBCDIC machine. */
+
+    inta = *(unsigned char *)ca;
+    intb = *(unsigned char *)cb;
+
+    if (zcode == 90 || zcode == 122) {
+
+/*        ASCII is assumed - ZCODE is the ASCII code of either lower o
+r   
+          upper case 'Z'. */
+
+	if (inta >= 97 && inta <= 122) {
+	    inta += -32;
+	}
+	if (intb >= 97 && intb <= 122) {
+	    intb += -32;
+	}
+
+    } else if (zcode == 233 || zcode == 169) {
+
+/*        EBCDIC is assumed - ZCODE is the EBCDIC code of either lower
+ or   
+          upper case 'Z'. */
+
+	if (inta >= 129 && inta <= 137 || inta >= 145 && inta <= 153 || inta 
+		>= 162 && inta <= 169) {
+	    inta += 64;
+	}
+	if (intb >= 129 && intb <= 137 || intb >= 145 && intb <= 153 || intb 
+		>= 162 && intb <= 169) {
+	    intb += 64;
+	}
+
+    } else if (zcode == 218 || zcode == 250) {
+
+/*        ASCII is assumed, on Prime machines - ZCODE is the ASCII cod
+e   
+          plus 128 of either lower or upper case 'Z'. */
+
+	if (inta >= 225 && inta <= 250) {
+	    inta += -32;
+	}
+	if (intb >= 225 && intb <= 250) {
+	    intb += -32;
+	}
+    }
+    ret_val = inta == intb;
+
+/*     RETURN   
+
+       End of LSAME */
+
+    return ret_val;
+} /* lsame_ */
diff --git a/tests/linalg/external/slasr.c b/tests/linalg/external/slasr.c
new file mode 100644
index 000000000..f34fead5c
--- /dev/null
+++ b/tests/linalg/external/slasr.c
@@ -0,0 +1,451 @@
+/* slasr.f -- translated by f2c (version 20061008).
+   You must link the resulting object file with libf2c:
+	on Microsoft Windows system, link with libf2c.lib;
+	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
+	or, if you install libf2c.a in a standard place, with -lf2c -lm
+	-- in that order, at the end of the command line, as in
+		cc *.o -lf2c -lm
+	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
+
+		http://www.netlib.org/f2c/libf2c.zip
+*/
+
+#include "f2c.h"
+
+/* Subroutine */ int slasr_(char *side, char *pivot, char *direct, integer *m, 
+	 integer *n, real *c__, real *s, real *a, integer *lda)
+{
+    /* System generated locals */
+    integer a_dim1, a_offset, i__1, i__2;
+
+    /* Local variables */
+    integer i__, j, info;
+    real temp;
+    extern logical lsame_(char *, char *);
+    real ctemp, stemp;
+    extern /* Subroutine */ int xerbla_(char *, integer *);
+
+
+/*  -- LAPACK auxiliary routine (version 3.2) -- */
+/*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
+/*     November 2006 */
+
+/*     .. Scalar Arguments .. */
+/*     .. */
+/*     .. Array Arguments .. */
+/*     .. */
+
+/*  Purpose */
+/*  ======= */
+
+/*  SLASR applies a sequence of plane rotations to a real matrix A, */
+/*  from either the left or the right. */
+
+/*  When SIDE = 'L', the transformation takes the form */
+
+/*     A := P*A */
+
+/*  and when SIDE = 'R', the transformation takes the form */
+
+/*     A := A*P**T */
+
+/*  where P is an orthogonal matrix consisting of a sequence of z plane */
+/*  rotations, with z = M when SIDE = 'L' and z = N when SIDE = 'R', */
+/*  and P**T is the transpose of P. */
+
+/*  When DIRECT = 'F' (Forward sequence), then */
+
+/*     P = P(z-1) * ... * P(2) * P(1) */
+
+/*  and when DIRECT = 'B' (Backward sequence), then */
+
+/*     P = P(1) * P(2) * ... * P(z-1) */
+
+/*  where P(k) is a plane rotation matrix defined by the 2-by-2 rotation */
+
+/*     R(k) = (  c(k)  s(k) ) */
+/*          = ( -s(k)  c(k) ). */
+
+/*  When PIVOT = 'V' (Variable pivot), the rotation is performed */
+/*  for the plane (k,k+1), i.e., P(k) has the form */
+
+/*     P(k) = (  1                                            ) */
+/*            (       ...                                     ) */
+/*            (              1                                ) */
+/*            (                   c(k)  s(k)                  ) */
+/*            (                  -s(k)  c(k)                  ) */
+/*            (                                1              ) */
+/*            (                                     ...       ) */
+/*            (                                            1  ) */
+
+/*  where R(k) appears as a rank-2 modification to the identity matrix in */
+/*  rows and columns k and k+1. */
+
+/*  When PIVOT = 'T' (Top pivot), the rotation is performed for the */
+/*  plane (1,k+1), so P(k) has the form */
+
+/*     P(k) = (  c(k)                    s(k)                 ) */
+/*            (         1                                     ) */
+/*            (              ...                              ) */
+/*            (                     1                         ) */
+/*            ( -s(k)                    c(k)                 ) */
+/*            (                                 1             ) */
+/*            (                                      ...      ) */
+/*            (                                             1 ) */
+
+/*  where R(k) appears in rows and columns 1 and k+1. */
+
+/*  Similarly, when PIVOT = 'B' (Bottom pivot), the rotation is */
+/*  performed for the plane (k,z), giving P(k) the form */
+
+/*     P(k) = ( 1                                             ) */
+/*            (      ...                                      ) */
+/*            (             1                                 ) */
+/*            (                  c(k)                    s(k) ) */
+/*            (                         1                     ) */
+/*            (                              ...              ) */
+/*            (                                     1         ) */
+/*            (                 -s(k)                    c(k) ) */
+
+/*  where R(k) appears in rows and columns k and z.  The rotations are */
+/*  performed without ever forming P(k) explicitly. */
+
+/*  Arguments */
+/*  ========= */
+
+/*  SIDE    (input) CHARACTER*1 */
+/*          Specifies whether the plane rotation matrix P is applied to */
+/*          A on the left or the right. */
+/*          = 'L':  Left, compute A := P*A */
+/*          = 'R':  Right, compute A:= A*P**T */
+
+/*  PIVOT   (input) CHARACTER*1 */
+/*          Specifies the plane for which P(k) is a plane rotation */
+/*          matrix. */
+/*          = 'V':  Variable pivot, the plane (k,k+1) */
+/*          = 'T':  Top pivot, the plane (1,k+1) */
+/*          = 'B':  Bottom pivot, the plane (k,z) */
+
+/*  DIRECT  (input) CHARACTER*1 */
+/*          Specifies whether P is a forward or backward sequence of */
+/*          plane rotations. */
+/*          = 'F':  Forward, P = P(z-1)*...*P(2)*P(1) */
+/*          = 'B':  Backward, P = P(1)*P(2)*...*P(z-1) */
+
+/*  M       (input) INTEGER */
+/*          The number of rows of the matrix A.  If m <= 1, an immediate */
+/*          return is effected. */
+
+/*  N       (input) INTEGER */
+/*          The number of columns of the matrix A.  If n <= 1, an */
+/*          immediate return is effected. */
+
+/*  C       (input) REAL array, dimension */
+/*                  (M-1) if SIDE = 'L' */
+/*                  (N-1) if SIDE = 'R' */
+/*          The cosines c(k) of the plane rotations. */
+
+/*  S       (input) REAL array, dimension */
+/*                  (M-1) if SIDE = 'L' */
+/*                  (N-1) if SIDE = 'R' */
+/*          The sines s(k) of the plane rotations.  The 2-by-2 plane */
+/*          rotation part of the matrix P(k), R(k), has the form */
+/*          R(k) = (  c(k)  s(k) ) */
+/*                 ( -s(k)  c(k) ). */
+
+/*  A       (input/output) REAL array, dimension (LDA,N) */
+/*          The M-by-N matrix A.  On exit, A is overwritten by P*A if */
+/*          SIDE = 'R' or by A*P**T if SIDE = 'L'. */
+
+/*  LDA     (input) INTEGER */
+/*          The leading dimension of the array A.  LDA >= max(1,M). */
+
+/*  ===================================================================== */
+
+/*     .. Parameters .. */
+/*     .. */
+/*     .. Local Scalars .. */
+/*     .. */
+/*     .. External Functions .. */
+/*     .. */
+/*     .. External Subroutines .. */
+/*     .. */
+/*     .. Intrinsic Functions .. */
+/*     .. */
+/*     .. Executable Statements .. */
+
+/*     Test the input parameters */
+
+    /* Parameter adjustments */
+    --c__;
+    --s;
+    a_dim1 = *lda;
+    a_offset = 1 + a_dim1;
+    a -= a_offset;
+
+    /* Function Body */
+    info = 0;
+    if (! (lsame_(side, "L") || lsame_(side, "R"))) {
+	info = 1;
+    } else if (! (lsame_(pivot, "V") || lsame_(pivot, 
+	    "T") || lsame_(pivot, "B"))) {
+	info = 2;
+    } else if (! (lsame_(direct, "F") || lsame_(direct, 
+	    "B"))) {
+	info = 3;
+    } else if (*m < 0) {
+	info = 4;
+    } else if (*n < 0) {
+	info = 5;
+    } else if (*lda < max(1,*m)) {
+	info = 9;
+    }
+    if (info != 0) {
+	xerbla_("SLASR ", &info);
+	return 0;
+    }
+
+/*     Quick return if possible */
+
+    if (*m == 0 || *n == 0) {
+	return 0;
+    }
+    if (lsame_(side, "L")) {
+
+/*        Form  P * A */
+
+	if (lsame_(pivot, "V")) {
+	    if (lsame_(direct, "F")) {
+		i__1 = *m - 1;
+		for (j = 1; j <= i__1; ++j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1.f || stemp != 0.f) {
+			i__2 = *n;
+			for (i__ = 1; i__ <= i__2; ++i__) {
+			    temp = a[j + 1 + i__ * a_dim1];
+			    a[j + 1 + i__ * a_dim1] = ctemp * temp - stemp * 
+				    a[j + i__ * a_dim1];
+			    a[j + i__ * a_dim1] = stemp * temp + ctemp * a[j 
+				    + i__ * a_dim1];
+/* L10: */
+			}
+		    }
+/* L20: */
+		}
+	    } else if (lsame_(direct, "B")) {
+		for (j = *m - 1; j >= 1; --j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1.f || stemp != 0.f) {
+			i__1 = *n;
+			for (i__ = 1; i__ <= i__1; ++i__) {
+			    temp = a[j + 1 + i__ * a_dim1];
+			    a[j + 1 + i__ * a_dim1] = ctemp * temp - stemp * 
+				    a[j + i__ * a_dim1];
+			    a[j + i__ * a_dim1] = stemp * temp + ctemp * a[j 
+				    + i__ * a_dim1];
+/* L30: */
+			}
+		    }
+/* L40: */
+		}
+	    }
+	} else if (lsame_(pivot, "T")) {
+	    if (lsame_(direct, "F")) {
+		i__1 = *m;
+		for (j = 2; j <= i__1; ++j) {
+		    ctemp = c__[j - 1];
+		    stemp = s[j - 1];
+		    if (ctemp != 1.f || stemp != 0.f) {
+			i__2 = *n;
+			for (i__ = 1; i__ <= i__2; ++i__) {
+			    temp = a[j + i__ * a_dim1];
+			    a[j + i__ * a_dim1] = ctemp * temp - stemp * a[
+				    i__ * a_dim1 + 1];
+			    a[i__ * a_dim1 + 1] = stemp * temp + ctemp * a[
+				    i__ * a_dim1 + 1];
+/* L50: */
+			}
+		    }
+/* L60: */
+		}
+	    } else if (lsame_(direct, "B")) {
+		for (j = *m; j >= 2; --j) {
+		    ctemp = c__[j - 1];
+		    stemp = s[j - 1];
+		    if (ctemp != 1.f || stemp != 0.f) {
+			i__1 = *n;
+			for (i__ = 1; i__ <= i__1; ++i__) {
+			    temp = a[j + i__ * a_dim1];
+			    a[j + i__ * a_dim1] = ctemp * temp - stemp * a[
+				    i__ * a_dim1 + 1];
+			    a[i__ * a_dim1 + 1] = stemp * temp + ctemp * a[
+				    i__ * a_dim1 + 1];
+/* L70: */
+			}
+		    }
+/* L80: */
+		}
+	    }
+	} else if (lsame_(pivot, "B")) {
+	    if (lsame_(direct, "F")) {
+		i__1 = *m - 1;
+    for (j = 1; j <= i__1; ++j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1.f || stemp != 0.f) {
+			i__2 = *n;
+      for (i__ = 1; i__ <= i__2; ++i__) {
+			    temp = a[j + i__ * a_dim1];
+			    a[j + i__ * a_dim1] = stemp * a[*m + i__ * a_dim1]
+				     + ctemp * temp;
+			    a[*m + i__ * a_dim1] = ctemp * a[*m + i__ * 
+				    a_dim1] - stemp * temp;
+/* L90: */
+			}
+		    }
+/* L100: */
+		}
+	    } else if (lsame_(direct, "B")) {
+		for (j = *m - 1; j >= 1; --j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1.f || stemp != 0.f) {
+			i__1 = *n;
+      for (i__ = 1; i__ <= i__1; ++i__) {
+			    temp = a[j + i__ * a_dim1];
+			    a[j + i__ * a_dim1] = stemp * a[*m + i__ * a_dim1]
+				     + ctemp * temp;
+			    a[*m + i__ * a_dim1] = ctemp * a[*m + i__ * 
+				    a_dim1] - stemp * temp;
+/* L110: */
+			}
+		    }
+/* L120: */
+		}
+	    }
+	}
+    } else if (lsame_(side, "R")) {
+
+/*        Form A * P' */
+
+	if (lsame_(pivot, "V")) {
+	    if (lsame_(direct, "F")) {
+		i__1 = *n - 1;
+    for (j = 1; j <= i__1; ++j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1.f || stemp != 0.f) {
+			i__2 = *m;
+      for (i__ = 1; i__ <= i__2; ++i__) {
+          temp = a[i__ + (j + 1) * a_dim1];
+          a[i__ + (j + 1) * a_dim1] = ctemp * temp - stemp *
+             a[i__ + j * a_dim1];
+          a[i__ + j * a_dim1] = stemp * temp + ctemp * a[
+            i__ + j * a_dim1];
+/* L130: */
+			}
+		    }
+/* L140: */
+		}
+	    } else if (lsame_(direct, "B")) {
+		for (j = *n - 1; j >= 1; --j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1.f || stemp != 0.f) {
+			i__1 = *m;
+			for (i__ = 1; i__ <= i__1; ++i__) {
+			    temp = a[i__ + (j + 1) * a_dim1];
+			    a[i__ + (j + 1) * a_dim1] = ctemp * temp - stemp *
+				     a[i__ + j * a_dim1];
+			    a[i__ + j * a_dim1] = stemp * temp + ctemp * a[
+				    i__ + j * a_dim1];
+/* L150: */
+			}
+		    }
+/* L160: */
+		}
+	    }
+	} else if (lsame_(pivot, "T")) {
+	    if (lsame_(direct, "F")) {
+		i__1 = *n;
+		for (j = 2; j <= i__1; ++j) {
+		    ctemp = c__[j - 1];
+		    stemp = s[j - 1];
+		    if (ctemp != 1.f || stemp != 0.f) {
+			i__2 = *m;
+			for (i__ = 1; i__ <= i__2; ++i__) {
+			    temp = a[i__ + j * a_dim1];
+			    a[i__ + j * a_dim1] = ctemp * temp - stemp * a[
+				    i__ + a_dim1];
+			    a[i__ + a_dim1] = stemp * temp + ctemp * a[i__ + 
+				    a_dim1];
+/* L170: */
+			}
+		    }
+/* L180: */
+		}
+	    } else if (lsame_(direct, "B")) {
+		for (j = *n; j >= 2; --j) {
+		    ctemp = c__[j - 1];
+		    stemp = s[j - 1];
+		    if (ctemp != 1.f || stemp != 0.f) {
+			i__1 = *m;
+			for (i__ = 1; i__ <= i__1; ++i__) {
+			    temp = a[i__ + j * a_dim1];
+			    a[i__ + j * a_dim1] = ctemp * temp - stemp * a[
+				    i__ + a_dim1];
+			    a[i__ + a_dim1] = stemp * temp + ctemp * a[i__ + 
+				    a_dim1];
+/* L190: */
+			}
+		    }
+/* L200: */
+		}
+	    }
+	} else if (lsame_(pivot, "B")) {
+	    if (lsame_(direct, "F")) {
+		i__1 = *n - 1;
+		for (j = 1; j <= i__1; ++j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1.f || stemp != 0.f) {
+			i__2 = *m;
+			for (i__ = 1; i__ <= i__2; ++i__) {
+			    temp = a[i__ + j * a_dim1];
+			    a[i__ + j * a_dim1] = stemp * a[i__ + *n * a_dim1]
+				     + ctemp * temp;
+			    a[i__ + *n * a_dim1] = ctemp * a[i__ + *n * 
+				    a_dim1] - stemp * temp;
+/* L210: */
+			}
+		    }
+/* L220: */
+		}
+	    } else if (lsame_(direct, "B")) {
+		for (j = *n - 1; j >= 1; --j) {
+		    ctemp = c__[j];
+		    stemp = s[j];
+		    if (ctemp != 1.f || stemp != 0.f) {
+			i__1 = *m;
+			for (i__ = 1; i__ <= i__1; ++i__) {
+			    temp = a[i__ + j * a_dim1];
+			    a[i__ + j * a_dim1] = stemp * a[i__ + *n * a_dim1]
+				     + ctemp * temp;
+			    a[i__ + *n * a_dim1] = ctemp * a[i__ + *n * 
+				    a_dim1] - stemp * temp;
+/* L230: */
+			}
+		    }
+/* L240: */
+		}
+	    }
+	}
+    }
+
+    return 0;
+
+/*     End of SLASR */
+
+} /* slasr_ */
diff --git a/tests/linalg/external/xerbla.c b/tests/linalg/external/xerbla.c
new file mode 100644
index 000000000..7d602403f
--- /dev/null
+++ b/tests/linalg/external/xerbla.c
@@ -0,0 +1,42 @@
+#include "f2c.h"
+#include <stdio.h>
+
+/* Subroutine */ int xerbla_(char *srname, integer *info)
+{
+/*  -- LAPACK auxiliary routine (version 2.0) --   
+       Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,   
+       Courant Institute, Argonne National Lab, and Rice University   
+       September 30, 1994   
+
+
+    Purpose   
+    =======   
+
+    XERBLA  is an error handler for the LAPACK routines.   
+    It is called by an LAPACK routine if an input parameter has an   
+    invalid value.  A message is printed and execution stops.   
+
+    Installers may consider modifying the STOP statement in order to   
+    call system-specific exception-handling facilities.   
+
+    Arguments   
+    =========   
+
+    SRNAME  (input) CHARACTER*6   
+            The name of the routine which called XERBLA.   
+
+    INFO    (input) INTEGER   
+            The position of the invalid parameter in the parameter list   
+
+            of the calling routine.   
+
+   ===================================================================== 
+*/
+
+    printf("** On entry to %6s, parameter number %2i had an illegal value\n", srname, (int)*info);
+
+/*     End of XERBLA */
+
+    return 0;
+} /* xerbla_ */
+
diff --git a/tests/linalg/gemm.cpp b/tests/linalg/gemm.cpp
index 46a55f305..c13eba8b7 100644
--- a/tests/linalg/gemm.cpp
+++ b/tests/linalg/gemm.cpp
@@ -6,7 +6,7 @@
 namespace sc = isaac;
 
 template<typename T>
-void test_impl(T epsilon, simple_matrix_base<T> & cC, simple_matrix_base<T> const & cA, simple_matrix_base<T> const & cB,
+void test(T epsilon, simple_matrix_base<T> & cC, simple_matrix_base<T> const & cA, simple_matrix_base<T> const & cB,
                           sc::array & C, sc::array const & A, sc::array const & AT,  sc::array const & B, sc::array const & BT,
                           interface_t interf, const char * prefix)
 {
@@ -94,7 +94,7 @@ void test_impl(T epsilon, simple_matrix_base<T> & cC, simple_matrix_base<T> cons
 }
 
 template<typename T>
-void test_impl(T epsilon, sc::driver::Context const & ctx)
+void test(T epsilon, sc::driver::Context const & ctx)
 {
     int_t M = 173;
     int_t N = 241;
@@ -108,16 +108,16 @@ void test_impl(T epsilon, sc::driver::Context const & ctx)
         INIT_MATRIX(M, SUBM, 5, 1, N, SUBN, 7, 1, cC, C, ctx);
         INIT_MATRIX(M, SUBM, 8, 1, K, SUBK, 4, 1, cA, A, ctx);
         INIT_MATRIX(K, SUBK, 9, 1, N, SUBN, 6, 1, cB, B, ctx);
-        test_impl(epsilon, cC_full, cA_full, cB_full, C_full, A_full, AT_full, B_full, BT_full, clBLAS, "BLAS, FULL");
-        test_impl(epsilon, cC_slice, cA_slice, cB_slice, C_slice, A_slice, AT_slice, B_slice, BT_slice, clBLAS, "BLAS, SUB");
+        test(epsilon, cC_full, cA_full, cB_full, C_full, A_full, AT_full, B_full, BT_full, clBLAS, "BLAS, FULL");
+        test(epsilon, cC_slice, cA_slice, cB_slice, C_slice, A_slice, AT_slice, B_slice, BT_slice, clBLAS, "BLAS, SUB");
     }
 
     {
         INIT_MATRIX(M, SUBM, 5, 2, N, SUBN, 7, 3, cC, C, ctx);
         INIT_MATRIX(M, SUBM, 8, 2, K, SUBK, 4, 3, cA, A, ctx);
         INIT_MATRIX(K, SUBK, 9, 4, N, SUBN, 6, 2, cB, B, ctx);
-        test_impl(epsilon, cC_full, cA_full, cB_full, C_full, A_full, AT_full, B_full, BT_full, CPP, "C++, FULL");
-        test_impl(epsilon, cC_slice, cA_slice, cB_slice, C_slice, A_slice, AT_slice, B_slice, BT_slice, CPP, "C++, SUB");
+        test(epsilon, cC_full, cA_full, cB_full, C_full, A_full, AT_full, B_full, BT_full, CPP, "C++, FULL");
+        test(epsilon, cC_slice, cA_slice, cB_slice, C_slice, A_slice, AT_slice, B_slice, BT_slice, CPP, "C++, SUB");
     }
 
 }
@@ -135,11 +135,11 @@ int main()
     std::cout << "Device: " << device.name() << " on " << device.platform().name() << " " << device.platform().version() << std::endl;
     std::cout << "---" << std::endl;
     std::cout << ">> float" << std::endl;
-    test_impl<float>(eps_float, *context);
+    test<float>(eps_float, *context);
     if(device.fp64_support())
     {
         std::cout << ">> double" << std::endl;
-        test_impl<double>(eps_double, *context);
+        test<double>(eps_double, *context);
     }
     std::cout << "---" << std::endl;
   }
diff --git a/tests/linalg/gemv.cpp b/tests/linalg/gemv.cpp
index 057a8970f..374fb8d31 100644
--- a/tests/linalg/gemv.cpp
+++ b/tests/linalg/gemv.cpp
@@ -8,7 +8,7 @@
 namespace sc = isaac;
 
 template<typename T>
-void test_row_wise_reduction(T epsilon, simple_vector_base<T> & cy, simple_matrix_base<T> const & cA, simple_vector_base<T> & cx,
+void test_impl(T epsilon, simple_vector_base<T> & cy, simple_matrix_base<T> const & cA, simple_vector_base<T> & cx,
                                         sc::array & y, sc::array const & A, sc::array & x, interface_t interf, const char * prefix)
 {
   int failure_count = 0;
@@ -25,7 +25,7 @@ void test_row_wise_reduction(T epsilon, simple_vector_base<T> & cy, simple_matri
   sc::driver::CommandQueue queue = sc::driver::backend::queues::get(y.context(),0);
 
   T yi = 0, xi = 0;
-#define TEST_OPERATION(NAME, SIZE1, SIZE2, NEUTRAL, REDUCTION, ASSIGNMENT, GPU_REDUCTION, RES, BUF, CRES)\
+#define RUN_TEST(NAME, SIZE1, SIZE2, NEUTRAL, REDUCTION, ASSIGNMENT, GPU_REDUCTION, RES, BUF, CRES)\
   std::cout << "[" << prefix << "] \t" << NAME "..." << std::flush;\
   for(int i = 0 ; i < SIZE1 ; ++i)\
   {\
@@ -52,37 +52,37 @@ void test_row_wise_reduction(T epsilon, simple_vector_base<T> & cy, simple_matri
       cl_command_queue clqueue = queue.handle().cl();
 
 
-      TEST_OPERATION("GEMV(ROW, NoTrans)", M, N, 0, yi+=cA(i,j)*cx[j], cy[i] = alpha*yi + beta*cy[i],
+      RUN_TEST("GEMV(ROW, NoTrans)", M, N, 0, yi+=cA(i,j)*cx[j], cy[i] = alpha*yi + beta*cy[i],
                      BLAS<T>::F(clblasSgemv, clblasDgemv)(clblasRowMajor, clblasTrans, N, M, alpha, CHANDLE(A), OFF(A), LD(A),
                                 CHANDLE(x), x.start()[0], x.stride()[0], beta, CHANDLE(y), y.start()[0], y.stride()[0],
                                 1, &clqueue, 0, NULL, NULL), y, bufy, cy);
 
-      TEST_OPERATION("GEMV(ROW, Trans)", N, M, 0, xi+=cA(j,i)*cy[j], cx[i] = alpha*xi + beta*cx[i],
+      RUN_TEST("GEMV(ROW, Trans)", N, M, 0, xi+=cA(j,i)*cy[j], cx[i] = alpha*xi + beta*cx[i],
                      BLAS<T>::F(clblasSgemv, clblasDgemv)(clblasRowMajor, clblasNoTrans, N, M, alpha, CHANDLE(A), OFF(A), LD(A),
                                 CHANDLE(y), y.start()[0], y.stride()[0], beta, CHANDLE(x), x.start()[0], x.stride()[0],
                                 1, &clqueue, 0, NULL, NULL), x, bufx, cx);
 
-      TEST_OPERATION("GEMV(COL, NoTrans)", M, N, 0, yi+=cA(i,j)*cx[j], cy[i] = alpha*yi + beta*cy[i],
+      RUN_TEST("GEMV(COL, NoTrans)", M, N, 0, yi+=cA(i,j)*cx[j], cy[i] = alpha*yi + beta*cy[i],
                      BLAS<T>::F(clblasSgemv, clblasDgemv)(clblasColumnMajor, clblasNoTrans, M, N, alpha, CHANDLE(A), OFF(A), LD(A),
                                 CHANDLE(x), x.start()[0], x.stride()[0], beta, CHANDLE(y), y.start()[0], y.stride()[0],
                                 1, &clqueue, 0, NULL, NULL), y, bufy, cy);
 
-      TEST_OPERATION("GEMV(COL, Trans)", N, M, 0, xi+=cA(j,i)*cy[j], cx[i] = alpha*xi + beta*cx[i],
+      RUN_TEST("GEMV(COL, Trans)", N, M, 0, xi+=cA(j,i)*cy[j], cx[i] = alpha*xi + beta*cx[i],
                      BLAS<T>::F(clblasSgemv, clblasDgemv)(clblasColumnMajor, clblasTrans, M, N, alpha, CHANDLE(A), OFF(A), LD(A),
                                 CHANDLE(y), y.start()[0], y.stride()[0], beta, CHANDLE(x), x.start()[0], x.stride()[0],
                                 1, &clqueue, 0, NULL, NULL), x, bufx, cx);
   }
   else
   {
-      TEST_OPERATION("x = dot(A.T, y)", N, M, 0, xi+=cA(j,i)*cy[j], cx[i] = xi, x = dot(trans(A),y), x, bufx, cx);
-      TEST_OPERATION("x = sum(A, 0)", N, M, 0, xi+=cA(j,i), cx[i] = xi, x = sum(A,0), x, bufx, cx);
-      TEST_OPERATION("x = max(A, 0)", N, M, std::numeric_limits<T>::min(), xi=std::max(xi,cA(j,i)), cx[i] = xi, x = max(A,0), x, bufx, cx);
-      TEST_OPERATION("x = min(A, 0)", N, M, std::numeric_limits<T>::max(), xi=std::min(xi,cA(j,i)), cx[i] = xi, x = min(A,0), x, bufx, cx);
+      RUN_TEST("x = dot(A.T, y)", N, M, 0, xi+=cA(j,i)*cy[j], cx[i] = xi, x = dot(trans(A),y), x, bufx, cx);
+      RUN_TEST("x = sum(A, 0)", N, M, 0, xi+=cA(j,i), cx[i] = xi, x = sum(A,0), x, bufx, cx);
+      RUN_TEST("x = max(A, 0)", N, M, std::numeric_limits<T>::min(), xi=std::max(xi,cA(j,i)), cx[i] = xi, x = max(A,0), x, bufx, cx);
+      RUN_TEST("x = min(A, 0)", N, M, std::numeric_limits<T>::max(), xi=std::min(xi,cA(j,i)), cx[i] = xi, x = min(A,0), x, bufx, cx);
 
-      TEST_OPERATION("y = dot(A, x)", M, N, 0, yi+=cA(i,j)*cx[j], cy[i] = yi, y = dot(A,x), y, bufy, cy);
-      TEST_OPERATION("y = sum(A, 1)", M, N, 0, yi+=cA(i,j), cy[i] = yi, y = sum(A,1), y, bufy, cy);
-      TEST_OPERATION("y = max(A, 1)", M, N, std::numeric_limits<T>::min(), yi=std::max(yi,cA(i,j)), cy[i] = yi, y = max(A,1), y, bufy, cy);
-      TEST_OPERATION("y = min(A, 1)", M, N, std::numeric_limits<T>::max(), yi=std::min(yi,cA(i,j)), cy[i] = yi, y = min(A,1), y, bufy, cy);
+      RUN_TEST("y = dot(A, x)", M, N, 0, yi+=cA(i,j)*cx[j], cy[i] = yi, y = dot(A,x), y, bufy, cy);
+      RUN_TEST("y = sum(A, 1)", M, N, 0, yi+=cA(i,j), cy[i] = yi, y = sum(A,1), y, bufy, cy);
+      RUN_TEST("y = max(A, 1)", M, N, std::numeric_limits<T>::min(), yi=std::max(yi,cA(i,j)), cy[i] = yi, y = max(A,1), y, bufy, cy);
+      RUN_TEST("y = min(A, 1)", M, N, std::numeric_limits<T>::max(), yi=std::min(yi,cA(i,j)), cy[i] = yi, y = min(A,1), y, bufy, cy);
   }
 
   if(failure_count>0)
@@ -90,7 +90,7 @@ void test_row_wise_reduction(T epsilon, simple_vector_base<T> & cy, simple_matri
 }
 
 template<typename T>
-void test_impl(T epsilon, sc::driver::Context const & ctx)
+void test(T epsilon, sc::driver::Context const & ctx)
 {
   int_t M = 173;
   int_t N = 241;
@@ -102,13 +102,13 @@ void test_impl(T epsilon, sc::driver::Context const & ctx)
 
   {
       INIT_MATRIX(M, SUBM, 9, 1, N, SUBN, 8, 1, cA, A, ctx);
-      test_row_wise_reduction(epsilon, cy_full, cA_full, cx_full, y_full, A_full, x_full, clBLAS, "BLAS, FULL");
-      test_row_wise_reduction(epsilon, cy_slice, cA_slice, cx_slice, y_slice, A_slice, x_slice, clBLAS, "BLAS, SUB");
+      test_impl(epsilon, cy_full, cA_full, cx_full, y_full, A_full, x_full, clBLAS, "BLAS, FULL");
+      test_impl(epsilon, cy_slice, cA_slice, cx_slice, y_slice, A_slice, x_slice, clBLAS, "BLAS, SUB");
   }
   {
       INIT_MATRIX(M, SUBM, 9, 5, N, SUBN, 8, 4, cA, A, ctx);
-      test_row_wise_reduction(epsilon, cy_full, cA_full, cx_full, y_full, A_full, x_full, CPP, "C++, FULL");
-      test_row_wise_reduction(epsilon, cy_slice, cA_slice, cx_slice, y_slice, A_slice, x_slice, CPP, "C++, SUB");
+      test_impl(epsilon, cy_full, cA_full, cx_full, y_full, A_full, x_full, CPP, "C++, FULL");
+      test_impl(epsilon, cy_slice, cA_slice, cx_slice, y_slice, A_slice, x_slice, CPP, "C++, SUB");
   }
 }
 
@@ -123,11 +123,11 @@ int main()
     std::cout << "Device: " << device.name() << " on " << device.platform().name() << " " << device.platform().version() << std::endl;
     std::cout << "---" << std::endl;
     std::cout << ">> float" << std::endl;
-    test_impl<float>(eps_float, *context);
+    test<float>(eps_float, *context);
     if(device.fp64_support())
     {
         std::cout << ">> double" << std::endl;
-        test_impl<double>(eps_double, *context);
+        test<double>(eps_double, *context);
     }
     std::cout << "---" << std::endl;
   }
diff --git a/tests/linalg/ger.cpp b/tests/linalg/ger.cpp
index b7b1ddd0e..e4977d75f 100644
--- a/tests/linalg/ger.cpp
+++ b/tests/linalg/ger.cpp
@@ -6,7 +6,7 @@ namespace sc = isaac;
 typedef isaac::int_t int_t;
 
 template<typename T>
-void test(T epsilon, simple_matrix_base<T> & cA, simple_matrix_base<T>& cB, simple_matrix_base<T>& cC, simple_vector_base<T>& cx, simple_vector_base<T>& cy,
+void test_impl(T epsilon, simple_matrix_base<T> & cA, simple_matrix_base<T>& cB, simple_matrix_base<T>& cC, simple_vector_base<T>& cx, simple_vector_base<T>& cy,
           sc::array& A, sc::array& B, sc::array& C, sc::array& x, sc::array& y)
 {
   using namespace std;
@@ -100,7 +100,7 @@ void test(T epsilon, simple_matrix_base<T> & cA, simple_matrix_base<T>& cB, simp
 }
 
 template<typename T>
-void test_impl(T epsilon, sc::driver::Context const & ctx)
+void test(T epsilon, sc::driver::Context const & ctx)
 {
   using isaac::_;
 
@@ -115,7 +115,7 @@ void test_impl(T epsilon, sc::driver::Context const & ctx)
   INIT_VECTOR(M, SUBM, 5, 3, cx, x, ctx);
   INIT_VECTOR(N, SUBN, 7, 2, cy, y, ctx);
 #define TEST_OPERATIONS(TYPE)\
-  test(epsilon, cA_ ## TYPE, cB_ ## TYPE, cC_ ## TYPE, cx_ ## TYPE, cy_ ## TYPE, A_ ## TYPE, B_ ## TYPE, C_ ## TYPE, x_ ## TYPE, y_ ## TYPE);\
+  test_impl(epsilon, cA_ ## TYPE, cB_ ## TYPE, cC_ ## TYPE, cx_ ## TYPE, cy_ ## TYPE, A_ ## TYPE, B_ ## TYPE, C_ ## TYPE, x_ ## TYPE, y_ ## TYPE);\
 
   std::cout << "> standard..." << std::endl;
   TEST_OPERATIONS(full);
@@ -133,11 +133,11 @@ int main()
     std::cout << "Device: " << device.name() << " on " << device.platform().name() << " " << device.platform().version() << std::endl;
     std::cout << "---" << std::endl;
     std::cout << ">> float" << std::endl;
-    test_impl<float>(eps_float, *context);
+    test<float>(eps_float, *context);
     if(device.fp64_support())
     {
         std::cout << ">> double" << std::endl;
-        test_impl<double>(eps_double, *context);
+        test<double>(eps_double, *context);
     }
     std::cout << "---" << std::endl;
   }
diff --git a/tests/linalg/gesvd.cpp b/tests/linalg/gesvd.cpp
new file mode 100644
index 000000000..193731f0b
--- /dev/null
+++ b/tests/linalg/gesvd.cpp
@@ -0,0 +1,48 @@
+#include "isaac/symbolic/execute.h"
+#include "isaac/symbolic/io.h"
+
+#include "common.hpp"
+#include "external/f2c.h"
+#include "external/clapack.h"
+
+namespace sc = isaac;
+
+int main()
+{
+  typedef float T;
+  using sc::_i0;
+
+  long int M = 10;
+  long int N = 10;
+  long int SUBM = 7;
+  long int SUBN = 11;
+
+  isaac::driver::Context const & ctx = isaac::driver::backend::contexts::get_default();
+  INIT_MATRIX(M, SUBM, 5, 3, N, SUBN, 7, 2, cA, A, ctx);
+  INIT_VECTOR(N-1, SUBN-1, 5, 3, ccos, cos, ctx);
+  INIT_VECTOR(M-1, SUBM-1, 5, 3, csin, sin, ctx);
+
+  char side = 'R';
+  char pivot = 'V';
+  char direct = 'B';
+  float* pA = cA_full.data().data();
+  float* pcos = ccos_full.data().data();
+  float* psin = csin_full.data().data();
+  long int lda = cA_full.ld();
+
+  std::cout << A_full << std::endl;
+  std::cout << std::endl;
+
+  slasr_(&side, &pivot, &direct, &M, &M, pcos, psin, pA, &lda);
+  sc::math_expression tree = sfor(_i0 = 8, _i0 >= 0, _i0-=1, rot(col(A_full, _i0), col(A_full, _i0 + 1), cos_full[_i0], sin_full[_i0]));
+  std::cout << to_string(tree) << std::endl;
+  sc::execute(tree);
+
+  std::cout << cos_full << std::endl;
+  std::cout << sin_full << std::endl;
+  std::cout << std::endl;
+
+  std::cout << sc::array(M, N, cA_full.data(), ctx) << std::endl;
+  std::cout << std::endl;
+  std::cout << A_full << std::endl;
+}