Index: coeffs/.gdbinit
===================================================================
--- coeffs/.gdbinit	(revision 2b957aaac9e8428774b24a75c7520073a5f4f90d)
+++ coeffs/.gdbinit	(revision 2b957aaac9e8428774b24a75c7520073a5f4f90d)
@@ -0,0 +1,2 @@
+break dErrorBreak
+
Index: coeffs/Makefile.in
===================================================================
--- coeffs/Makefile.in	(revision c3d17527305d0cf9da8226a23b8fc95f6e3f37d0)
+++ coeffs/Makefile.in	(revision 2b957aaac9e8428774b24a75c7520073a5f4f90d)
@@ -35,5 +35,7 @@
 CXXTEMPLFLAGS	= -fno-implicit-templates --no-exceptions
 CPPFLAGS	= -I${srcdir} -I${includedir} -I${srcdir}/../misc/ -I${srcdir}/../resource/ -I${srcdir}/../output/ -L${srcdir}/../output/ -L${libdir} -lgmp
-DEFS		= -DNDEBUG -DOM_NDEBUG -Dix86_Linux -DHAVE_CONFIG_H
+DEFS		= -Dix86_Linux -DHAVE_CONFIG_H -DLDEBUG -DDEBUG -DOM_DEBUG -DHAVE_ASSUME
+
+# -DNDEBUG -DOM_NDEBUG 
 
 ## End configuration dependend stuff
@@ -92,4 +94,4 @@
 	$(INSTALL_DATA) coeffs.h $(includedir)/coeffs.h
 
-test: libcoeffs.a
+test: test.cc libcoeffs.a
 	${CXX} ${CXXFLAGS} ${CXXTEMPLFLAGS} ${CPPFLAGS} ${DEFS} test.cc -L. -I. -lcoeffs -o test -lomalloc -loutput 
Index: coeffs/gnumpc.cc
===================================================================
--- coeffs/gnumpc.cc	(revision c3d17527305d0cf9da8226a23b8fc95f6e3f37d0)
+++ coeffs/gnumpc.cc	(revision 2b957aaac9e8428774b24a75c7520073a5f4f90d)
@@ -375,5 +375,5 @@
 
 
-static BOOLEAN ngcCoeffsEqual(const coeffs r, n_coeffType n, int)
+static BOOLEAN ngcCoeffsEqual(const coeffs r, n_coeffType n, void*)
 {
   assume( getCoeffType(r) == ID );
@@ -382,5 +382,5 @@
 };
 
-void ngcInitChar(coeffs n, int)
+void ngcInitChar(coeffs n, void*)
 {
   assume( getCoeffType(n) == ID );
Index: coeffs/gnumpc.h
===================================================================
--- coeffs/gnumpc.h	(revision c3d17527305d0cf9da8226a23b8fc95f6e3f37d0)
+++ coeffs/gnumpc.h	(revision 2b957aaac9e8428774b24a75c7520073a5f4f90d)
@@ -14,8 +14,8 @@
 
 /// Initialize r
-void ngcInitChar(coeffs r, int);
+void ngcInitChar(coeffs r, void*);
 
 /// test, whether r is an instance of nInitCoeffs(n, parameter) */
-static BOOLEAN ngcCoeffsEqual(const coeffs r, n_coeffType n, int parameter);
+static BOOLEAN ngcCoeffsEqual(const coeffs r, n_coeffType n, void* parameter);
 
 
Index: coeffs/longrat.cc
===================================================================
--- coeffs/longrat.cc	(revision c3d17527305d0cf9da8226a23b8fc95f6e3f37d0)
+++ coeffs/longrat.cc	(revision 2b957aaac9e8428774b24a75c7520073a5f4f90d)
@@ -191,5 +191,5 @@
 
 #ifdef LDEBUG
-BOOLEAN nlDBTest(number a, const char *f,const int l)
+BOOLEAN nlDBTest(number a, const char *f,const int l, const coeffs r)
 {
   if (a==NULL)
@@ -376,5 +376,5 @@
     res=nlShort3(res);
   }
-  nlTest(res);
+  nlTest(res, dst);
   return res;
 }
@@ -476,5 +476,5 @@
 int nlInt(number &i, const coeffs r)
 {
-  nlTest(i);
+  nlTest(i, r);
   nlNormalize(i,r);
   if (SR_HDL(i) &SR_INT) return SR_TO_INT(i);
@@ -505,5 +505,5 @@
 number nlBigInt(number &i, const coeffs r)
 {
-  nlTest(i);
+  nlTest(i, r);
   nlNormalize(i,r);
   if (SR_HDL(i) &SR_INT) return (i);
@@ -523,5 +523,5 @@
 number nlInvers(number a, const coeffs r)
 {
-  nlTest(a);
+  nlTest(a, r);
   number n;
   if (SR_HDL(a) & SR_INT)
@@ -551,5 +551,5 @@
       mpz_init_set_si(n->n,(long)-SR_TO_INT(a));
     }
-    nlTest(n);
+    nlTest(n, r);
     return n;
   }
@@ -592,5 +592,5 @@
     }
   }
-  nlTest(n);
+  nlTest(n, r);
   return n;
 }
@@ -600,5 +600,5 @@
 * u := a / b in Z, if b | a (else undefined)
 */
-number   nlExactDiv(number a, number b)
+number   nlExactDiv(number a, number b, const coeffs r)
 {
   if (b==INT_TO_SR(0))
@@ -644,5 +644,5 @@
   }
   u=nlShort3(u);
-  nlTest(u);
+  nlTest(u, r);
   return u;
 }
@@ -651,5 +651,5 @@
 * u := a / b in Z
 */
-number nlIntDiv (number a, number b)
+number nlIntDiv (number a, number b, const coeffs r)
 {
   if (b==INT_TO_SR(0))
@@ -710,5 +710,5 @@
   }
   u=nlShort3(u);
-  nlTest(u);
+  nlTest(u, r);
   return u;
 }
@@ -794,5 +794,5 @@
   }
   u=nlShort3(u);
-  nlTest(u);
+  nlTest(u, r);
   return u;
 }
@@ -900,5 +900,5 @@
     u=nlShort3(u);
   }
-  nlTest(u);
+  nlTest(u, r);
   return u;
 }
@@ -912,5 +912,5 @@
   if (!nlIsZero(x,r))
   {
-    nlTest(x);
+    nlTest(x, r);
     number aa=NULL;
     if (SR_HDL(x) & SR_INT)
@@ -952,5 +952,5 @@
 #ifdef LDEBUG
   if (exp<0) Print("nlPower: neg. exp. %d\n",exp);
-  nlTest(*u);
+  nlTest(*u, r);
 #endif
 }
@@ -960,7 +960,7 @@
 * za >= 0 ?
 */
-BOOLEAN nlGreaterZero (number a)
-{
-  nlTest(a);
+BOOLEAN nlGreaterZero (number a, const coeffs r)
+{
+  nlTest(a, r);
   if (SR_HDL(a) & SR_INT) return SR_HDL(a)>1L /* represents number(0) */;
   return (!mpz_isNeg(a->z));
@@ -972,6 +972,6 @@
 BOOLEAN nlGreater (number a, number b, const coeffs r)
 {
-  nlTest(a);
-  nlTest(b);
+  nlTest(a, r);
+  nlTest(b, r);
   number re;
   BOOLEAN rr;
@@ -985,9 +985,9 @@
 * a == -1 ?
 */
-BOOLEAN nlIsMOne (number a)
+BOOLEAN nlIsMOne (number a, const coeffs r)
 {
 #ifdef LDEBUG
   if (a==NULL) return FALSE;
-  nlTest(a);
+  nlTest(a, r);
 #endif
   //if (SR_HDL(a) & SR_INT) return (a==INT_TO_SR(-1L));
@@ -1002,6 +1002,6 @@
 {
   number result;
-  nlTest(a);
-  nlTest(b);
+  nlTest(a, r);
+  nlTest(b, r);
   //nlNormalize(a);
   //nlNormalize(b);
@@ -1032,5 +1032,5 @@
     else
      result=INT_TO_SR(i);
-    nlTest(result);
+    nlTest(result,r);
     return result;
   }
@@ -1045,5 +1045,4 @@
     else
      result=INT_TO_SR(t);
-    nlTest(result);
   }
   else
@@ -1056,5 +1055,4 @@
     else
      result=INT_TO_SR(t);
-    nlTest(result);
   }
   else
@@ -1068,6 +1066,6 @@
   #endif
     result=nlShort3(result);
-    nlTest(result);
-  }
+  }
+  nlTest(result, r);
   return result;
 }
@@ -1101,5 +1099,5 @@
   {
     x=nlShort3_noinline(x);
-    nlTest(x);
+    nlTest(x,r);
     return;
   }
@@ -1137,5 +1135,5 @@
     }
   }
-  nlTest(x);
+  nlTest(x, r);
 }
 
@@ -1146,6 +1144,6 @@
 {
   number result;
-  nlTest(a);
-  nlTest(b);
+  nlTest(a, r);
+  nlTest(b, r);
   if ((SR_HDL(b) & SR_INT)
   || (b->s==3))
@@ -1184,5 +1182,5 @@
   mpz_clear(gcd);
   result=nlShort3(result);
-  nlTest(result);
+  nlTest(result, r);
   return result;
 }
@@ -1216,5 +1214,5 @@
 {
   // Hier brauche ich einfach die GMP Zahl
-  nlTest(i);
+  nlTest(i, r);
   nlNormalize(i);
   if (SR_HDL(i) & SR_INT)
@@ -1341,8 +1339,8 @@
 
 // copy not immediate number a
-number _nlCopy_NoImm(number a)
+number _nlCopy_NoImm(number a, const coeffs r)
 {
   assume(!((SR_HDL(a) & SR_INT)||(a==NULL)));
-  nlTest(a);
+  nlTest(a, r);
   number b=ALLOC_RNUMBER();
 #if defined(LDEBUG)
@@ -1359,5 +1357,5 @@
   }
   b->s = a->s;
-  nlTest(b);
+  nlTest(b, r);
   return b;
 }
@@ -1381,5 +1379,5 @@
 }
 
-number _nlNeg_NoImm(number a)
+number _nlNeg_NoImm(number a, const coeffs r)
 {
   {
@@ -1390,9 +1388,9 @@
     }
   }
-  nlTest(a);
+  nlTest(a, r);
   return a;
 }
 
-number _nlAdd_aNoImm_OR_bNoImm(number a, number b)
+number _nlAdd_aNoImm_OR_bNoImm(number a, number b, const coeffs r)
 {
   number u=ALLOC_RNUMBER();
@@ -1557,9 +1555,9 @@
     }
   }
-  nlTest(u);
+  nlTest(u, r);
   return u;
 }
 
-number _nlSub_aNoImm_OR_bNoImm(number a, number b)
+number _nlSub_aNoImm_OR_bNoImm(number a, number b, const coeffs r)
 {
   number u=ALLOC_RNUMBER();
@@ -1781,10 +1779,10 @@
     }
   }
-  nlTest(u);
+  nlTest(u, r);
   return u;
 }
 
 // a and b are intermediate, but a*b not
-number _nlMult_aImm_bImm_rNoImm(number a, number b)
+number _nlMult_aImm_bImm_rNoImm(number a, number b, const coeffs r)
 {
   number u=ALLOC_RNUMBER();
@@ -1795,10 +1793,10 @@
   mpz_init_set_si(u->z,SR_TO_INT(a));
   mpz_mul_si(u->z,u->z,SR_TO_INT(b));
-  nlTest(u);
+  nlTest(u, r);
   return u;
 }
 
 // a or b are not immediate
-number _nlMult_aNoImm_OR_bNoImm(number a, number b)
+number _nlMult_aNoImm_OR_bNoImm(number a, number b, const coeffs r)
 {
   assume(! (SR_HDL(a) & SR_HDL(b) & SR_INT));
@@ -1898,5 +1896,5 @@
     }
   }
-  nlTest(u);
+  nlTest(u, r);
   return u;
 }
@@ -1914,10 +1912,11 @@
     return a;
   }
-  return _nlCopy_NoImm(a);
-}
+  return _nlCopy_NoImm(a, src); // dst?
+}
+
 nMapFunc nlSetMap(const coeffs src, const coeffs dst)
 {
   assume( getCoeffType(dst) == ID );
-  assume( getCoeffType(src) == ID );
+//  assume( getCoeffType(src) == ID );
   
   if (nField_is_Q(src))
@@ -2018,8 +2017,8 @@
 * a = b ?
 */
-LINLINE BOOLEAN nlEqual (number a, number b)
-{
-  nlTest(a);
-  nlTest(b);
+LINLINE BOOLEAN nlEqual (number a, number b, const coeffs r)
+{
+  nlTest(a, r);
+  nlTest(b, r);
 // short - short
   if (SR_HDL(a) & SR_HDL(b) & SR_INT) return a==b;
@@ -2034,5 +2033,5 @@
   if ( ((ii << 3) >> 3) == ii ) n=INT_TO_SR(ii);
   else                          n=nlRInit(ii);
-  nlTest(n);
+  nlTest(n, r);
   return n;
 }
@@ -2042,9 +2041,9 @@
 * a == 1 ?
 */
-LINLINE BOOLEAN nlIsOne (number a)
+LINLINE BOOLEAN nlIsOne (number a, const coeffs r)
 {
 #ifdef LDEBUG
   if (a==NULL) return FALSE;
-  nlTest(a);
+  nlTest(a, r);
 #endif
   return (a==INT_TO_SR(1));
@@ -2066,5 +2065,5 @@
     return a;
   }
-  return _nlCopy_NoImm(a);
+  return _nlCopy_NoImm(a, r);
 }
 
@@ -2077,5 +2076,5 @@
   if (*a!=NULL)
   {
-    nlTest(*a);
+    nlTest(*a, r);
     if ((SR_HDL(*a) & SR_INT)==0)
     {
@@ -2091,5 +2090,5 @@
 LINLINE number nlNeg (number a, const coeffs r)
 {
-  nlTest(a);
+  nlTest(a, r);
   if(SR_HDL(a) &SR_INT)
   {
@@ -2099,5 +2098,5 @@
     return a;
   }
-  return _nlNeg_NoImm(a);
+  return _nlNeg_NoImm(a, r);
 }
 
@@ -2116,5 +2115,5 @@
       return nlRInit(SR_TO_INT(r));
   }
-  return _nlAdd_aNoImm_OR_bNoImm(a, b);
+  return _nlAdd_aNoImm_OR_bNoImm(a, b, r);
 }
 
@@ -2198,5 +2197,5 @@
       }
     }
-    nlTest(u);
+    nlTest(u, r);
     return u;
   }
@@ -2268,5 +2267,5 @@
       }
     }
-    nlTest(a);
+    nlTest(a, r);
     return a;
   }
@@ -2275,7 +2274,6 @@
 LINLINE number nlMult (number a, number b, const coeffs R)
 {
-  nlTest(a);
-  nlTest(b);
-
+  nlTest(a, R);
+  nlTest(b, R);
   if (a==INT_TO_SR(0)) return INT_TO_SR(0);
   if (b==INT_TO_SR(0)) return INT_TO_SR(0);
@@ -2289,7 +2287,7 @@
       return nlRInit(SR_HDL(u)>>2);
     }
-    return _nlMult_aImm_bImm_rNoImm(a, b);
-  }
-  return _nlMult_aNoImm_OR_bNoImm(a, b);
+    return _nlMult_aImm_bImm_rNoImm(a, b, R);
+  }
+  return _nlMult_aNoImm_OR_bNoImm(a, b, R);
 }
 
@@ -2310,5 +2308,5 @@
       return nlRInit(SR_TO_INT(r));
   }
-  return _nlSub_aNoImm_OR_bNoImm(a, b);
+  return _nlSub_aNoImm_OR_bNoImm(a, b, r);
 }
 
@@ -2365,5 +2363,5 @@
   if ((SR_HDL(b)|SR_HDL(a))&SR_INT)
   {
-    number n=nlIntDiv(a,b);
+    number n=nlIntDiv(a,b, r);
     nlDelete(&a,r);
     a=n;
@@ -2464,6 +2462,8 @@
 }
 
-void nlInitChar(coeffs r, int ch)
-{
+void nlInitChar(coeffs r, void* p)
+{
+  const int ch = (int)(long)(p);
+  
   r->cfKillChar=NULL;
   r->cfSetChar=NULL;
@@ -2491,6 +2491,6 @@
   r->cfNeg   = nlNeg;
   r->cfInvers= nlInvers;
-  r->cfCopy  = nl_Copy;
-  r->cfRePart = nl_Copy;
+  r->cfCopy  = nlCopy;
+  r->cfRePart = nlCopy;
   //r->cfImPart = ndReturn0;
   r->cfWrite = nlWrite;
Index: coeffs/longrat.h
===================================================================
--- coeffs/longrat.h	(revision c3d17527305d0cf9da8226a23b8fc95f6e3f37d0)
+++ coeffs/longrat.h	(revision 2b957aaac9e8428774b24a75c7520073a5f4f90d)
@@ -58,5 +58,6 @@
 LINLINE number   nlMult(number a, number b, const coeffs r);
 
-void     nlInitChar(coeffs r, int ch);
+void     nlInitChar(coeffs r, void*);
+static BOOLEAN nlCoeffsEqual(const coeffs r, n_coeffType n, void * parameter);
 
 number   nlInit2 (int i, int j, const coeffs r);
@@ -115,8 +116,8 @@
 
 #ifdef LDEBUG
-#define nlTest(a) nlDBTest(a,__FILE__,__LINE__)
-BOOLEAN nlDBTest(number a, char *f,int l);
+#define nlTest(a, r) nlDBTest(a,__FILE__,__LINE__, r)
+BOOLEAN nlDBTest(number a, char *f,int l, const coeffs r);
 #else
-#define nlTest(a) ((void)0)
+#define nlTest(a, r) ((void)0)
 #endif
 
Index: coeffs/modulop.cc
===================================================================
--- coeffs/modulop.cc	(revision c3d17527305d0cf9da8226a23b8fc95f6e3f37d0)
+++ coeffs/modulop.cc	(revision 2b957aaac9e8428774b24a75c7520073a5f4f90d)
@@ -439,5 +439,5 @@
 
 #ifdef LDEBUG
-BOOLEAN npDBTest (number a, const coeffs r, const char *f, const int l)
+BOOLEAN npDBTest (number a, const char *f, const int l, const coeffs r)
 {
   if (((long)a<0) || ((long)a>r->npPrimeM))
@@ -452,5 +452,7 @@
 number npMap0(number from, const coeffs src, const coeffs dst_r)
 {
-  return npInit(nlModP(from,dst_r->npPrimeM),dst_r);
+  int nlModP(number n, int p, const coeffs r);
+
+  return npInit(nlModP(from, dst_r->npPrimeM, src),dst_r);
 }
 
Index: coeffs/modulop.h
===================================================================
--- coeffs/modulop.h	(revision c3d17527305d0cf9da8226a23b8fc95f6e3f37d0)
+++ coeffs/modulop.h	(revision 2b957aaac9e8428774b24a75c7520073a5f4f90d)
@@ -44,6 +44,6 @@
 const char *  npRead  (const char *s, number *a,const coeffs r);
 #ifdef LDEBUG
-BOOLEAN npDBTest      (number a,const coeffs r, const char *f, const int l);
-#define npTest(A,r)     npDBTest(A,r,__FILE__,__LINE__)
+BOOLEAN npDBTest      (number a, const char *f, const int l, const coeffs r);
+#define npTest(A,r)     npDBTest(A,__FILE__,__LINE__, r)
 #else
 #define npTest(A,r)     (0)
Index: coeffs/mpr_complex.cc
===================================================================
--- coeffs/mpr_complex.cc	(revision c3d17527305d0cf9da8226a23b8fc95f6e3f37d0)
+++ coeffs/mpr_complex.cc	(revision 2b957aaac9e8428774b24a75c7520073a5f4f90d)
@@ -38,6 +38,9 @@
 size_t gmp_output_digits= DEFPREC;
 
-extern int mmInit(void);
-int dummy=mmInit();
+// extern int mmInit(void); // TODO: From Factory???
+//{ return 0; }; // 
+// int dummy=mmInit();
+
+
 static gmp_float *gmpRel=NULL;
 static gmp_float *diff=NULL;
Index: coeffs/numbers.cc
===================================================================
--- coeffs/numbers.cc	(revision c3d17527305d0cf9da8226a23b8fc95f6e3f37d0)
+++ coeffs/numbers.cc	(revision 2b957aaac9e8428774b24a75c7520073a5f4f90d)
@@ -60,5 +60,5 @@
 #ifdef LDEBUG
 void   nDBDummy1(number* d,char *f, int l) { *d=NULL; }
-BOOLEAN ndDBTest(number a, const char *f, const int l)
+BOOLEAN ndDBTest(number a, const char *f, const int l, const coeffs r)
 {
   return TRUE;
Index: coeffs/numbers.h
===================================================================
--- coeffs/numbers.h	(revision c3d17527305d0cf9da8226a23b8fc95f6e3f37d0)
+++ coeffs/numbers.h	(revision 2b957aaac9e8428774b24a75c7520073a5f4f90d)
@@ -32,4 +32,5 @@
 #ifdef LDEBUG
 void nDBDummy1(number* d,char *f, int l);
+BOOLEAN ndDBTest(number a, const char *f, const int l, const coeffs r);
 #endif
 
Index: coeffs/shortfl.cc
===================================================================
--- coeffs/shortfl.cc	(revision c3d17527305d0cf9da8226a23b8fc95f6e3f37d0)
+++ coeffs/shortfl.cc	(revision 2b957aaac9e8428774b24a75c7520073a5f4f90d)
@@ -353,5 +353,5 @@
 * test valid numbers: not implemented yet
 */
-BOOLEAN  nrDBTest(number a, const char *f, const int l, const coeffs r);
+BOOLEAN  nrDBTest(number a, const char *f, const int l, const coeffs r)
 {
   assume( getCoeffType(r) == ID );
@@ -538,5 +538,5 @@
 
 /// test, whether r is an instance of nInitCoeffs(n, parameter) */
-static BOOLEAN nrCoeffsEqual(const coeffs r, n_coeffType n, int parameter)
+static BOOLEAN nrCoeffsEqual(const coeffs r, n_coeffType n, void* parameter)
 {
   assume( getCoeffType(r) == ID );
@@ -547,5 +547,5 @@
 
 
-void nrInitChar(coeffs n, int)
+void nrInitChar(coeffs n, void*)
 {
   assume( getCoeffType(n) == ID );
Index: coeffs/shortfl.h
===================================================================
--- coeffs/shortfl.h	(revision c3d17527305d0cf9da8226a23b8fc95f6e3f37d0)
+++ coeffs/shortfl.h	(revision 2b957aaac9e8428774b24a75c7520073a5f4f90d)
@@ -15,11 +15,11 @@
 
 /// Initialize r
-void nrInitChar(coeffs r, int);
+void nrInitChar(coeffs r, void*);
 
 /// test, whether r is an instance of nInitCoeffs(n, parameter) */
-static BOOLEAN nrCoeffsEqual(const coeffs r, n_coeffType n, int parameter);
+static BOOLEAN nrCoeffsEqual(const coeffs r, n_coeffType n, void* parameter);
 
 
-/* // Private interface should be hidden!!!
+// Private interface should be hidden!!!
 
 BOOLEAN nrGreaterZero (number k, const coeffs r);
@@ -43,5 +43,4 @@
 BOOLEAN nrDBTest(number a, const coeffs r, const char *f, const int l);
 #endif
-*/
 
 
Index: coeffs/test.cc
===================================================================
--- coeffs/test.cc	(revision c3d17527305d0cf9da8226a23b8fc95f6e3f37d0)
+++ coeffs/test.cc	(revision 2b957aaac9e8428774b24a75c7520073a5f4f90d)
@@ -8,6 +8,7 @@
 
 
-//#include <longrat.h>
+#include <longrat.h>
 #include <gnumpc.h>
+#include <shortfl.h>
 
 
@@ -18,9 +19,18 @@
 int main()
 {
-  const n_coeffType type = n_long_C; // n_Q;
+  SPrintStart();
+  
+  const n_coeffType type = nRegister( n_Q, nlInitChar); assume( type == n_Q );
+//  const n_coeffType type = nRegister( n_long_C, ngcInitChar); assume( type == n_long_C );
+//  const n_coeffType type = nRegister( n_R, nrInitChar); assume( type == n_R );
+  
 
   const coeffs r = nInitChar( type, NULL );
 
   assume( r != NULL );
+  
+  nSetChar( r );
+
+  assume( getCoeffType(r) == type );
 
   assume( r->cfInit != NULL );
@@ -28,17 +38,13 @@
   assume( r->cfAdd != NULL );
   assume( r->cfDelete != NULL );
-
-  assume( getCoeffType(r) == type );
+  
 
   if( type == n_Q )
   {
-    
-/*
     assume( r->cfInit == nlInit );
     assume( r->cfWrite == nlWrite );
     assume( r->cfAdd == nlAdd );
     assume( r->cfDelete == nlDelete );    
-*/
-    }
+  }
   else if( type == n_long_C )
   {
@@ -48,15 +54,29 @@
     assume( r->cfDelete == ngcDelete );    
   }
+  else if( type == n_R )
+  {
+    assume( r->cfInit == nrInit );
+    assume( r->cfWrite == nrWrite );
+    assume( r->cfAdd == nrAdd );
+//    assume( r->cfDelete == nrDelete ); // No?
+  } else
+  {
+    // ...
+  }
 
 
   
   number a = r->cfInit(666, r); 
+  number b = r->cfAdd( a, a, r);
+
   r->cfWrite( a, r );
-  number b = r->cfAdd( a, a, r);
   r->cfWrite( b, r );
+  
   r->cfDelete( &a, r);
   r->cfDelete( &b, r);
 
-  
+  nKillChar( r );
+
+  cout << "OUTPUT BUFFER: " << SPrintEnd();
   
   return 0;
