diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc
index f250b58..471d5ce 100644
Binary files a/EgtMachKernel.rc and b/EgtMachKernel.rc differ
diff --git a/Pocketing.cpp b/Pocketing.cpp
index c09acd7..aae6761 100644
--- a/Pocketing.cpp
+++ b/Pocketing.cpp
@@ -1149,7 +1149,7 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC)
       if ( ! pSurf->GetFacetNormal( nFacet, vtN))
          return false ;
      // creo la curva a partire dei loop
-      for ( int i = 0 ; i < vPL.size() ; i++) {
+      for ( int i = 0 ; i < int( vPL.size()) ; i++) {
          PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
          pCrvCompo->FromPolyLine( vPL[i]) ;
          if ( ! pCrvCompo->IsValid())
@@ -2430,7 +2430,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
      // se sono nel caso ottimizzato devo togliere il loop esterno
       if ( bOptimizedZigZag) {
          double dMaxArea = -INFINITO ; int nJumpInd = 0 ;
-         for ( int i = 0 ; i < vCrvLoops.size() ; i++) {
+         for ( int i = 0 ; i < int( vCrvLoops.size()) ; i++) {
             double dArea ; vCrvLoops[i]->GetAreaXY( dArea) ;
             if ( dArea > dMaxArea) {
                dMaxArea = dArea ;
@@ -2438,13 +2438,13 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
             }
          }
          ICRVCOMPOPOVECTOR vCrvHelp ;
-         for ( int i = 0 ; i < vCrvLoops.size() ; i++) {
+         for ( int i = 0 ; i < int( vCrvLoops.size()) ; i++) {
             if ( i != nJumpInd)
                vCrvHelp.emplace_back( vCrvLoops[i]->Clone()) ;
          }
          vCrvLoops.clear() ;
          vCrvLoops.resize( vCrvHelp.size()) ;
-         for ( int i = 0 ; i < vCrvHelp.size() ; i++)
+         for ( int i = 0 ; i < int( vCrvHelp.size()) ; i++)
             vCrvLoops[i].Set( Release( vCrvHelp[i])) ;
       }
 
@@ -2457,8 +2457,8 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
       Point3d ptRef = ptEnd ;
       double dMinDist = INFINITO ;
       int nIndexSwitch = -1 ;
-      for ( int i = -1 ; i < vCrvLoops.size() - 1 ; i++) {
-         for ( int j = i + 1 ; j < vCrvLoops.size() ; j++) {
+      for ( int i = -1 ; i < int( vCrvLoops.size()) - 1 ; i++) {
+         for ( int j = i + 1 ; j < int( vCrvLoops.size()) ; j++) {
             Point3d ptS ; vCrvLoops[j]->GetStartPoint( ptS) ;
             if ( Dist( ptS, ptRef) < dMinDist) {
                dMinDist = Dist( ptS, ptRef) ;
@@ -2474,7 +2474,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
          dMinDist = INFINITO ;
       }
 
-      for( int u = 0 ; u < vCrvLoops.size() ; u++) {
+      for( int u = 0 ; u < int( vCrvLoops.size()) ; u++) {
 
         // recupero la prima curva di offset disponibile 
          PtrOwner<ICurveComposite> pOffs( CreateCurveComposite());
@@ -2681,7 +2681,7 @@ Pocketing::CalcZigZag( const ISurfFlatRegion* pSrfZigZag, ICRVCOMPOPOVECTOR& vpC
      // calcolo la classificazione della linea rispetto alla superificie
       CRVCVECTOR ccClass ;
       pSrfZigZag->GetCurveClassification( *pLine, EPS_SMALL, ccClass) ;
-      for ( int j = 0 ; j < ccClass.size() ; j++) {
+      for ( int j = 0 ; j < int( ccClass.size()) ; j++) {
          if ( ccClass[j].nClass == CRVC_IN) { // memorizzo il segmento
             Section currSec;
             currSec.bActive = true;
@@ -2689,7 +2689,7 @@ Pocketing::CalcZigZag( const ISurfFlatRegion* pSrfZigZag, ICRVCOMPOPOVECTOR& vpC
             Point3d ptS, ptE ;
             pSeg->GetStartPoint( ptS) ; pSeg->GetEndPoint( ptE) ;
             currSec.ptS = ptS ; currSec.ptE = ptE ;
-            for ( int k = 0 ; k < vFirstOff.size() ; k++) {
+            for ( int k = 0 ; k < int( vFirstOff.size()) ; k++) {
                if ( vFirstOff[k]->IsPointOn( ptS)) {
                   currSec.nOffIndS = k ;
                   double dUOS; vFirstOff[k]->GetParamAtPoint( ptS, dUOS) ;
@@ -2745,9 +2745,6 @@ Pocketing::CalcZigZag( const ISurfFlatRegion* pSrfZigZag, ICRVCOMPOPOVECTOR& vpC
       Sec.bActive = false ;
       vpCrvs.back()->AddLine( vvSec[nI][nJ].ptE) ;
 
-      if (vpCrvs[0]->GetCurveCount() == 9)
-         int a = 0;
-
       if ( nStatus == 0) { // primo segmento per il raccordo smussato
          plastLine.Set( GetCurveLine( vpCrvs.back()->GetLastCurve()->Clone())) ;
          plastLine->GetStartPoint( ptS_ref) ;
@@ -2933,7 +2930,7 @@ Pocketing::GetUnclearedRegion( ICRVCOMPOPOVECTOR& vFirstOffs, ICRVCOMPOPOVECTOR&
    if ( IsNull( pSrfExtern))
       return false ;
 
-   for ( int i = 0 ; i < vFirstOffs.size() ; i++) {
+   for ( int i = 0 ; i < int( vFirstOffs.size()) ; i++) {
       if ( i == 0)
          pSrfExtern->AddExtLoop( vFirstOffs[i]->Clone()) ;
       else {
@@ -2948,7 +2945,7 @@ Pocketing::GetUnclearedRegion( ICRVCOMPOPOVECTOR& vFirstOffs, ICRVCOMPOPOVECTOR&
    if ( IsNull( pSrfTool))
       return false ;
 
-   for ( int i = 0 ; i < vCrvs.size(); i++) {
+   for ( int i = 0 ; i < int( vCrvs.size()) ; i++) {
       PtrOwner<ISurfFlatRegion> pSrfToolRegOffi( GetSurfFlatRegionFromFatCurve( vCrvs[i]->Clone(), m_TParams.m_dDiam / 2 + 5 * EPS_SMALL, false, false)) ;
       if ( i == 0)
          pSrfTool.Set( Release( pSrfToolRegOffi)) ;
@@ -2956,7 +2953,7 @@ Pocketing::GetUnclearedRegion( ICRVCOMPOPOVECTOR& vFirstOffs, ICRVCOMPOPOVECTOR&
          pSrfTool->Add( *Release( pSrfToolRegOffi)) ;
    }
 
-   for ( int i = 0; i < vLinks.size(); i++) {
+   for ( int i = 0; i < int( vLinks.size()) ; i++) {
       if ( ! IsNull( vLinks[i])) {
          PtrOwner<ISurfFlatRegion> pSrfToolRegLinki( GetSurfFlatRegionFromFatCurve( vLinks[i]->Clone(), m_TParams.m_dDiam / 2 + 5 * EPS_SMALL, false, false)) ;
          pSrfTool->Add( *Release( pSrfToolRegLinki)) ;
@@ -3213,7 +3210,7 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl
       }
    }
 
-   for ( int i = 0 ; i < vCrvAllLoops.size() ; i++) {
+   for ( int i = 0 ; i < int( vCrvAllLoops.size()) ; i++) {
       if ( i != nIndex) {
          vFirstOffsets.emplace_back( vCrvAllLoops[i]->Clone()) ;
       }
@@ -3221,7 +3218,7 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl
 
   // creo la superficie da svuotare ottimizzata
    SurfFlatRegionByContours pSrfMod ;
-   for ( int i = 0 ; i < vFirstOffsets.size() ; i++)
+   for ( int i = 0 ; i < int( vFirstOffsets.size()) ; i++)
       pSrfMod.AddCurve( vFirstOffsets[i]->Clone()) ;
    PtrOwner<ISurfFlatRegion> pSrfZigZag( GetSurfFlatRegion( pSrfMod.GetSurf())) ;
    if ( IsNull( pSrfZigZag))
@@ -3673,7 +3670,7 @@ Pocketing::AddOneWay( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
             return false ;
          pSrfIdeal.Set( pSrfToPock->CloneChunk( c)) ;
          vChunksAvailable[c] = -1 ;
-         for ( int i = 0; i < vChunksAvailable.size(); i++) {
+         for ( int i = 0; i < int( vChunksAvailable.size()) ; i++) {
             if ( vChunksAvailable[i] == 1) { // se chunk valido...
                PtrOwner<ICurveComposite> pCrvExtC( GetCurveComposite( pSrfToPock->GetLoop( i, 0))) ;
                if ( IsNull( pCrvExtC))
@@ -3697,7 +3694,7 @@ Pocketing::AddOneWay( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
    // - dOffs con le curve da percorrere all'inizio ( bordo da percorrere, senza mai superarlo)
    // - dOffs - dExtra per definire le curve interne della svuotatura ( bordo immaginario per il OneWay )
 
-   for ( int nIdealSurf = 0 ; nIdealSurf < vSrfFlat.size() ; nIdealSurf++) {
+   for ( int nIdealSurf = 0 ; nIdealSurf < int( vSrfFlat.size()) ; nIdealSurf++) {
 
      // === PRIMO OFFSET ===
       PtrOwner<ISurfFlatRegion> pSrfIdeal( CloneSurfFlatRegion( vSrfFlat[nIdealSurf])->Clone()) ;
@@ -3726,7 +3723,7 @@ Pocketing::AddOneWay( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
       Point3d ptHelp ;
 
      // scorro tutte le curve 
-      for ( int i = 0 ; i < vAllCrv.size() ; i++) {
+      for ( int i = 0 ; i < int( vAllCrv.size()) ; i++) {
          
         //se richiesto, la inverto
          if ( m_Params.m_bInvert)
@@ -3742,7 +3739,7 @@ Pocketing::AddOneWay( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
            // sposto l'inizio a metà del tratto più lungo
             AdjustContourStart( vAllCrv[i]) ;
          }
-         else if ( i < vAllCrv.size() - 1) {
+         else if ( i < int( vAllCrv.size()) - 1) {
            // sposto l'inizio della curva più vicina al punto finale precendente
             Point3d ptS ;
             vAllCrv[i]->GetStartPoint( ptS) ;
@@ -3752,7 +3749,7 @@ Pocketing::AddOneWay( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
                return false ;
             dDist = INFINITO ;
          
-            for ( int j = i + 1 ; j <= vAllCrv.size() - 1 ; j++) {
+            for ( int j = i + 1 ; j <= int( vAllCrv.size()) - 1 ; j++) {
          
               // cerco il punto più vicino della curva
                Point3d ptE ;
@@ -3937,7 +3934,7 @@ Pocketing::AddOneWay( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
            // riempio il vettore di segmenti
             CRVCVECTOR ccClassSeg ;
             pSrfIdeal->GetCurveClassification( *pLine, EPS_SMALL, ccClassSeg) ;
-            for ( int w = 0 ; w < ccClassSeg.size() ; w++) {
+            for ( int w = 0 ; w < int( ccClassSeg.size()) ; w++) {
                if ( ccClassSeg[w].nClass == CRVC_IN) {
 
                   PtrOwner<ICurveLine> pCrvSeg( GetCurveLine( pLine->CopyParamRange( ccClassSeg[w].dParS, ccClassSeg[w].dParE))) ;
@@ -4735,14 +4732,14 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int nReg, Point3d ptStar
   // smusso le curve di offset ( ad eccezione della prima)
    ICRVCOMPOPOVECTOR vOffsClosedCurves( vOffs.size()) ; // vettore con tutte le curve di Offset Chiuse
 
-   for ( int i = 0; i < vOffs.size(); i++ ) {
+   for ( int i = 0; i < int( vOffs.size()) ; i++ ) {
       if( i != 0)
          ModifyCurveToSmooted( vOffs[i], 0.01, 0.01) ;
       vOffs[i]->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
       vOffsClosedCurves[i].Set( vOffs[i]->Clone()) ;
    }
 
-   for ( int i = 0 ; i < vOffsFirstCurve.size() ; i++ ) {
+   for ( int i = 0 ; i < int( vOffsFirstCurve.size()) ; i++ ) {
       if( i != 0 )
          ModifyCurveToSmooted( vOffsFirstCurve[i], 0.01, 0.01) ;
       vOffsFirstCurve[i]->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
@@ -4750,7 +4747,7 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int nReg, Point3d ptStar
 
   // setto il punto iniziale della svuotatura
    double dNewUS ;
-   vOffs[0]->GetParamAtPoint( ptNewStart, dNewUS);
+   vOffs[0]->GetParamAtPoint( ptNewStart, dNewUS) ;
    vOffs[0]->ChangeStartPoint( dNewUS) ;
 
   // riordino le curve cambiando il loro punto di inizio e creando poi i collegamenti
@@ -4759,7 +4756,7 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int nReg, Point3d ptStar
    Point3d ptHelp ;
    ICURVEPOVECTOR vLinks( vOffs.size()) ;
 
-   for ( int i = 0 ; i < vOffs.size() - 1; i++) {
+   for ( int i = 0 ; i < int( vOffs.size()) - 1 ; i++) {
 
       Point3d ptS ;
       if ( ! vOffs[i]->GetStartPoint( ptS))
@@ -4770,7 +4767,7 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int nReg, Point3d ptStar
          return false ;
       dDist = INFINITO ;
 
-      for ( int j = i + 1 ; j <= vOffs.size() - 1; j++) {
+      for ( int j = i + 1 ; j <= int( vOffs.size()) - 1 ; j++) {
         // cerco il punto più vicino della curva
          Point3d ptE ;
 
@@ -4842,7 +4839,7 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int nReg, Point3d ptStar
 
       }
       else {
-         double dUNS, dUNE, dUNEE, dLen ;
+         double dUNS, dUNE ;
          PtrOwner<ICurveComposite> pCrvTest( CreateCurveComposite()) ;
          PtrOwner<ICurveComposite> pOff_i0(CloneCurveComposite( vOffs[i])) ;
          PtrOwner<ICurveComposite> pOff_i1(CloneCurveComposite( vOffs[i + 1])) ;
@@ -4983,10 +4980,10 @@ Pocketing::ModifyCurveToSmooted( ICurveComposite* pCrv, double dRightPer, double
       vCrvStepsToFill.emplace_back( pMyCrvFirst->Clone()) ;
    }
 
-   double dUE_ref, dUS_ref, dRadius, dPar1, dPar2, dULast;
+   double dUE_ref, dUS_ref, dRadius, dPar1, dPar2 ;
 
   // riempio il vettore degli archi, scorro tutte le curve da raccordare ( la i-esima e la (i+1)-esima )
-   for ( int i = 0; i < vCrvStepsToFill.size() - 1; i++) {
+   for ( int i = 0; i < int( vCrvStepsToFill.size()) - 1 ; i++) {
 
      // controllo che le curve non siano già tangenti
       Vector3d vtS, vtE ;
@@ -5077,7 +5074,7 @@ Pocketing::ModifyCurveToSmooted( ICurveComposite* pCrv, double dRightPer, double
    Point3d ptArcHelp, ptFirstPoint ;
 
   // unisco la curva i-esima con l'arco i-esimo (non guardo l'ultima curva nel vettore, controllo dopo il caso di curva chiusa)
-   for ( int i = 0 ; i < vCrvStepsToFill.size() -1 ; i++) {
+   for ( int i = 0 ; i < int( vCrvStepsToFill.size()) - 1 ; i++) {
 
       if ( vArcsToJump[i] == -1) { // se esiste l'arco ...
          Point3d ptArcS, ptArcE ;
@@ -5190,7 +5187,7 @@ Pocketing::CutCurveToConnect( ICurveComposite* pCrvS, ICurveComposite* pCrvE, IC
 
   // se ho una curva di primo Offset allora non devo accorciarla ...
    bool bCut = true ;
-   for ( int i = 0 ; i < vFirstOffset.size() ; i++ ) {
+   for ( int i = 0 ; i < int( vFirstOffset.size()) ; i++ ) {
       if ( vFirstOffset[i]->IsPointOn( ptSS) && vFirstOffset[i]->IsPointOn( ptSE))
          dLenPercS = 0 ;
       if ( vFirstOffset[i]->IsPointOn( ptES) && vFirstOffset[i]->IsPointOn( ptEE))
@@ -5221,7 +5218,7 @@ Pocketing::CutCurveToConnect( ICurveComposite* pCrvS, ICurveComposite* pCrvE, IC
 
     // se il BiArco creato interseca le altre curve di Offset allora mi fermo...
       bool bInterr = false ;
-      for ( int i = 0 ; i < vOffsCL.size() && ! bInterr ; i++) {
+      for ( int i = 0 ; i < int( vOffsCL.size()) && ! bInterr ; i++) {
          if ( vOffsCL[i]->IsPointOn( ptSE) || vOffsCL[i]->IsPointOn( ptES))
             continue ;
 
@@ -5340,7 +5337,6 @@ Pocketing::RemoveExtraParts( ISurfFlatRegion* pSrfToCut, ICRVCOMPOPOVECTOR& vOff
             if ( ! GetNewCurvetWithPath( pCrvH1, pCrvH2, pCrvPath, vOffsFirstCurve, vOffsClosedCurves, ptCrvNewLink))
                bSucc = false;
 
-            double dLen, dLenI ;
             PtrOwner<ICurveComposite> pCrvPathI( pCrvPath->Clone()) ;
             pCrvPathI->Invert() ;
             PtrOwner<ICurveComposite> ptCrvNewLinkI( CreateCurveComposite()) ;
@@ -5378,9 +5374,8 @@ Pocketing::RemoveExtraParts( ISurfFlatRegion* pSrfToCut, ICRVCOMPOPOVECTOR& vOff
             bool bSucc = true; bool bSuccI = true;
 
             if ( ! GetNewCurvetWithPath( pCrvH1, pCrvH2, pCrvPath, vOffsFirstCurve, vOffsClosedCurves, ptCrvNewOffs))
-               bSucc == false ;
+               bSucc = false ;
 
-            double dLen, dLenI ;
             PtrOwner<ICurveComposite> pCrvPathI( pCrvPath->Clone()) ;
             pCrvPathI->Invert() ;
             PtrOwner<ICurveComposite> ptCrvNewOffsI( CreateCurveComposite()) ;
@@ -5493,8 +5488,8 @@ Pocketing::ChoosePath( ICurveComposite* pCrv1, ICurveComposite* pCrv2, int nP, d
    double CR1, CR2 ;
 
    if ( dRot1 == 0 && dRot2 == 0) {
-      CR1 == 0 ; 
-      CR2 == 0 ;
+      CR1 = 0 ; 
+      CR2 = 0 ;
    }
    else {
       CR1 = dRot1 / max( dRot1, dRot2) ;
@@ -5529,7 +5524,7 @@ GetClosestOffsetToAPoint( ICRVCOMPOPOVECTOR& vCurves, Point3d& ptFocus, Point3d&
          return false ;
    }
 
-   for ( int j = 1; j < vCurves.size(); j++ ) {
+   for ( int j = 1; j < int( vCurves.size()) ; ++ j) {
       if ( ! DistPointCurve( ptFocus, *vCurves[j]).GetMinDistPoint( EPS_SMALL, ptCl_H, nFlag))
          return false ;
 
@@ -5541,7 +5536,7 @@ GetClosestOffsetToAPoint( ICRVCOMPOPOVECTOR& vCurves, Point3d& ptFocus, Point3d&
    }
    if ( ! bFirst && vCurves.size() > 1) {
       int nindexOld = nIndex ; dDistance = INFINITO ;
-      for ( int j = 1; j < vCurves.size(); j++ ) {
+      for ( int j = 1; j < int( vCurves.size()) ; ++ j) {
          if ( j != nindexOld) {
             if ( ! DistPointCurve( ptFocus, *vCurves[j]).GetMinDistPoint( EPS_SMALL, ptCl_H, nFlag))
                return false ;
@@ -5561,7 +5556,7 @@ GetClosestOffsetToAPoint( ICRVCOMPOPOVECTOR& vCurves, Point3d& ptFocus, Point3d&
    PtrOwner<ICurveComposite> pCrv_H( vCurves[nIndex]->Clone()) ;
 
   // 2) Sulle curve di Offset ricavo: vettore iniziale, finale | punto iniziale, finale
-   Vector3d vtTanS, vtTanE, vtHelp ; double dUTan, dLenHelp, dUS, dUE ; bool bMustUseBiArcs = false ;
+   Vector3d vtTanS, vtTanE, vtHelp ; double dUTan, dUS, dUE ; bool bMustUseBiArcs = false ;
 
    if ( ! pCrv_H->GetParamAtPoint( ptCL, dUTan) || ! pCrv_H->GetDomain( dUS, dUE))
       return false ;
@@ -5583,7 +5578,7 @@ GetClosestLinkToAPoint( ICURVEPOVECTOR& vCurves, ICRVCOMPOPOVECTOR& vOffs, Point
    pCrv2->Clear() ;
    bfound = false ;
 
-   for ( int j = 1; j < vCurves.size(); j++ ) {
+   for ( int j = 1; j < int( vCurves.size()) ; ++ j) {
       if ( ! DistPointCurve( ptFocus, *vCurves[j]).GetMinDistPoint( EPS_SMALL, ptCl_H, nFlag))
          return false ;
 
@@ -5973,14 +5968,15 @@ Pocketing::RemoveExtraPartByMedialAxis( ISurfFlatRegion* pChunkToCut, ICRVCOMPOP
          return false ;
 
       ISurfFlatRegion* pSrfChunkToCutCloneTest( pSrfBiggerChunk->Clone()) ;
-      if ( bForceCentroid || pSrfChunkToCutCloneTest->Subtract( *pSrfTool) && ! pSrfChunkToCutCloneTest->GetArea( dArea) && dArea < 10 * EPS_SMALL) {
+      if ( bForceCentroid  ||
+           ( pSrfChunkToCutCloneTest->Subtract( *pSrfTool)  &&  ! pSrfChunkToCutCloneTest->GetArea( dArea)  &&  dArea < 10 * EPS_SMALL)) {
          if ( nIter == 1) { // se alla prima iterazione svuoto tutto con il centroide ...
             nOptFlag = 1 ;
             ptCentroid = ptC;
             return true ;
          }
          else { // ... altrimenti devo prendere il centroide (che poi unirò al medil axis più vicino...)
-            for ( int cen = 0 ; cen < vPtCentroid.size(); cen++) {
+            for ( int cen = 0 ; cen < int( vPtCentroid.size()) ; ++ cen) {
                if ( AreSamePointApprox( vPtCentroid[cen], ptC)) {
                   pSrfChunkToCutClone->Clear() ;
                   break ;
@@ -6065,7 +6061,7 @@ Pocketing::RemoveExtraPartByMedialAxis( ISurfFlatRegion* pChunkToCut, ICRVCOMPOP
 
    pCrvPath->AddCurve( vCrvCoMedAxi[0]->Clone()) ; // inserisco il primo medial Axis nel percorso finale 
 
-   for ( int i = 1; i < vCrvCoMedAxi.size(); i++) { // scorro i restanti
+   for ( int i = 1; i < int( vCrvCoMedAxi.size()) ; ++ i) { // scorro i restanti
       Point3d ptS, ptE ; Vector3d vtS, vtE ;  // parametri iniziali del medialAxis iesimo e (i-1)esimo
       if ( ! vCrvCoMedAxi[i]->GetStartPoint( ptE) 
          || ! vCrvCoMedAxi[i-1]->GetEndPoint( ptS)
@@ -6096,7 +6092,7 @@ Pocketing::RemoveExtraPartByMedialAxis( ISurfFlatRegion* pChunkToCut, ICRVCOMPOP
    // la tengo chiusa in modo da unire facilmente le circonferenze che collegheranno i vari centroidi a questa curva 
 
   // se ho trovato dei centroidi li unisco nei punti più vicino a questo percorso
-   for ( int i = 0; i < vPtCentroid.size(); i++) {
+   for ( int i = 0; i < int( vPtCentroid.size()) ; ++ i) {
 
      // 1) cerco il punto sulla curva più vicino al centroide i
       Point3d ptClosestOnPath ; int nFlag ;
@@ -6110,7 +6106,6 @@ Pocketing::RemoveExtraPartByMedialAxis( ISurfFlatRegion* pChunkToCut, ICRVCOMPOP
 
      // 3) prendo il vettore tangente al percorso nel punto PtClosestOnPath
       Vector3d vtTanCpt ;
-      double dParClosest ;
       ICurveComposite* pCrvCoHelpToTan( pCrvPath->Clone()) ;
       if ( ! pCrvCoHelpToTan->GetStartDir( vtTanCpt))
          return false ;
@@ -6171,7 +6166,7 @@ Pocketing::CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, ICRVCO
 
   // porto la curva di contenimento in locale a questo riferimento
    vector<CurveLocal> vOffsExtr ;
-   for ( int i = 0 ; i < vOffIslands.size(); i++) {
+   for ( int i = 0 ; i < int( vOffIslands.size()) ; ++ i) {
       CurveLocal CrvOutLoc( vOffIslands[i], GLOB_FRM, frLoc) ;
       vOffsExtr.push_back( CrvOutLoc) ;
    }
@@ -6198,7 +6193,7 @@ Pocketing::CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, ICRVCO
       return false ;
 
      // scorro il vettore degli indici degli offset delle isole intersecati
-   for ( int i = 0 ; i < vOffIslands.size(); i++ ) { 
+   for ( int i = 0 ; i < int( vOffIslands.size()) ; i++) { 
       CRVCVECTOR ccClass ;
       IntersCurveCurve intCC( *pCompo, *vOffIslands[i]) ;
       intCC.GetCurveClassification( 0, EPS_SMALL, ccClass) ;
@@ -6292,7 +6287,7 @@ Pocketing::CalcBoundedSmootedLink( const Point3d& ptStart, const Vector3d& vtSta
       return false ;
 
   // scorro tutte le curve per controllare le intersezioni ...
-   for ( int i = 0 ; i < vOffIslands.size(); i++) {
+   for ( int i = 0 ; i < int( vOffIslands.size()) ; i++) {
 
       CRVCVECTOR ccClass ;
       IntersCurveCurve intCC( *pCompo, *vOffIslands[i]) ;
@@ -6392,8 +6387,6 @@ Pocketing::ModifyBiArc( ICurve* pBiArcLink, double dToll, ICurveComposite* pNewB
    if ( pArc1 == nullptr || pArc2 == nullptr)
       return false ;
 
-   double dUTollS, dUTollE ;
-
   // primo pezzo
    pArc1->GetDomain( dUS, dUE) ;
    PtrOwner<ICurve> pArc1A( GetCurve( pArc1->CopyParamRange( dUS, dUS + ( dUE - dUS ) * dToll))) ; // Arc1
@@ -6433,8 +6426,8 @@ Pocketing::CutCurveByOffsets( ICurveComposite* pCurve, ICRVCOMPOPOVECTOR& vOffs)
    if ( vOffs.size() == 0)
       return true ;
 
-   ICRVCOMPOPOVECTOR vOffOrig( vOffs.size());
-   for ( int i = 0; i < vOffs.size(); i++ ) {
+   ICRVCOMPOPOVECTOR vOffOrig( vOffs.size()) ;
+   for ( int i = 0; i < int( vOffs.size()) ; i++) {
       vOffOrig[i].Set(vOffs[i]->Clone()) ;
    }
 
@@ -6451,7 +6444,7 @@ Pocketing::CutCurveByOffsets( ICurveComposite* pCurve, ICRVCOMPOPOVECTOR& vOffs)
    int nTypeOfCut = -1 ;
    bool bAttention = false ;
 
-   for ( int i = 0; i < vOffOrig.size() ; i++) {
+   for ( int i = 0; i < int( vOffOrig.size()) ; i++) {
 
       if ( vOffOrig[i]->IsPointOn( ptStart))
          pOffCheck.Set( vOffOrig[i]->Clone()) ;
@@ -8149,7 +8142,7 @@ Pocketing::VerifyLeadInHelix( ISurfFlatRegion* pSrfChunk, const Point3d& ptCen,
    double dMinDist ;
    bool bOk = DistPointCurve( ptCenL, *pCompo).GetDist( dMinDist) && dMinDist > dRad + 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL ;
   // se la curva per l'attacco è valida per tale, controllo che l'elica non intersechi eventuali isole
-   for ( int i = 1 ; bOk && i < vCrv.size() ; i++)
+   for ( int i = 1 ; bOk && i < int( vCrv.size()) ; i++)
       bOk = DistPointCurve( ptCenL, *vCrv[i]).GetDist( dMinDist) && dMinDist > dRad + 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL ;
    return bOk ;
 }
@@ -8194,7 +8187,7 @@ Pocketing::VerifyLeadInZigZag( ISurfFlatRegion* pSrfChunk, const Point3d& ptPa,
       return false ;
    bool bOk = dMinDistPa > 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL && dMinDistPb > 0.5 * m_TParams.m_dDiam - 10 * EPS_SMALL ;
   // se la curva per l'attacco è valida per tale, controllo che lo ZigZag non intersechi eventuali isole
-   for ( int i = 1 ; bOk && i < vCrv.size() ; i++) {
+   for ( int i = 1 ; bOk && i < int( vCrv.size()) ; i++) {
       if ( ! DistPointCurve( ptPaL, *vCrv[i]).GetDist( dMinDistPa))
          return false ;
       if ( ! DistPointCurve( ptPbL, *vCrv[i]).GetDist( dMinDistPb))
diff --git a/SawFinishing.cpp b/SawFinishing.cpp
index 1445694..6a4d11d 100644
--- a/SawFinishing.cpp
+++ b/SawFinishing.cpp
@@ -1564,18 +1564,6 @@ SawFinishing::CalculateCurvedAcrossToolPath( int nAuxId, int nClId)
   // La porto in globale
    PL.ToGlob( frSect) ;
 
-  // Calcolo eventuale anticipo dell'inizio
-   double dAddStart = 0 ;
-   if ( m_Params.m_nLeadLinkType == SAWFIN_LL_OUT) {
-      BBox3d b3PL ;
-      PL.GetLocalBBox( b3PL) ;
-      double dMaxElev = min( dDepth, b3Raw.GetMax().z - b3PL.GetMin().z) ;
-      if ( dMaxElev > 0.0  &&  dMaxElev < 0.5 * m_TParams.m_dDiam)
-         dAddStart = sqrt( dMaxElev * m_TParams.m_dDiam - dMaxElev * dMaxElev) ;
-      else
-         dAddStart =  0.5 * m_TParams.m_dDiam ;
-   }
-
   // Imposto versore fresa come Z+
    Vector3d vtTool = Z_AX ;
 
@@ -1857,7 +1845,6 @@ SawFinishing::ClassifySection( ICurve* pCrv, INTVECTOR& vnClass)
 {
    const ICurveComposite* pCompo = GetCurveComposite( pCrv) ;
    if ( pCompo != nullptr) {
-      int Ind = 0 ;
       const ICurve* pSimpCrv = pCompo->GetFirstCurve() ;
       while ( pSimpCrv != nullptr) {
         // analizzo la curva
@@ -1875,7 +1862,6 @@ SawFinishing::ClassifySection( ICurve* pCrv, INTVECTOR& vnClass)
          else
             vnClass.push_back( CCL_FALL) ;
         // passo alla curva successiva
-         ++ Ind ;
          pSimpCrv = pCompo->GetNextCurve() ;
       }
    }
diff --git a/SetupMgr.cpp b/SetupMgr.cpp
index 5747235..ea69c4a 100644
--- a/SetupMgr.cpp
+++ b/SetupMgr.cpp
@@ -181,16 +181,12 @@ SetupMgr::Import( const string& sFileName)
         m_pMchMgr->GetCurrMachGroup() == GDB_ID_NULL)
       return false ;
 
-  // recupero il gruppo di setup
-   int nSetupId = m_pMchMgr->GetCurrSetupGroupId() ;
-
   // inizializzo lo scanner
    Scanner TheScanner ;
    if ( ! TheScanner.Init( sFileName, ";"))
       return false ;
 
   // eseguo la lettura dei campi di attrezzaggio
-   int nPos = 1 ;
    string sLine ;
    while ( TheScanner.GetLine( sLine)) {
      // salto dichiarazione sezione
@@ -228,8 +224,6 @@ SetupMgr::Import( const string& sFileName)
          stuData.m_nExit = 0 ;
          m_vStuData.emplace_back( stuData) ;
       }
-     // passo alla successiva posizione
-      ++ nPos ;
    }
 
    return true ;