--- sage-4.8/spkg/build/sage-4.8/c_lib/include/pb_wrap.h.orig	2012-05-04 20:49:12.000000000 +0000
+++ sage-4.8/spkg/build/sage-4.8/c_lib/include/pb_wrap.h	2012-05-04 21:00:16.000000000 +0000
@@ -1,7 +1,9 @@
+#include "cudd.h"
+#include "cuddInt.h"
 #include "polybori.h"
 #include "groebner_alg.h"
 #include "nf.h"
-#include "fglm.h"
+#include "FGLMStrategy.h"
 #include "interpolate.h"
 #include "randomset.h"
 #include "ccobject.h"
--- sage-4.8/spkg/build/sage-4.8/sage/ext/multi_modular.h.orig	2012-05-03 20:49:31.000000000 +0000
+++ sage-4.8/spkg/build/sage-4.8/sage/ext/multi_modular.h	2012-05-03 20:49:45.000000000 +0000
@@ -1,5 +1,5 @@
 /* #define mod_int size_t */
-#define mod_int size_t
+#define mod_int ssize_t
 
 /* This is the largest value we can do arithmetic on without risking overflowing. 
  * It will be optimized to a constant if any optimization is turned on. 
--- sage-4.8/spkg/build/sage-4.8/sage/libs/linbox/fflas.pxd.orig	2012-05-04 20:27:10.000000000 +0000
+++ sage-4.8/spkg/build/sage-4.8/sage/libs/linbox/fflas.pxd	2012-05-04 20:32:15.000000000 +0000
@@ -1,6 +1,6 @@
 from modular cimport ModDoubleField, ModFloatField, ModDoubleFieldElement, ModFloatFieldElement
 
-cdef extern from "linbox/fflas/fflas.h" namespace "std":
+cdef extern from "fflas-ffpack/fflas/fflas.h" namespace "std":
     cdef cppclass vector[T]:
         cppclass iterator:
             T operator*()
@@ -29,16 +29,16 @@ cdef extern from "linbox/fflas/fflas.h"
         size_t size()
         void clear()
 
-cdef extern from "linbox/fflas/fflas.h":
-    ctypedef enum fflas_trans_enum "LinBox::FFLAS::FFLAS_TRANSPOSE":
-        fflas_no_trans  "LinBox::FFLAS::FflasNoTrans"
-        fflas_trans  "LinBox::FFLAS::FflasTrans"
+cdef extern from "fflas-ffpack/fflas/fflas.h":
+    ctypedef enum fflas_trans_enum "FFLAS::FFLAS_TRANSPOSE":
+        fflas_no_trans  "FFLAS::FflasNoTrans"
+        fflas_trans  "FFLAS::FflasTrans"
 
-    ctypedef enum fflas_side_enum "LinBox::FFLAS::FFLAS_SIDE":
-        fflas_right  "LinBox::FFLAS::FflasRight"
+    ctypedef enum fflas_side_enum "FFLAS::FFLAS_SIDE":
+        fflas_right  "FFLAS::FflasRight"
 
     # double
-    void ModDouble_fgemv "LinBox::FFLAS::fgemv" \
+    void ModDouble_fgemv "FFLAS::fgemv" \
             (ModDoubleField F, fflas_trans_enum transA,
                     size_t nrows, size_t ncols,
                     ModDoubleFieldElement alpha, ModDoubleFieldElement* A,
@@ -46,7 +46,7 @@ cdef extern from "linbox/fflas/fflas.h":
                     ModDoubleFieldElement beta, ModDoubleFieldElement* Y,
                     size_t incY)
 
-    ModDoubleFieldElement* ModDouble_fgemm "LinBox::FFLAS::fgemm" \
+    ModDoubleFieldElement* ModDouble_fgemm "FFLAS::fgemm" \
             (ModDoubleField F,
                     fflas_trans_enum transA, fflas_trans_enum transB,
                     size_t nrowsA, size_t ncolsB, size_t ncolsA,
@@ -57,7 +57,7 @@ cdef extern from "linbox/fflas/fflas.h":
 
 
     # float
-    void ModFloat_fgemv "LinBox::FFLAS::fgemv" \
+    void ModFloat_fgemv "FFLAS::fgemv" \
             (ModFloatField F, fflas_trans_enum transA,
                     size_t nrows, size_t ncols,
                     ModFloatFieldElement alpha, ModFloatFieldElement* A,
@@ -65,7 +65,7 @@ cdef extern from "linbox/fflas/fflas.h":
                     ModFloatFieldElement beta, ModFloatFieldElement* Y,
                     size_t incY)
 
-    ModFloatFieldElement* ModFloat_fgemm "LinBox::FFLAS::fgemm" \
+    ModFloatFieldElement* ModFloat_fgemm "FFLAS::fgemm" \
             (ModFloatField F,
                     fflas_trans_enum transA, fflas_trans_enum transB,
                     size_t nrowsA, size_t ncolsB, size_t ncolsA,
@@ -74,72 +74,72 @@ cdef extern from "linbox/fflas/fflas.h":
                     ModFloatFieldElement beta, ModFloatFieldElement* C,
                     size_t C_stride)
 
-cdef extern from "linbox/ffpack/ffpack.h":
+cdef extern from "fflas-ffpack/ffpack/ffpack.h":
     # double
-    bint ModDouble_is_singular "LinBox::FFPACK::IsSingular" (ModDoubleField F,
+    bint ModDouble_is_singular "FFPACK::IsSingular" (ModDoubleField F,
                                                              size_t nrows, size_t ncols, ModDoubleFieldElement* A,
                                                              size_t A_stride)
 
-    ModDoubleFieldElement* ModDouble_invert_in_place "LinBox::FFPACK::Invert"  (ModDoubleField F, size_t order,
+    ModDoubleFieldElement* ModDouble_invert_in_place "FFPACK::Invert"  (ModDoubleField F, size_t order,
                                                                                 ModDoubleFieldElement* A, size_t A_stride, int nullity)
 
-    ModDoubleFieldElement ModDoubleDet "LinBox::FFPACK::Det" (ModDoubleField F,
+    ModDoubleFieldElement ModDoubleDet "FFPACK::Det" (ModDoubleField F,
                                                               size_t nrows, size_t ncols,
                                                               ModDoubleFieldElement* A, size_t A_stride)
 
-    int ModDoubleRank "LinBox::FFPACK::Rank" (ModDoubleField,
+    int ModDoubleRank "FFPACK::Rank" (ModDoubleField,
                                               size_t nrows, size_t ncols,
                                               ModDoubleFieldElement *A, size_t lda)
 
-    size_t ModDouble_echelon "LinBox::FFPACK::ReducedRowEchelonForm" (ModDoubleField F, size_t a, size_t b,
+    size_t ModDouble_echelon "FFPACK::ReducedRowEchelonForm" (ModDoubleField F, size_t a, size_t b,
                                                                       ModDoubleFieldElement* matrix,
                                                                       size_t s, size_t* P, size_t* Q)
     
-    void ModDouble_applyp "LinBox::FFPACK::applyP" (ModDoubleField F,
+    void ModDouble_applyp "FFPACK::applyP" (ModDoubleField F,
                                                     fflas_side_enum s, fflas_trans_enum tr,
                                                     size_t nr, size_t foo, size_t r,
                                                     ModDoubleFieldElement* matrix, size_t nc, size_t* Q)
     
-    void ModDouble_MinPoly "LinBox::FFPACK::MinPoly" ( ModDoubleField F, 
+    void ModDouble_MinPoly "FFPACK::MinPoly" ( ModDoubleField F, 
                                                        vector[ModDoubleFieldElement] minP, size_t N,
                                                        ModDoubleFieldElement* A, size_t lda,
                                                        ModDoubleFieldElement* X, size_t ldx, size_t* P)
 
-    void ModDouble_CharPoly "LinBox::FFPACK::CharPoly" ( ModDoubleField F, 
+    void ModDouble_CharPoly "FFPACK::CharPoly" ( ModDoubleField F, 
                                                          list[vector[ModDoubleFieldElement]] charp, size_t N,
                                                          ModDoubleFieldElement* A, size_t lda)
 
     # float
 
-    bint ModFloat_is_singular "LinBox::FFPACK::IsSingular" (ModFloatField F,
+    bint ModFloat_is_singular "FFPACK::IsSingular" (ModFloatField F,
                                                             size_t nrows, size_t ncols, ModFloatFieldElement* A,
                                                             size_t A_stride)
 
-    ModFloatFieldElement* ModFloat_invert_in_place "LinBox::FFPACK::Invert" (ModFloatField F, size_t order,
+    ModFloatFieldElement* ModFloat_invert_in_place "FFPACK::Invert" (ModFloatField F, size_t order,
                                                                              ModFloatFieldElement* A, size_t A_stride, int nullity)
 
-    ModFloatFieldElement ModFloatDet "LinBox::FFPACK::Det" (ModFloatField F,
+    ModFloatFieldElement ModFloatDet "FFPACK::Det" (ModFloatField F,
                                                             size_t nrows, size_t ncols,
                                                             ModFloatFieldElement* A, size_t A_stride)
 
-    int ModFloatRank "LinBox::FFPACK::Rank" (ModFloatField,
+    int ModFloatRank "FFPACK::Rank" (ModFloatField,
                                              size_t nrows, size_t ncols,
                                              ModFloatFieldElement *A, size_t lda)
 
-    size_t ModFloat_echelon "LinBox::FFPACK::ReducedRowEchelonForm" (ModFloatField F, size_t a, size_t b,
+    size_t ModFloat_echelon "FFPACK::ReducedRowEchelonForm" (ModFloatField F, size_t a, size_t b,
                                                                      ModFloatFieldElement* matrix,
                                                                      size_t s, size_t* P, size_t* Q)
 
-    void ModFloat_applyp "LinBox::FFPACK::applyP" (ModFloatField F,
+    void ModFloat_applyp "FFPACK::applyP" (ModFloatField F,
                                                    fflas_side_enum s, fflas_trans_enum tr,
                                                    size_t nr, size_t foo, size_t r,
                                                    ModFloatFieldElement* matrix, size_t nc, size_t* Q)
 
-    void ModFloat_MinPoly "LinBox::FFPACK::MinPoly" ( ModFloatField F, 
+    void ModFloat_MinPoly "FFPACK::MinPoly" ( ModFloatField F, 
                                                       vector[ModFloatFieldElement] minP, size_t N,
                                                       ModFloatFieldElement* A, size_t lda,
                                                       ModFloatFieldElement* X, size_t ldx, size_t* P)
 
-    void ModFloat_CharPoly "LinBox::FFPACK::CharPoly" ( ModFloatField F, 
+    void ModFloat_CharPoly "FFPACK::CharPoly" ( ModFloatField F, 
                                                         list[vector[ModFloatFieldElement]] charp, size_t N,
                                                         ModFloatFieldElement* A, size_t lda )
--- sage-4.8/spkg/build/sage-4.8/sage/libs/linbox/linbox.pxd.orig	2012-05-03 20:49:31.000000000 +0000
+++ sage-4.8/spkg/build/sage-4.8/sage/libs/linbox/linbox.pxd	2012-05-03 20:49:42.000000000 +0000
@@ -5,15 +5,15 @@ include '../../modules/vector_modn_spars
 from sage.matrix.matrix_integer_dense cimport mod_int
 
 cdef class Linbox_modn_dense:
-    cdef mod_int** matrix
+    cdef mod_int* matrix
     cdef mod_int n
     cdef size_t nrows, ncols
     
-    cdef set(self, mod_int n, mod_int** matrix, size_t nrows, size_t ncols)
+    cdef set(self, mod_int n, mod_int* matrix, size_t nrows, size_t ncols)
     cdef int echelonize(self)
     cdef matrix_matrix_multiply(self,
-                                mod_int **ans,
-                                mod_int **B,
+                                mod_int *ans,
+                                mod_int *B,
                                 size_t B_nr, size_t B_nc)
     cdef unsigned long rank(self) except -1
 
--- sage-4.8/spkg/build/sage-4.8/sage/libs/linbox/linbox.pyx.orig	2012-05-03 20:49:31.000000000 +0000
+++ sage-4.8/spkg/build/sage-4.8/sage/libs/linbox/linbox.pyx	2012-05-03 20:49:41.000000000 +0000
@@ -16,32 +16,31 @@ cdef extern from "linbox/linbox-sage.h":
     void linbox_modn_dense_delete_array(mod_int *f)
 
     int linbox_modn_dense_echelonize(unsigned long modulus,  
-                              mod_int **matrix, size_t nrows, size_t ncols)
-    void linbox_modn_dense_minpoly(unsigned long modulus, mod_int **mp, size_t* degree, size_t n,
-                                   mod_int **matrix, int do_minpoly)
-
-    int  linbox_modn_dense_matrix_matrix_multiply(unsigned long modulus, mod_int **ans,
-                                                  mod_int **A, mod_int **B,
-                                                  size_t A_nr, size_t A_nc,
-                                                  size_t B_nr, size_t B_nc)
+                              mod_int *matrix, size_t nrows, size_t ncols)
+    mod_int *linbox_modn_dense_minpoly(unsigned long modulus, mod_int **mp,
+                                      size_t* degree, size_t n, mod_int *matrix)
+    mod_int *linbox_modn_dense_charpoly(unsigned long modulus, mod_int **mp,
+                                        size_t n, mod_int *matrix)
+    mod_int *linbox_modn_dense_matrix_matrix_multiply(unsigned long modulus, mod_int *ans,
+                                                      mod_int *A, mod_int *B,
+                                                      size_t n, size_t n,
+                                                      size_t k)
 
     int linbox_modn_dense_rank(unsigned long modulus,  
-                               mod_int** matrix, size_t nrows, size_t ncols)
+                               mod_int* matrix, size_t nrows, size_t ncols)
 
-    mod_int linbox_modn_dense_det(mod_int modulus, mod_int** matrix, size_t nrows, size_t ncols)
+    mod_int linbox_modn_dense_det(mod_int modulus, mod_int* matrix, size_t nrows, size_t ncols)
 
 
 cdef class Linbox_modn_dense:
     def __init__(self):
-        self.matrix = <mod_int**> 0
+        self.matrix = <mod_int*> 0
 
     def __dealloc__(self):
         if self.matrix:
-            for i from 0 <= i < self.nrows:
-                sage_free(self.matrix[i])
             sage_free(self.matrix)
             
-    cdef set(self, mod_int n, mod_int** matrix,
+    cdef set(self, mod_int n, mod_int* matrix,
              size_t nrows, size_t ncols):
         self.n = n
         self.nrows = nrows
@@ -70,9 +69,12 @@ cdef class Linbox_modn_dense:
         """
         cdef mod_int *f
         cdef size_t degree
-        linbox_modn_dense_minpoly(self.n, &f, &degree,
-                                  self.nrows, self.matrix,
-                                  minpoly)
+        if minpoly:
+            linbox_modn_dense_minpoly(self.n, &f, &degree,
+                                      self.nrows, self.matrix)
+        else:
+            linbox_modn_dense_charpoly(self.n, &f,
+                                       self.nrows, self.matrix)
         v = []
         cdef Py_ssize_t i
         for i from 0 <= i <= degree:
@@ -81,17 +83,15 @@ cdef class Linbox_modn_dense:
         return v
         
     cdef matrix_matrix_multiply(self,
-                                mod_int **ans,
-                                mod_int **B,
+                                mod_int *ans,
+                                mod_int *B,
                                 size_t B_nr, size_t B_nc):
-        cdef int e
-        e = linbox_modn_dense_matrix_matrix_multiply(self.n, ans,
-                                                     self.matrix,  B,
-                                                     self.nrows, self.ncols,
-                                                     B_nr, B_nc)
-        if e:
+        if self.nrows != B_nc:
             raise RuntimeError, "error doing matrix matrix multiply modn using linbox"
-    
+        linbox_modn_dense_matrix_matrix_multiply(self.n, ans,
+                                                 self.matrix,  B,
+                                                 self.nrows, self.ncols,
+                                                 B_nr)
 
     cdef unsigned long rank(self) except -1:
         cdef unsigned long r
@@ -202,10 +202,7 @@ cdef class Linbox_integer_dense:
         cdef mpz_t* poly
         cdef size_t degree
         verbose("using linbox poly comp")
-        if do_minpoly:
-            linbox_integer_dense_minpoly(&poly, &degree, self.nrows, self.matrix)
-        else:
-            linbox_integer_dense_charpoly(&poly, &degree, self.nrows, self.matrix)
+        linbox_integer_dense_minpoly_hacked(&poly, &degree, self.nrows, self.matrix, do_minpoly)
         verbose("computed poly -- now converting back to Sage")
             
         v = []
--- sage-4.8/spkg/build/sage-4.8/sage/libs/m4ri.pxd.orig	2012-05-04 18:49:33.000000000 +0000
+++ sage-4.8/spkg/build/sage-4.8/sage/libs/m4ri.pxd	2012-05-04 19:15:36.000000000 +0000
@@ -151,25 +151,25 @@ cdef extern from "m4ri/m4ri.h":
     cdef int mzd_echelonize(mzd_t *m, int full)
 
     # matrix inversion using Gray codes
-    cdef mzd_t *mzd_invert_m4ri(mzd_t *m, mzd_t *identity, int k)
+    cdef mzd_t *mzd_inv_m4ri(mzd_t *m, mzd_t *identity, int k)
 
     # asymptotically fast PLUQ factorization
     cdef long mzd_pluq(mzd_t *A, mzp_t *P, mzp_t *Q, int cutoff)
 
     # PLUQ factorization using Gray codes
-    cdef long _mzd_pluq_mmpf(mzd_t *A, mzp_t *P, mzp_t *Q, int k)
+    cdef long _mzd_pluq_russian(mzd_t *A, mzp_t *P, mzp_t *Q, int k)
 
     # cubic PLUQ factorization
     cdef long _mzd_pluq_naive(mzd_t *A, mzp_t *P, mzp_t *Q)
 
     # asymptotically fast PLS factorization
-    cdef long mzd_pls(mzd_t *A, mzp_t *P, mzp_t *Q, int cutoff)
+    cdef long mzd_ple(mzd_t *A, mzp_t *P, mzp_t *Q, int cutoff)
 
     # PLS factorization using Gray codes
-    cdef long _mzd_pls_mmpf(mzd_t *A, mzp_t *P, mzp_t *Q, int k)
+    cdef long _mzd_ple_russian(mzd_t *A, mzp_t *P, mzp_t *Q, int k)
 
     # cubic PLS factorization
-    cdef long _mzd_pls_naive(mzd_t *A, mzp_t *P, mzp_t *Q)
+    cdef long _mzd_ple_naive(mzd_t *A, mzp_t *P, mzp_t *Q)
 
     # reduced row echelon form using PLUQ factorization
     cdef long mzd_echelonize_pluq(mzd_t *A, int full)
--- sage-4.8/spkg/build/sage-4.8/sage/libs/m4rie.pxd.orig	2012-05-04 19:45:23.000000000 +0000
+++ sage-4.8/spkg/build/sage-4.8/sage/libs/m4rie.pxd	2012-05-04 19:48:20.000000000 +0000
@@ -87,7 +87,7 @@ cdef extern from "m4rie/m4rie.h":
 
     void mzed_print(const_mzed_t *M)
  
-    mzed_t *mzed_invert_travolta(mzed_t *A, mzed_t *B)
+    mzed_t *mzed_invert_newton_john(mzed_t *A, mzed_t *B)
 
     # TODO: not implemented yet in m4rie
     double mzed_density(mzed_t *A, int res)
@@ -96,9 +96,9 @@ cdef extern from "m4rie/m4rie.h":
     double _mzed_density(mzed_t *A, int res, size_t r, size_t c)
 
 #cdef extern from "m4rie/travolta.h":
-    size_t mzed_echelonize_travolta(mzed_t *, size_t)
+    size_t mzed_echelonize_newton_john(mzed_t *, size_t)
 
-    mzed_t *mzed_mul_travolta(mzed_t *, mzed_t *, mzed_t *)
+    mzed_t *mzed_mul_newton_john(mzed_t *, mzed_t *, mzed_t *)
 
 #cdef extern from "m4rie/echelonform.h":
     size_t mzed_echelonize(mzed_t *, size_t)
--- sage-4.8/spkg/build/sage-4.8/sage/matrix/matrix_integer_dense.pyx.orig	2012-05-03 20:49:31.000000000 +0000
+++ sage-4.8/spkg/build/sage-4.8/sage/matrix/matrix_integer_dense.pyx	2012-05-03 20:49:43.000000000 +0000
@@ -1365,17 +1365,14 @@ cdef class Matrix_integer_dense(matrix_d
         """
         if n > 67108879:   # doesn't work for bigger primes -- experimental observation
             raise NotImplementedError("modulus to big")
-        cdef mod_int** matrix = <mod_int**>sage_malloc(sizeof(mod_int*) * self._nrows)
+        cdef mod_int* matrix = <mod_int*>sage_malloc(sizeof(mod_int) * self._nrows * self._ncols)
         if matrix == NULL:
             raise MemoryError("out of memory allocating multi-modular coefficient list")
         
         cdef Py_ssize_t i, j
         for i from 0 <= i < self._nrows:
-            matrix[i] = <mod_int *>sage_malloc(sizeof(mod_int) * self._ncols)
-            if matrix[i] == NULL:
-                raise MemoryError("out of memory allocating multi-modular coefficient list")
             for j from 0 <= j < self._ncols:
-                matrix[i][j] = mpz_fdiv_ui(self._matrix[i][j], n)
+                matrix[i * self._ncols + j] = mpz_fdiv_ui(self._matrix[i][j], n)
 
         cdef Linbox_modn_dense L = Linbox_modn_dense()
         L.set(n, matrix, self._nrows, self._ncols)
--- sage-4.8/spkg/build/sage-4.8/sage/matrix/matrix_mod2e_dense.pyx.orig	2012-05-04 19:22:35.000000000 +0000
+++ sage-4.8/spkg/build/sage-4.8/sage/matrix/matrix_mod2e_dense.pyx	2012-05-04 19:57:16.000000000 +0000
@@ -516,7 +516,7 @@ cdef class Matrix_mod2e_dense(matrix_den
             return ans
 
         _sig_on
-        ans._entries = mzed_mul_travolta(ans._entries, self._entries, (<Matrix_mod2e_dense>right)._entries)
+        ans._entries = mzed_mul_newton_john(ans._entries, self._entries, (<Matrix_mod2e_dense>right)._entries)
         _sig_off
         return ans
 
@@ -942,7 +942,7 @@ cdef class Matrix_mod2e_dense(matrix_den
             
         elif algorithm == 'travolta':
             _sig_on
-            r =  mzed_echelonize_travolta(self._entries, full)
+            r =  mzed_echelonize_newton_john(self._entries, full)
             _sig_off
             
         elif algorithm == 'ple':
@@ -1014,7 +1014,7 @@ cdef class Matrix_mod2e_dense(matrix_den
         A = Matrix_mod2e_dense.__new__(Matrix_mod2e_dense, self._parent, 0, 0, 0)
         
         if self._nrows and self._nrows == self._ncols:
-            mzed_invert_travolta(A._entries, self._entries)
+            mzed_invert_newton_john(A._entries, self._entries)
 
         return A
         
--- sage-4.8/spkg/build/sage-4.8/sage/matrix/matrix_modn_dense.pyx.orig	2012-05-03 20:49:31.000000000 +0000
+++ sage-4.8/spkg/build/sage-4.8/sage/matrix/matrix_modn_dense.pyx	2012-05-03 20:49:44.000000000 +0000
@@ -846,7 +846,7 @@ cdef class Matrix_modn_dense(matrix_dens
         B = right
         self._init_linbox()
         sig_on()
-        linbox.matrix_matrix_multiply(ans._matrix, B._matrix, B._nrows, B._ncols)
+        linbox.matrix_matrix_multiply(ans._entries, B._entries, B._nrows, B._ncols)
         sig_off()
         return ans
     
@@ -1094,7 +1094,7 @@ cdef class Matrix_modn_dense(matrix_dens
 
     cdef _init_linbox(self):
         sig_on()
-        linbox.set(self.p, self._matrix, self._nrows, self._ncols)
+        linbox.set(self.p, self._entries, self._nrows, self._ncols)
         sig_off()
 
     def _echelonize_linbox(self):
--- sage-4.8/spkg/build/sage-4.8/sage/rings/finite_rings/element_givaro.pxd.orig	2012-05-04 20:39:11.000000000 +0000
+++ sage-4.8/spkg/build/sage-4.8/sage/rings/finite_rings/element_givaro.pxd	2012-05-04 20:39:11.000000000 +0000
@@ -8,10 +8,10 @@ cdef extern from "givaro/givconfig.h":
     pass
 
 cdef extern from "givaro/givrandom.h":
-    ctypedef struct GivRandom "GivRandom":
+    ctypedef struct GivRandom "Givaro::GivRandom":
         pass
 
-    GivRandom GivRandomSeeded  "GivRandom"(unsigned long seed)
+    GivRandom GivRandomSeeded  "Givaro::GivRandom"(unsigned long seed)
 
 cdef extern from "givaro/givgfq.h":
     ctypedef struct intvec "std::vector<unsigned int>":
@@ -23,7 +23,7 @@ cdef extern from "givaro/givgfq.h":
 
 cdef extern from "givaro/givgfq.h":
 
-    ctypedef struct GivaroGfq "GFqDom<int>":
+    ctypedef struct GivaroGfq "Givaro::GFqDom<int>":
         #attributes
         unsigned int one
         unsigned int zero
@@ -53,13 +53,13 @@ cdef extern from "givaro/givgfq.h":
         bint (* isOne)(int e)
         bint (* isunit)(int e)
 
-    GivaroGfq *gfq_factorypk "new GFqDom<int>" (unsigned int p, unsigned int k)
+    GivaroGfq *gfq_factorypk "new Givaro::GFqDom<int>" (unsigned int p, unsigned int k)
     # SAGE specific method, not found upstream
-    GivaroGfq *gfq_factorypkp "new GFqDom<int>" (unsigned int p, unsigned int k, intvec poly)
-    GivaroGfq *gfq_factorycopy "new GFqDom<int>"(GivaroGfq orig)
+    GivaroGfq *gfq_factorypkp "new Givaro::GFqDom<int>" (unsigned int p, unsigned int k, intvec poly)
+    GivaroGfq *gfq_factorycopy "new Givaro::GFqDom<int>"(GivaroGfq orig)
     GivaroGfq  gfq_deref "*"(GivaroGfq *orig)
     void delete "delete "(void *o)
-    int gfq_element_factory "GFqDom<int>::Element"()
+    int gfq_element_factory "Givaro::GFqDom<int>::Element"()
 
 cdef class FiniteField_givaroElement(FinitePolyExtElement) #forward declaration
 
