--- doc/config.txt.orig	2016-10-14 07:53:33.000000000 -0600

+++ doc/config.txt	2016-10-19 19:06:48.837854327 -0600

@@ -300,6 +300,7 @@ NTL_AVOID_BRANCHING=off

 NTL_GF2X_NOINLINE=off

 NTL_GF2X_ALTCODE=off

 NTL_GF2X_ALTCODE1=off

+NTL_LOADTIME_CPU=off

 GMP_INCDIR=$(GMP_PREFIX)/include

 GMP_LIBDIR=$(GMP_PREFIX)/lib

@@ -597,6 +598,10 @@ NTL_GF2X_ALTCODE1=off

 # Yet another alternative implementation for GF2X multiplication.

+NTL_LOADTIME_CPU=off

+

+# switch to check CPU characteristics at load time and use routines

+# optimized for the executing CPU.

 ########## More GMP Options:

--- include/NTL/config.h.orig	2016-10-14 07:53:33.000000000 -0600

+++ include/NTL/config.h	2016-10-19 19:03:46.635500859 -0600

@@ -475,6 +475,20 @@ using the configure script.

 #endif

+#if 0

+#define NTL_LOADTIME_CPU

+

+/*

+ * With this flag enabled, detect advanced CPU features at load time instead

+ * of at compile time.  This flag is intended for distributions, so that they

+ * can compile for the lowest common denominator CPU, but still support newer

+ * CPUs.

+ *

+ * This flag is useful only on x86_64 platforms with gcc 4.8 or later.

+ */

+

+#endif

+

--- include/NTL/ctools.h.orig	2016-10-14 07:53:32.000000000 -0600

+++ include/NTL/ctools.h	2016-10-19 19:03:46.636500779 -0600

@@ -447,6 +447,136 @@ char *_ntl_make_aligned(char *p, long al

 // and it should also be as big as a cache line

+/* Determine CPU characteristics at runtime */

+#ifdef NTL_LOADTIME_CPU

+#if !defined(__x86_64__)

+#error Runtime CPU support is only available on x86_64.

+#endif

+#ifndef __GNUC__

+#error Runtime CPU support is only available with GCC.

+#endif

+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)

+#error Runtime CPU support is only available with GCC 4.6 or later.

+#endif

+

+#include <cpuid.h>

+#ifndef bit_PCLMUL

+#define bit_PCLMUL	(1 << 1)

+#endif

+#ifndef bit_AVX

+#define bit_AVX		(1 << 28)

+#endif

+#ifndef bit_FMA

+#define bit_FMA		(1 << 12)

+#endif

+#ifndef bit_AVX2

+#define bit_AVX2	(1 << 5)

+#endif

+

+#define BASE_FUNC(type,name) static type name##_base

+#define TARGET_FUNC(arch,suffix,type,name)                              \

+   static type __attribute__((target (arch))) name##_##suffix

+#define PCLMUL_FUNC(type,name) TARGET_FUNC("pclmul",pclmul,type,name)

+#define AVX_FUNC(type,name) TARGET_FUNC("avx,pclmul",avx,type,name)

+#define FMA_FUNC(type,name) TARGET_FUNC("fma,avx,pclmul",fma,type,name)

+#define AVX2_FUNC(type,name) TARGET_FUNC("avx2,fma,avx,pclmul",avx2,type,name)

+#define PCLMUL_RESOLVER(type,name,params)                               \

+   extern "C" {                                                         \

+      static void __attribute__((optimize ("O0")))                      \

+         (*resolve_##name (void))(void) {                               \

+         if (__builtin_expect(have_pclmul, 0) < 0) {                    \

+            unsigned int eax, ebx, ecx, edx;                            \

+            if (__get_cpuid(1, &eax, &ebx, &ecx, &edx)) {               \

+               have_pclmul = ((ecx & bit_PCLMUL) != 0);                 \

+               have_avx = ((ecx & bit_AVX) != 0);                       \

+               have_fma = ((ecx & bit_FMA) != 0);                       \

+            } else {                                                    \

+               have_pclmul = 0;                                         \

+               have_avx = 0;                                            \

+               have_fma = 0;                                            \

+            }                                                           \

+         }                                                              \

+         if (have_avx) return (void (*)(void))&name##_avx;              \

+         if (have_pclmul) return (void (*)(void))&name##_pclmul;        \

+         return (void (*)(void))&name##_base;                           \

+      }                                                                 \

+   }                                                                    \

+   type __attribute__((ifunc ("resolve_" #name))) name params

+#define AVX_RESOLVER(type,name,params)                                  \

+   extern "C" {                                                         \

+      static void __attribute__((optimize ("O0")))                      \

+         (*resolve_##name (void))(void) {                               \

+         if (__builtin_expect(have_pclmul, 0) < 0) {                    \

+            unsigned int eax, ebx, ecx, edx;                            \

+            if (__get_cpuid(1, &eax, &ebx, &ecx, &edx)) {               \

+               have_pclmul = ((ecx & bit_PCLMUL) != 0);                 \

+               have_avx = ((ecx & bit_AVX) != 0);                       \

+               have_fma = ((ecx & bit_FMA) != 0);                       \

+            } else {                                                    \

+               have_pclmul = 0;                                         \

+               have_avx = 0;                                            \

+               have_fma = 0;                                            \

+            }                                                           \

+         }                                                              \

+         return have_avx                                                \

+               ? (void (*)(void))&name##_avx                            \

+               : (void (*)(void))&name##_base;                          \

+      }                                                                 \

+   }                                                                    \

+   type __attribute__((ifunc ("resolve_" #name))) name params

+#define FMA_RESOLVER(type,name,params)                                  \

+   extern "C" {                                                         \

+      static void __attribute__((optimize ("O0")))                      \

+         (*resolve_##name (void))(void) {                               \

+         if (__builtin_expect(have_pclmul, 0) < 0) {                    \

+            unsigned int eax, ebx, ecx, edx;                            \

+            if (__get_cpuid(1, &eax, &ebx, &ecx, &edx)) {               \

+               have_pclmul = ((ecx & bit_PCLMUL) != 0);                 \

+               have_avx = ((ecx & bit_AVX) != 0);                       \

+               have_fma = ((ecx & bit_FMA) != 0);                       \

+            } else {                                                    \

+               have_pclmul = 0;                                         \

+               have_avx = 0;                                            \

+               have_fma = 0;                                            \

+            }                                                           \

+         }                                                              \

+         return have_fma                                                \

+               ? (void (*)(void))&name##_fma                            \

+               : (void (*)(void))&name##_avx;                           \

+      }                                                                 \

+   }                                                                    \

+   type __attribute__((ifunc ("resolve_" #name))) name params

+#define AVX2_RESOLVER(type,name,params)                                 \

+   extern "C" {                                                         \

+      static void __attribute__((optimize ("O0")))                      \

+         (*resolve_##name (void))(void) {                               \

+         if (__builtin_expect(have_avx2, 0) < 0) {                      \

+            unsigned int eax, ebx, ecx, edx;                            \

+            if (__get_cpuid(7, &eax, &ebx, &ecx, &edx)) {               \

+               have_avx2 = ((ebx & bit_AVX2) != 0);                     \

+            } else {                                                    \

+               have_avx2 = 0;                                           \

+            }                                                           \

+         }                                                              \

+         if (__builtin_expect(have_pclmul, 0) < 0) {                    \

+            unsigned int eax, ebx, ecx, edx;                            \

+            if (__get_cpuid(1, &eax, &ebx, &ecx, &edx)) {               \

+               have_pclmul = ((ecx & bit_PCLMUL) != 0);                 \

+               have_avx = ((ecx & bit_AVX) != 0);                       \

+               have_fma = ((ecx & bit_FMA) != 0);                       \

+            } else {                                                    \

+               have_pclmul = 0;                                         \

+               have_avx = 0;                                            \

+               have_fma = 0;                                            \

+            }                                                           \

+         }                                                              \

+         return have_avx2                                               \

+               ? (void (*)(void))&name##_avx2                           \

+               : (void (*)(void))&name##_fma;                           \

+      }                                                                 \

+   }                                                                    \

+   type __attribute__((ifunc ("resolve_" #name))) name params

+#endif

 #ifdef NTL_HAVE_BUILTIN_CLZL

--- include/NTL/def_config.h.orig	2016-10-14 07:53:33.000000000 -0600

+++ include/NTL/def_config.h	2016-10-19 19:03:46.637500698 -0600

@@ -475,6 +475,19 @@ using the configure script.

 #endif

+#if 0

+#define NTL_LOADTIME_CPU

+

+/*

+ * With this flag enabled, detect advanced CPU features at load time instead

+ * of at compile time.  This flag is intended for distributions, so that they

+ * can compile for the lowest common denominator CPU, but still support newer

+ * CPUs.

+ *

+ * This flag is useful only on x86_64 platforms with gcc 4.8 or later.

+ */

+

+#endif

--- src/cfile.orig	2016-10-14 07:53:32.000000000 -0600

+++ src/cfile	2016-10-19 19:03:46.637500698 -0600

@@ -475,6 +475,20 @@ using the configure script.

 #endif

+#if @{NTL_LOADTIME_CPU}

+#define NTL_LOADTIME_CPU

+

+/*

+ * With this flag enabled, detect advanced CPU features at load time instead

+ * of at compile time.  This flag is intended for distributions, so that they

+ * can compile for the lowest common denominator CPU, but still support newer

+ * CPUs.

+ *

+ * This flag is useful only on x86_64 platforms with gcc 4.8 or later.

+ */

+

+#endif

+

 @{WIZARD_HACK}

--- src/DispSettings.cpp.orig	2016-10-14 07:53:32.000000000 -0600

+++ src/DispSettings.cpp	2016-10-19 19:03:46.637500698 -0600

@@ -164,6 +164,10 @@ cout << "Performance Options:\n";

    cout << "NTL_GF2X_NOINLINE\n";

 #endif

+#ifdef NTL_LOADTIME_CPU

+   cout << "NTL_LOADTIME_CPU\n";

+#endif

+

    cout << "***************************/\n";

    cout << "\n\n";

--- src/DoConfig.orig	2016-10-14 07:53:32.000000000 -0600

+++ src/DoConfig	2016-10-19 19:09:03.299035983 -0600

@@ -1,7 +1,7 @@

 # This is a perl script, invoked from a shell

 # use warnings;  # this doesn't work on older versions of perl

-

+use Config;

 %MakeFlag = (

@@ -82,6 +82,7 @@

 'NTL_GF2X_NOINLINE'       => 'off',

 'NTL_GF2X_ALTCODE'        => 'off',

 'NTL_GF2X_ALTCODE1'       => 'off',

+'NTL_LOADTIME_CPU'        => 'off',

 );

@@ -191,6 +192,15 @@ if ($ConfigFlag{'NTL_THREAD_BOOST'} eq '

 }

+# special processing: NTL_LOADTIME_CPU on x86/x86_64 only and => NTL_GF2X_NOINLINE

+

+if ($ConfigFlag{'NTL_LOADTIME_CPU'} eq 'on') {

+   if (!$Config{archname} =~ /x86_64/) {

+      die "Error: NTL_LOADTIME_CPU currently only available with x86_64...sorry\n";

+   }

+   $ConfigFlag{'NTL_GF2X_NOINLINE'} = 'on';

+}

+

 # some special MakeVal values that are determined by SHARED

--- src/GF2X1.cpp.orig	2016-10-19 19:03:46.640500457 -0600

+++ src/GF2X1.cpp	2016-10-19 19:10:34.740694338 -0600

@@ -19,7 +19,7 @@

 // simple scaling factor for some crossover points:

 // we use a lower crossover of the underlying multiplication

 // is faster  

-#if (defined(NTL_GF2X_LIB) || defined(NTL_HAVE_PCLMUL))

+#if (defined(NTL_GF2X_LIB) || defined(NTL_HAVE_PCLMUL) || defined(NTL_LOADTIME_CPU))

 #define XOVER_SCALE (1L)

 #else

 #define XOVER_SCALE (2L)

--- src/GF2X.cpp.orig	2016-10-14 07:53:31.000000000 -0600

+++ src/GF2X.cpp	2016-10-19 19:46:20.799482817 -0600

@@ -28,6 +28,22 @@ pclmul_mul1 (unsigned long *c, unsigned

    _mm_storeu_si128((__m128i*)c, _mm_clmulepi64_si128(aa, bb, 0));

 }

+#elif defined (NTL_LOADTIME_CPU)

+

+#include <wmmintrin.h>

+

+static int have_pclmul = -1;

+static int have_avx = -1;

+static int have_fma = -1;

+

+#define NTL_INLINE inline

+

+#define pclmul_mul1(c,a,b) do {                                          \

+   __m128i aa = _mm_setr_epi64( _mm_cvtsi64_m64(a), _mm_cvtsi64_m64(0)); \

+   __m128i bb = _mm_setr_epi64( _mm_cvtsi64_m64(b), _mm_cvtsi64_m64(0)); \

+   _mm_storeu_si128((__m128i*)(c), _mm_clmulepi64_si128(aa, bb, 0));     \

+} while (0)

+

 #else

@@ -576,6 +592,27 @@ void add(GF2X& x, const GF2X& a, const G

+#ifdef NTL_LOADTIME_CPU

+

+BASE_FUNC(void,mul1)(_ntl_ulong *c, _ntl_ulong a, _ntl_ulong b)

+{

+   NTL_EFF_BB_MUL_CODE0

+}

+

+PCLMUL_FUNC(void,mul1)(_ntl_ulong *c, _ntl_ulong a, _ntl_ulong b)

+{

+   pclmul_mul1(c, a, b);

+}

+

+AVX_FUNC(void,mul1)(_ntl_ulong *c, _ntl_ulong a, _ntl_ulong b)

+{

+   pclmul_mul1(c, a, b);

+}

+

+PCLMUL_RESOLVER(static void,mul1,(_ntl_ulong *c, _ntl_ulong a, _ntl_ulong b));

+

+#else

+

 static NTL_INLINE

 void mul1(_ntl_ulong *c, _ntl_ulong a, _ntl_ulong b)

 {

@@ -588,6 +625,7 @@ NTL_EFF_BB_MUL_CODE0

 }

+#endif

 #ifdef NTL_GF2X_NOINLINE

@@ -612,6 +650,51 @@ NTL_EFF_BB_MUL_CODE0

 #endif

+#ifdef NTL_LOADTIME_CPU

+

+BASE_FUNC(void,Mul1)

+(_ntl_ulong *cp, const _ntl_ulong *bp, long sb, _ntl_ulong a)

+{

+   NTL_EFF_BB_MUL_CODE1

+}

+

+PCLMUL_FUNC(void,Mul1)

+(_ntl_ulong *cp, const _ntl_ulong *bp, long sb, _ntl_ulong a)

+{

+   long i;

+   unsigned long carry, prod[2];

+

+   carry = 0;

+   for (i = 0; i < sb; i++) {

+      pclmul_mul1(prod, bp[i], a);

+      cp[i] = carry ^ prod[0];

+      carry = prod[1];

+   }

+

+   cp[sb] = carry;

+}

+

+AVX_FUNC(void,Mul1)

+(_ntl_ulong *cp, const _ntl_ulong *bp, long sb, _ntl_ulong a)

+{

+   long i;

+   unsigned long carry, prod[2];

+

+   carry = 0;

+   for (i = 0; i < sb; i++) {

+      pclmul_mul1(prod, bp[i], a);

+      cp[i] = carry ^ prod[0];

+      carry = prod[1];

+   }

+

+   cp[sb] = carry;

+}

+

+PCLMUL_RESOLVER(static void,Mul1,

+    (_ntl_ulong *cp, const _ntl_ulong *bp, long sb, _ntl_ulong a));

+

+#else

+

 static 

 void Mul1(_ntl_ulong *cp, const _ntl_ulong *bp, long sb, _ntl_ulong a)

 {

@@ -639,6 +722,53 @@ NTL_EFF_BB_MUL_CODE1

 }

+#endif

+

+#ifdef NTL_LOADTIME_CPU

+

+BASE_FUNC(void,AddMul1)

+(_ntl_ulong *cp, const _ntl_ulong* bp, long sb, _ntl_ulong a)

+{

+   NTL_EFF_BB_MUL_CODE2

+}

+

+PCLMUL_FUNC(void,AddMul1)

+(_ntl_ulong *cp, const _ntl_ulong* bp, long sb, _ntl_ulong a)

+{

+   long i;

+   unsigned long carry, prod[2];

+

+   carry = 0;

+   for (i = 0; i < sb; i++) {

+      pclmul_mul1(prod, bp[i], a);

+      cp[i] ^= carry ^ prod[0];

+      carry = prod[1];

+   }

+

+   cp[sb] ^= carry;

+}

+

+AVX_FUNC(void,AddMul1)

+(_ntl_ulong *cp, const _ntl_ulong* bp, long sb, _ntl_ulong a)

+{

+   long i;

+   unsigned long carry, prod[2];

+

+   carry = 0;

+   for (i = 0; i < sb; i++) {

+      pclmul_mul1(prod, bp[i], a);

+      cp[i] ^= carry ^ prod[0];

+      carry = prod[1];

+   }

+

+   cp[sb] ^= carry;

+}

+

+PCLMUL_RESOLVER(static void,AddMul1,

+    (_ntl_ulong *cp, const _ntl_ulong* bp, long sb, _ntl_ulong a));

+

+#else

+

 static 

 void AddMul1(_ntl_ulong *cp, const _ntl_ulong* bp, long sb, _ntl_ulong a)

 {

@@ -667,6 +797,52 @@ NTL_EFF_BB_MUL_CODE2

 }

+#endif

+

+#ifdef NTL_LOADTIME_CPU

+

+BASE_FUNC(void,Mul1_short)

+(_ntl_ulong *cp, const _ntl_ulong *bp, long sb, _ntl_ulong a)

+{

+   NTL_EFF_SHORT_BB_MUL_CODE1

+}

+

+PCLMUL_FUNC(void,Mul1_short)

+(_ntl_ulong *cp, const _ntl_ulong *bp, long sb, _ntl_ulong a)

+{

+   long i;

+   unsigned long carry, prod[2];

+

+   carry = 0;

+   for (i = 0; i < sb; i++) {

+      pclmul_mul1(prod, bp[i], a);

+      cp[i] = carry ^ prod[0];

+      carry = prod[1];

+   }

+

+   cp[sb] = carry;

+}

+

+AVX_FUNC(void,Mul1_short)

+(_ntl_ulong *cp, const _ntl_ulong *bp, long sb, _ntl_ulong a)

+{

+   long i;

+   unsigned long carry, prod[2];

+

+   carry = 0;

+   for (i = 0; i < sb; i++) {

+      pclmul_mul1(prod, bp[i], a);

+      cp[i] = carry ^ prod[0];

+      carry = prod[1];

+   }

+

+   cp[sb] = carry;

+}

+

+PCLMUL_RESOLVER(static void,Mul1_short,

+    (_ntl_ulong *cp, const _ntl_ulong *bp, long sb, _ntl_ulong a));

+

+#else

 static 

 void Mul1_short(_ntl_ulong *cp, const _ntl_ulong *bp, long sb, _ntl_ulong a)

@@ -695,10 +871,31 @@ NTL_EFF_SHORT_BB_MUL_CODE1

 }

+#endif

+#ifdef NTL_LOADTIME_CPU

+BASE_FUNC(void,mul_half)(_ntl_ulong *c, _ntl_ulong a, _ntl_ulong b)

+{

+   NTL_EFF_HALF_BB_MUL_CODE0

+}

+

+PCLMUL_FUNC(void,mul_half)(_ntl_ulong *c, _ntl_ulong a, _ntl_ulong b)

+{

+   pclmul_mul1(c, a, b);

+}

+ 

+AVX_FUNC(void,mul_half)(_ntl_ulong *c, _ntl_ulong a, _ntl_ulong b)

+{

+   pclmul_mul1(c, a, b);

+}

+ 

+PCLMUL_RESOLVER(static void,mul_half,(_ntl_ulong *c, _ntl_ulong a, _ntl_ulong b));

+ 

+#else

+ 

 static 

 void mul_half(_ntl_ulong *c, _ntl_ulong a, _ntl_ulong b)

 {

@@ -712,6 +909,7 @@ NTL_EFF_HALF_BB_MUL_CODE0

 }

+#endif

 // mul2...mul8 hard-code 2x2...8x8 word multiplies.

 // I adapted these routines from LiDIA (except mul3, see below).

@@ -1623,6 +1821,77 @@ static const _ntl_ulong sqrtab[256] = {

+#ifdef NTL_LOADTIME_CPU

+

+BASE_FUNC(void,sqr)(GF2X& c, const GF2X& a)

+{

+   long sa = a.xrep.length();

+   if (sa <= 0) {

+      clear(c);

+      return;

+   }

+

+   c.xrep.SetLength(sa << 1);

+   _ntl_ulong *cp = c.xrep.elts();

+   const _ntl_ulong *ap = a.xrep.elts();

+

+   for (long i = sa-1; i >= 0; i--) {

+      _ntl_ulong *c = cp + (i << 1);

+      _ntl_ulong a = ap[i];

+      _ntl_ulong hi, lo;

+

+      NTL_BB_SQR_CODE

+

+      c[0] = lo;

+      c[1] = hi;

+   }

+

+   c.normalize();

+   return;

+}

+

+PCLMUL_FUNC(void,sqr)(GF2X& c, const GF2X& a)

+{

+   long sa = a.xrep.length();

+   if (sa <= 0) {

+      clear(c);

+      return;

+   }

+

+   c.xrep.SetLength(sa << 1);

+   _ntl_ulong *cp = c.xrep.elts();

+   const _ntl_ulong *ap = a.xrep.elts();

+

+   for (long i = sa-1; i >= 0; i--)

+      pclmul_mul1 (cp + (i << 1), ap[i], ap[i]);

+

+   c.normalize();

+   return;

+}

+

+AVX_FUNC(void,sqr)(GF2X& c, const GF2X& a)

+{

+   long sa = a.xrep.length();

+   if (sa <= 0) {

+      clear(c);

+      return;

+   }

+

+   c.xrep.SetLength(sa << 1);

+   _ntl_ulong *cp = c.xrep.elts();

+   const _ntl_ulong *ap = a.xrep.elts();

+

+   for (long i = sa-1; i >= 0; i--)

+      pclmul_mul1 (cp + (i << 1), ap[i], ap[i]);

+

+   c.normalize();

+   return;

+}

+

+PCLMUL_RESOLVER(void,sqr,(GF2X& c, const GF2X& a));

+

+#else

+

 static inline

 void sqr1(_ntl_ulong *c, _ntl_ulong a)

 {

@@ -1663,6 +1932,7 @@ void sqr(GF2X& c, const GF2X& a)

    return;

 }

+#endif

 void LeftShift(GF2X& c, const GF2X& a, long n)

--- src/InitSettings.cpp.orig	2016-10-14 07:53:32.000000000 -0600

+++ src/InitSettings.cpp	2016-10-19 19:03:46.643500216 -0600

@@ -148,6 +148,11 @@ int main()

    cout << "NTL_RANGE_CHECK=0\n";

 #endif

+#ifdef NTL_LOADTIME_CPU

+   cout << "NTL_LOADTIME_CPU=1\n";

+#else

+   cout << "NTL_LOADTIME_CPU=0\n";

+#endif

 // the following are not actual config flags, but help

 // in the Wizard logic

--- src/lzz_pX1.cpp.orig	2016-10-14 07:53:32.000000000 -0600

+++ src/lzz_pX1.cpp	2016-10-19 19:03:46.644500136 -0600

@@ -4,6 +4,12 @@

 #ifdef NTL_HAVE_AVX

 #include <immintrin.h>

+#elif defined(NTL_LOADTIME_CPU)

+#include <immintrin.h>

+

+static int have_pclmul = -1;

+static int have_avx = -1;

+static int have_fma = -1;

 #endif

@@ -1076,6 +1082,175 @@ void Comp3Mod(zz_pX& x1, zz_pX& x2, zz_p

+#ifdef NTL_LOADTIME_CPU

+

+BASE_FUNC(void,build)

+(zz_pXAltArgument& altH, const zz_pXArgument& H, const zz_pXModulus& F)

+{

+   altH.orig = &H;

+   altH.mem.kill();

+   altH.row.kill();

+

+   if (H.H.length() < 10 || F.n < 50) { altH.strategy = 0; return; }

+

+   altH.n = F.n;

+   altH.m = H.H.length()-1;

+

+   long p = zz_p::modulus();

+   long n = altH.n;

+   long m = altH.m;

+

+

+   if (cast_unsigned(m) <= (~(0UL))/cast_unsigned(p-1) &&

+       cast_unsigned(m)*cast_unsigned(p-1) <= (~(0UL))/cast_unsigned(p-1)) {

+      altH.strategy = 1;

+      altH.pinv_L = sp_PrepRem(p);

+   }

+   else {

+      altH.strategy = 2;

+      altH.pinv_LL = make_sp_ll_reduce_struct(p);

+   }

+

+

+   if (altH.strategy == 1 || altH.strategy == 2) {

+

+      altH.row.SetLength(n);

+      long **row = altH.row.elts();

+      

+      const long  AllocAmt = 1L << 18;

+   

+      long BlockSize = (AllocAmt + m - 1)/m;

+      long NumBlocks = (n + BlockSize - 1)/BlockSize;

+   

+      altH.mem.SetLength(NumBlocks);

+   

+      for (long i = 0; i < NumBlocks; i++) {

+         long first = i*BlockSize;

+         long last =  min(n, first + BlockSize);

+         altH.mem[i].SetLength((last-first)*m);

+         for (long j = first; j < last; j++) {

+            row[j] = altH.mem[i].elts() + (j-first)*m;

+         }

+      }

+