#include <DBRep.hxx>
 #include <DrawTrSurf.hxx>
 #include <stdio.h>
-#endif
-
-#ifdef DEB
 static Standard_Boolean AffichGeom = Standard_False;
 static Standard_Boolean AffichEdge = Standard_False;
 static Standard_Integer NbFACES       = 0;
 static Standard_Integer NbVEVOS       = 0;
 static Standard_Integer NbPROFILS     = 0;
 static Standard_Integer NbEDGES       = 0;
-// POP for NT
-#ifndef WNT
-static char name[100];
-#endif
 #endif
 
 static const Standard_Real BRepFill_Confusion() 
 
 #ifdef DRAW
   if (AffichEdge) {      
+    char name[100];
     sprintf(name,"PROFIL_%d",++NbPROFILS);     
     DBRep::Set(name,Pr);
   }
        
 #ifdef DRAW
        if (AffichEdge) {
+          char name[100];
          sprintf(name,"ARCEDGE_%d_%d_%d",i,vv,Ti);     
          DBRep::Set(name,CurrentEdge);
        }
     }
   }
 
-#ifdef DEB
+#ifdef DRAW
  if (AffichEdge) {
    cout << " End of Construction of edges and vertices on bissectrices"<<endl;
  }
            
 #ifdef DRAW        
            if (AffichEdge) {
+              char name[100];
              sprintf(name,"PAREDGE_%d_%d",++NbEDGES,k);        
              DBRep::Set(name,S.Value(k));
            }
          
 #ifdef DRAW        
          if (AffichEdge) {       
+            char name[100];
            sprintf(name,"PAREDGE_%d_%d",++NbEDGES,k);  
            DBRep::Set(name,S.Value(k));
          }
 #ifdef DRAW  
   if (AffichEdge) {      
     cout <<" End of construction of an elementary volevo."<<endl;          
+    char name[100];
     sprintf(name,"VEVO_%d",++NbVEVOS); 
     DBRep::Set(name,myShape);
   }
       TopTools_DataMapIteratorOfDataMapOfShapeShape it(MapVP);
       Standard_Integer k = 0;
       for (; it.More(); it.Next()) {
+        char name[100];
        sprintf(name,"PARALI_%d",++k);  
        DBRep::Set(name,it.Value());
       }
     
 #ifdef DRAW  
     if (AffichEdge) {    
+      char name[100];
       sprintf(name,"PARALI_%d",++NbVEVOS);     
       DBRep::Set(name,Base);
     }
     BRepSweep_Prism PS(Base,gp_Vec(0,0,Alt2 - Alt1),Standard_False);
 #ifdef DRAW  
     if (AffichEdge) {    
+      char name[100];
       sprintf(name,"PRISM_%d",NbVEVOS);        
       DBRep::Set(name,PS.Shape());
     }
 
 #ifdef DRAW
   if (AffichEdge) {
+    char name[100];
     sprintf(name,"workspine"); 
     DBRep::Set(name,WorkSpine);
   }
 
 #ifdef DRAW
   if (AffichGeom) {
+    char name[100];
     sprintf(name,"EVOLBASE_%d",++NbFACES);
     DBRep::Set(name,SE);
     sprintf(name,"EVOLPROF_%d",NbFACES);
   
 #ifdef DRAW
   if (AffichGeom) {
+    char name[100];
     sprintf(name,"EVOL_%d",++NbFACES);
     DBRep::Set(name,Pipe.Shape());
   }
   
 #ifdef DRAW  
   if (AffichGeom) {
+    char name[100];
     sprintf(name,"EVOLBASE_%d",++NbFACES);
-    char* Temp = name ;
-    DrawTrSurf::Set(Temp,new Geom_Line(AxeRev));
+    DrawTrSurf::Set(name,new Geom_Line(AxeRev));
 //    DrawTrSurf::Set(name,new Geom_Line(AxeRev));
     sprintf(name,"EVOLPROF_%d",NbFACES);
     DBRep::Set(name,GenProf);
 
 #ifdef DRAW
   if (AffichEdge) {
+    char name[100];
     sprintf(name,"movedspine");
     TopoDS_Face SL = mySpine;
     DBRep::Set(name,SL);    
 
 
 #ifdef DRAW
 #include <DrawTrSurf.hxx>
-#endif
-
-#ifdef DEB
 static Standard_Boolean AffichCurve = Standard_False;
 static Standard_Integer NbProj = 1;
 #endif
+
 //POP pour NT
 #include <stdio.h>
 
 
 #ifdef DRAW
     if ( AffichCurve) {
-//POP pour NT
-      //      char name[100];
-      char* name = new char[100];
+      char name[100];
       sprintf(name,"C2_%d",NbProj);
       DrawTrSurf::Set(name,TLine);
       sprintf(name,"C3_%d",NbProj);
 
 #include <DrawTrSurf.hxx>
 #include <DrawTrSurf_Curve2d.hxx>
 #include <DBRep.hxx>
-#endif
-
-#ifdef DEB
 static Standard_Boolean AffichGeom  = Standard_False;
 static Standard_Boolean Affich2d    = Standard_False;
 static Standard_Boolean AffichEdge  = Standard_False;
 static Standard_Integer NbOFFSET    = 0;
 static Standard_Integer NbEDGES     = 0;
 static Standard_Integer NbBISSEC    = 0;
-#ifndef WNT
-static char tname[100];
-static Standard_CString name = tname ;
-#endif
 #endif
 
 //  Modified by Sergey KHROMOV - Thu Nov 16 17:24:39 2000 Begin
       
       if(aSubst.IsCopied(myWorkSpine)) {
         myWorkSpine = TopoDS::Face(aSubst.Copy(myWorkSpine).First());
-        //sprintf(name,"WS1");
-        //DBRep::Set(name,myWorkSpine);
 
         BRepMAT2d_Explorer newExp;
         newExp.Perform(myWorkSpine);
   }
 
 
-#ifdef DEB
+#ifdef DRAW
   if (AffichEdge) {
     cout << " End Construction of geometric primitives "<<endl;
   }
     
 #ifdef DRAW
   if ( AffichGeom) {
+    char name[256];
     sprintf(name,"BISSEC_%d",NbBISSEC++);
     DrawTrSurf::Set(name,Bisec.Value());
   }
     }
   }
   
-#ifdef DEB 
+#ifdef DRAW
   if (AffichEdge) {
     cout << " End Construction of vertices on offsets"<<endl;
   }
 
 #ifdef DRAW
   if ( AffichEdge) {
-    sprintf(name,"WS");
-    DBRep::Set(name,myWorkSpine);
+    DBRep::Set("WS",myWorkSpine);
   }
 #endif
 
 
 #ifdef DRAW
   if ( AffichGeom && !OE.IsNull()) {
+    char name[256];
     sprintf(name,"OFFSET_%d",++NbOFFSET);
     DBRep::Set(name,OE);
   }
 
 #ifdef DRAW  
     if (AffichGeom && !OE.IsNull()) {
+      char name[256];
       sprintf(name,"OFFSET_%d",++NbOFFSET);
       DBRep::Set(name,OE);
       Standard_Real ii = 0;
 
 #ifdef DRAW
     if ( AffichEdge) {
+      char name[256];
       sprintf(name,"TRIMEDGE_%d",NbTRIMEDGES);
       DBRep::Set(name,NewEdge);  
     }
       Handle(Geom_Surface) Surf;  
       Handle(Geom2d_Curve) C;
       BRep_Tool::CurveOnSurface(NewEdge,C,Surf,L,f,l);
+      char name[256];
       sprintf(name,"OFFSET2d_%d",NbTRIMEDGES++);
       Handle(Geom2d_TrimmedCurve) C2d = new Geom2d_TrimmedCurve(C,f,l);
       Handle(DrawTrSurf_Curve2d) dr =
 
 #include <BRep_CurveRepresentation.hxx>
 #include <BRep_GCurve.hxx>
 
-#ifdef DRAW 
-#include <DBRep.hxx>
-#endif
-#ifdef DEB
-#ifndef WNT
-extern Standard_Integer AffichInt2d;
-#else
-Standard_IMPORT Standard_Boolean AffichInt2d;
-#endif
-static Standard_Integer NbF2d = 0;
-static Standard_Integer NbE2d = 0;
-static Standard_Integer NbNewVertices  = 0;
-#endif
-
 #include <Geom_Line.hxx>
 #include <Geom_TrimmedCurve.hxx>
 #include <GeomConvert_CompCurveToBSplineCurve.hxx>
 #include <BndLib_Add3dCurve.hxx>
 #include <BRepTools.hxx>
 
+#ifdef DRAW 
+#include <DBRep.hxx>
+Standard_IMPORT extern Standard_Boolean AffichInt2d;
+static Standard_Integer NbF2d = 0;
+static Standard_Integer NbE2d = 0;
+static Standard_Integer NbNewVertices  = 0;
+#endif
 
 //=======================================================================
 //function : CommonVertex
 #ifdef DRAW
    if (AffichInt2d) {    
      if (!OnE1 && !OnE2) {
-       //POP pour NT
-       char* name = new char[100];
+       char name[256];
        sprintf(name,"VV_%d",NbNewVertices++);  
        DBRep::Set(name,V);
      }
 {
 #ifdef DRAW
   if (AffichInt2d) {
-    //POP pour NT
-    char* name = new char[100];
+    char name[256];
     sprintf(name,"E2d_%d_%d",NbF2d,NbE2d++);
     DBRep::Set(name,E1);
     sprintf(name,"E2d_%d_%d",NbF2d,NbE2d++);
 {
 #ifdef DRAW
   if (AffichInt2d) {
-    //POP for NT
-    char* name = new char[100];
+    char name[256];
     sprintf(name,"E2d_%d_%d",NbF2d,NbE2d++);
     DBRep::Set(name,E1);
     sprintf(name,"E2d_%d_%d",NbF2d,NbE2d++);
                                  const TopTools_IndexedMapOfShape& NewEdges,
                                  const Standard_Real               Tol)
 {
-#ifdef DEB
+#ifdef DRAW
   NbF2d++;
   NbE2d = 0;
 #endif 
 
 
 #ifdef DRAW
 #include <DBRep.hxx>
-#endif
-#ifdef DEB
 Standard_Integer NbF = 1;
 static Standard_Boolean Affich = Standard_False;
-//POP pour NT
-//char name[100];
 #endif
 
-
 BRepOffset_MakeLoops::BRepOffset_MakeLoops()
 {
 }
       }
       if (ToRebuild) {
 #ifdef DRAW
-//POP for NT
        if ( Affich) {
-         char* name = new char[100];
+         char name[256];
          sprintf(name,"CF_%d",NbF++);
          DBRep::Set(name,F);
        }
 
 
 #ifdef DRAW
 #include <DBRep.hxx>
-#endif
-
-#ifdef DEB       
 Standard_Boolean AffichInter  = Standard_False;
-static Standard_Boolean AffichExtent = Standard_False;
 static Standard_Integer NbNewEdges  = 1;
 static Standard_Integer NbFaces     = 1;
 static Standard_Integer NbFOB       = 1;
 static Standard_Integer NbFTE       = 1;
 static Standard_Integer NbExtE      = 1;
-//POP pour NT
-//char* name = new char[100];
 #endif
 
+#ifdef DEB
+static Standard_Boolean AffichExtent = Standard_False;
+#endif
 
 //=======================================================================
 //function : EdgeVertices
 { 
 #ifdef DRAW
   if (AffichInter) {
-    // POP pour NT
-    char* name = new char[100];
+    char name[256];
     sprintf(name,"FF_%d",NbFaces++);
     DBRep::Set(name,F1);
     sprintf(name,"FF_%d",NbFaces++);
       L2.Append (E.Oriented(O2));
 #ifdef DRAW
       if (AffichInter) {
-    // POP pour NT
-       char* name = new char[100];
+        char name[256];
        sprintf(name,"EI_%d",NbNewEdges++);     
        DBRep::Set(name,E.Oriented(O1));
       }
 {
 #ifdef DRAW
   if (AffichInter) {
-    // POP pour NT
-    char* name = new char[100];
+    char name[256];
     sprintf(name,"FF_%d",NbFaces++);
     DBRep::Set(name,F1);
     sprintf(name,"FF_%d",NbFaces++);
         
 #ifdef DRAW
         if (AffichInter) {
-          char* name = new char[100];
+         char name[256];
           sprintf(name,"EI_%d",NbNewEdges++);  
           DBRep::Set(name,anEdge.Oriented(O1));
          
 {
 #ifdef DRAW
   if (AffichInter) {
-    // POP pour NT
-    char* name = new char[100];
+    char name[256];
     sprintf(name,"FF_%d",NbFaces++);
     DBRep::Set(name,F1);
     sprintf(name,"FF_%d",NbFaces++);
       LInt2.Append (CurE.Oriented(O2));
 #ifdef DRAW
       if (AffichInter) {
-    // POP pour NT
-       char* name = new char[100];
-       sprintf(name,"EI_%d",NbNewEdges++);     
+        char name[256];
+        sprintf(name,"EI_%d",NbNewEdges++);    
        DBRep::Set(name,CurE.Oriented(O1));
       }
 #endif      
 {
 #ifdef DRAW
   if (AffichInter) {
-    // POP pour NT
-    char* name = new char[100];
+    char name[256];
     sprintf(name,"FF_%d",NbFaces++);
     DBRep::Set(name,F1);
     sprintf(name,"FF_%d",NbFaces++);
       L2.Append (E.Oriented(O2));
 #ifdef DRAW
       if (AffichInter) {
-    // POP pour NT
-    char* name = new char[100];
+        char name[256];
        sprintf(name,"EI_%d",NbNewEdges++);     
        DBRep::Set(name,E.Oriented(O1));
       }
   NE.Orientation(E.Orientation());
 #ifdef DRAW
   if (AffichExtent) {
-    char* name = new char[100];
+    char name[256];
     sprintf (name,"F_%d",NbExtE);
     DBRep::Set(name,EF);
     sprintf (name,"OE_%d",NbExtE);
 {
 #ifdef DRAW
   if (AffichInter) {
-    // POP pour NT
-    char* name = new char[100];
+    char name[256];
     sprintf(name,"FTE_%d",NbFTE++);
     DBRep::Set(name,F);
   }
   
 #ifdef DRAW
   if (AffichInter) {
-    // POP pour NT
-    char* name = new char[100];
+    char name[256];
     sprintf(name,"FOB_%d",NbFOB++);
     DBRep::Set(name,NF);
   }
 
 #include <Draw_Appli.hxx>
 #include <DrawTrSurf_Curve2d.hxx>
 #include <Draw_Marker2D.hxx>
-#endif
-#ifdef DEB
 static Standard_Boolean Affich = Standard_False;
 #endif
 
 
        Arrive = Standard_True;
       }
       break;
-#ifndef DEB
+
     default:
       break;
-#endif
     }
     if (Arrive) {
       if (sens > 0.) {
 
       Standard_OutOfRange::Raise();
     }
   }
-#if defined (WNT) || !defined (DEB)
  return *(  ( Handle_Expr_GeneralExpression* )NULL  );
-#endif  // WNT || !DEB
 }
 
 Standard_Boolean Expr_BinaryExpression::ContainsUnknowns () const
 
       case GeomAbs_BSplineSurface:
       case GeomAbs_SurfaceOfRevolution:
       case GeomAbs_SurfaceOfExtrusion:
+      case GeomAbs_OffsetSurface:
       case GeomAbs_OtherSurface:
        {
          Standard_Real cfirst = myucinf, clast = myucsup;
          if(Precision::IsInfinite(Abs(cfirst)) || Precision::IsInfinite(Abs(clast))) {
 
            Bnd_Box aSurfBox;
-      BndLib_AddSurface::Add(*myS, ufirst, ulast, vfirst, vlast, Precision::Confusion(), aSurfBox);
+            BndLib_AddSurface::Add(*myS, ufirst, ulast, vfirst, vlast, Precision::Confusion(), aSurfBox);
            Standard_Real xmin, ymin, zmin, xmax, ymax, zmax;
            aSurfBox.Get(xmin, ymin, zmin, xmax, ymax, zmax);
            Standard_Real tmin = Precision::Infinite(), tmax = -tmin;
          return;
          
        }
-#ifndef DEB
-      default:
-#endif
-       break;
       }
       break;
     }
 
 
 #ifdef DRAW
 #include <DrawTrSurf.hxx>
-#endif
-#ifdef DEB
 static Standard_Boolean Affich     = Standard_False;
 static Standard_Integer NbSECTIONS = 0;
 #endif
+
 //#define GF_DEB
 //=======================================================================
 //function : GeomFill_SweepSectionGenerator
     }
 #ifdef DRAW
     if ( Affich) {
-//POP pour NT
-//      char name[100];
-      char* name = new char[100];
+      char name[256];
       sprintf(name,"SECTION_%d",++NbSECTIONS);
       DrawTrSurf::Set(name,myFirstSect->Transformed(cumulTR));
     }
 
 #ifdef DRAW
       if ( Affich) {
-// POP pour NT
-//     char name[100];
-       char* name = new char[100];
+        char name[256];
        sprintf(name,"SECTION_%d",++NbSECTIONS);
        DrawTrSurf::Set(name,BS);
       }
 
 #include <Geom2d_BezierCurve.hxx>
 #include <TColgp_Array1OfPnt2d.hxx>
 
+#include <TColStd_SequenceOfInteger.hxx>
+#include <TColgp_SequenceOfVec.hxx>
+#include <TColgp_HArray2OfPnt.hxx>
+#include <Geom_BSplineSurface.hxx>
+#include <GeomPlate_SequenceOfAij.hxx>
+#include <GeomPlate_MakeApprox.hxx>
+
 // pour mes tests
-#ifdef DEB
+#ifdef PLATE_DEB
 #include <OSD_Chronometer.hxx>
+#endif
 
+#ifdef DRAW
+#include <DrawTrSurf.hxx>
+#include <Draw_Marker3D.hxx>
+#include <Draw_Marker2D.hxx>
+#include <Draw.hxx>
 static Standard_Integer Affich=0;
 // 0 : Pas de display
 // 1 : Display des Geometries et controle intermediaire
 static Standard_Integer NbProj = 0;
 #endif
 
-#ifdef DRAW
-#include <DrawTrSurf.hxx>
-#include <Draw_Marker3D.hxx>
-#include <Draw_Marker2D.hxx>
-#include <Draw.hxx>
-#endif
-
-#include <TColStd_SequenceOfInteger.hxx>
-#include <TColgp_SequenceOfVec.hxx>
-#include <TColgp_HArray2OfPnt.hxx>
-#include <Geom_BSplineSurface.hxx>
-#include <GeomPlate_SequenceOfAij.hxx>
-#include <GeomPlate_MakeApprox.hxx>
-
-
 //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
 //      =========================================================
 //                   C O N S T R U C T E U R S
  }
 #if DRAW
  if (Affich) {
-   char* name = new char[100];
+   char name[256];
    sprintf(name,"proj_%d",++NbProj);
    DrawTrSurf::Set(name, Curve2d);
  }
 //---------------------------------------------------------
 void GeomPlate_BuildPlateSurface::Perform()
 { 
-#ifdef DEB
+#ifdef PLATE_DEB
   // Chronmetrage
   OSD_Chronometer Chrono;
   Chrono.Reset();
       myPlanarSurfInit = mySurfInit;
 #if DRAW
       if (Affich) {
-       char* name = new char[100];
+       char name[256];
        sprintf(name,"planinit_%d",NbPlan+1);
        DrawTrSurf::Set(name, mySurfInit);
       }
 
 #if DRAW
   if (Affich) {
-    char* name = new char[100];
+    char name[256];
     sprintf(name,"surfinit_%d",++NbPlan);
     DrawTrSurf::Set(name, mySurfInit);
   }
                    if (Affich > 1)
                      {
                        Handle(Draw_Marker3D) mark = new (Draw_Marker3D)(P1, Draw_X, Draw_vert);
-                       char* name = new char[100];
+                        char name[256];
                        sprintf(name,"mark_%d",++NbMark);
                        Draw::Set(name, mark); 
                      }
              LinCont->D0(U,P);
              Handle(Draw_Marker3D) mark = 
                new (Draw_Marker3D)(P, Draw_X, Draw_orange);
-             char* name = new char[100];
-
+              char name[256];
              sprintf(name,"mark_%d",++NbMark);
              Draw::Set(name, mark);
              if (!LinCont->ProjectedCurve().IsNull())
                LinCont->D0(U,P);       
                Handle(Draw_Marker3D) mark = 
                  new Draw_Marker3D(P, Draw_X, Draw_or);
-               char* name = new char[100];
+                char name[256];
                sprintf(name,"mark_%d",++NbMark);
                Draw::Set(name, mark);
              }
 
 
 #ifdef DRAW
 #include <DrawTrSurf.hxx>
-#endif
-#ifdef DEB
 static Standard_Boolean Affich = Standard_False;
 static Standard_Integer NBPROJ = 1;
 #endif
 {
 #ifdef DRAW
   if ( Affich) {
-//POP pour NT
-//    char name[100];
-    char* name = new char[100];
+    char name[256];
     Sprintf(name,"PROJCURV_%d",NBPROJ);
     DrawTrSurf::Set(name,C);
     Sprintf(name,"PROJSURF_%d",NBPROJ);
 
       ElSLib::Parameters(TheSurfaceTool::Sphere(surface),P,u,v);
        break;
       }
-#ifndef DEB
-  default:     break;      
-#endif
+  default:
+    break;
   }
 }
 //=======================================================================
 
                             const Standard_Real);
 
 static void ProcessRLine (IntPatch_SequenceOfLine&,
-#ifndef DEB
                          const IntSurf_Quadric&,
                          const IntSurf_Quadric&,
-#else
-                         const Handle(Adaptor3d_HSurface)&,
-                         const Handle(Adaptor3d_HSurface)&,
-#endif
                          const Standard_Real);
 
-
-
-
 //-- le calcul de dist est completement faux ds la routine ci dessous a revoir (lbr le 18 nov 97)
 Standard_Boolean IntersectionWithAnArc(gp_Pnt& PSurf,
                                       const Handle(IntPatch_ALine)& alin,
 
                                  Standard_Integer&,
                                  Standard_Integer&);
 
-#ifdef DEB                               
-static Standard_Boolean LocBefore (const LocOpe_SequenceOfPntFace&,
-                                  const Standard_Integer,
-                                  Standard_Integer&,
-                                  Standard_Integer&);
-#endif
-
-
 static void AddPoints(IntCurvesFace_Intersector&,
                       LocOpe_SequenceOfPntFace&,
                      const TopoDS_Face&);
 
-
-
-
 //=======================================================================
 //function : Init
 //purpose  : 
 
 #ifdef DRAW
   cout<<FUN_tool_PRODINP()<<"P"<<Index()<<" "<<P3D.X()<<" "<<P3D.Y()<<" "<<P3D.Z()<<"; # tol = "<<tol<<endl;
 #endif
-  cout<<"     on (1) :"; cout<<" vertex(1) : "; cout<<(isvertex1)? 1:0;
-  cout<<"  T "<<E1index<<"(1) : "; T1.Dump(cout);
+  cout<<"     on (1) :";
+  cout<<" vertex(1) : ";
+  cout<<(isvertex1?1:0);
+  cout<<"  T "<<E1index<<"(1) : ";
+  T1.Dump(cout);
   cout<<" par(1) = "<<par1;
   if (isvertex1) {
     P3D = BRep_Tool::Pnt(V1);
   }
   cout<<endl;
   
-  cout<<"     on (2) :"; cout<<" vertex(2) : "; cout<<(isvertex2)? 1:0;
-  cout<<"  T "<<E2index<<"(2) : "; T2.Dump(cout); 
+  cout<<"     on (2) :";
+  cout<<" vertex(2) : ";
+  cout<<(isvertex2?1:0);
+  cout<<"  T "<<E2index<<"(2) : ";
+  T2.Dump(cout);
   cout<<" par(2) = "<<par2;
   if (isvertex2) {
     P3D = BRep_Tool::Pnt(V2);
 
 extern Standard_Boolean TopOpeBRepDS_GettraceDSP();
 extern Standard_Boolean TopOpeBRepDS_GettraceSPSX(const Standard_Integer i);
 extern Standard_Boolean TopOpeBRep_GettraceNVP(Standard_Integer a,Standard_Integer b,Standard_Integer c,Standard_Integer d,Standard_Integer e);
-extern Standard_Boolean GLOBAL_bvpr = Standard_False;void debvpr(){};
+
+Standard_Boolean GLOBAL_bvpr = Standard_False;
+
+void debvpr(){};
 void debvprmess(Standard_Integer f1,Standard_Integer f2,Standard_Integer il,Standard_Integer vp,Standard_Integer si)
 {cout<<"f1,f2,il,vp,si : "<<f1<<","<<f2<<","<<il<<","<<vp<<","<<si<<endl;cout.flush();debvpr();}
 void debpoint(Standard_Integer i) {cout<<"+ debpoint"<<i<<endl;}