diff --git a/VolTriZmapGraphics.cpp b/VolTriZmapGraphics.cpp
index eae0406..20c4e0a 100644
--- a/VolTriZmapGraphics.cpp
+++ b/VolTriZmapGraphics.cpp
@@ -351,7 +351,7 @@ VolZmap::GetTriangles( bool bAllBlocks, INTVECTOR& nModifiedBlocks, TRIA3DLISTVE
             for ( size_t t1 = 0 ; t1 < m_InterBlockTria[t].size() ; ++ t1) {
                for ( size_t t2 = 0 ; t2 < m_InterBlockTria[t][t1].vCompoTria.size() ; ++ t2) {
                   for ( size_t t3 = 0 ; t3 < m_InterBlockTria[t][t1].vCompoTria[t2].size() ; ++ t3) {
-                     if ( m_InterBlockTria[t][t1].vCompoTria[t2][t3].GetArea() > EPS_SMALL) {
+                     if ( m_InterBlockTria[t][t1].vCompoTria[t2][t3].GetArea() > EPS_SMALL * EPS_SMALL) {
                         vLstTria[nPos].emplace_back( InterBlockTria[t][t1].vCompoTria[t2][t3]) ;
                      }
                   }
diff --git a/VolTriZmapVolume.cpp b/VolTriZmapVolume.cpp
index 5b2de44..1fe481a 100644
--- a/VolTriZmapVolume.cpp
+++ b/VolTriZmapVolume.cpp
@@ -179,53 +179,92 @@ VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ
   
       if ( nGrid == 0) {
 
-         int nXBlock = min( nI / m_nDexNumPBlock, m_nFracLin[0] - 1) ;
-         int nYBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[1] - 1) ;
+         INTVECTOR nXBlock ;
+         INTVECTOR nYBlock ;
 
-         int nMinK = max( int( floor( ( ( dMin - 0.5 * m_dStep) / m_dStep - EPS_SMALL))), 0) ;
-         int nMaxK = max( int( floor( ( ( dMax + 0.5 * m_dStep) / m_dStep + EPS_SMALL))), 0) ;
+         nXBlock.emplace_back( min( nI / m_nDexNumPBlock, m_nFracLin[0] - 1)) ;
+         nYBlock.emplace_back( min( nJ / m_nDexNumPBlock, m_nFracLin[1] - 1)) ;     
+
+         if ( nI % N_DEXBLOCK == 0  &&  nXBlock[0] > 0) 
+            nXBlock.emplace_back( nXBlock[0] - 1) ;
+
+         if ( nJ % N_DEXBLOCK == 0  &&  nYBlock[0] > 0)
+            nYBlock.emplace_back( nYBlock[0] - 1) ;
+
+         int nMinK = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / m_dStep - EPS_SMALL))), 0, m_nNy[1] - 1) ;
+         int nMaxK = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / m_dStep + EPS_SMALL))), 0, m_nNy[1] - 1) ;
 
          int nMinZBlock = ( m_nMapNum == 1 ? 0 : max( 0, nMinK / int( m_nDexNumPBlock))) ;
          int nMaxZBlock = min( int( m_nFracLin[2] - 1), nMaxK / int( m_nDexNumPBlock)) ;
 
-         for ( int k = nMinZBlock ; k <= nMaxZBlock ; ++ k) { 
-            int nBlockNum = k * nLayerBlock + nYBlock * m_nFracLin[0] + nXBlock ;
-            m_BlockToUpdate[nBlockNum] = true ;            
-         }
+         for ( size_t tI = 0 ; tI < nXBlock.size() ; ++ tI) {
+            for ( size_t tJ = 0 ; tJ < nYBlock.size() ; ++ tJ) {
+               for ( int k = nMinZBlock ; k <= nMaxZBlock ; ++ k) { 
+                  int nBlockNum = k * nLayerBlock + nYBlock[tJ] * m_nFracLin[0] + nXBlock[tI] ;
+                  m_BlockToUpdate[nBlockNum] = true ;            
+               }
+            }
+         }         
       }
 
       else if ( nGrid == 1) {
 
-         int nYBlock = min( nI / m_nDexNumPBlock, m_nFracLin[1] - 1) ;
-         int nZBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[2] - 1) ;
+         INTVECTOR nYBlock ;
+         INTVECTOR nZBlock ;
 
-         int nMinI = max( int( floor( ( ( dMin - 0.5 * m_dStep) / m_dStep - EPS_SMALL))), 0) ; 
-         int nMaxI = max( int( floor( ( ( dMax + 0.5 * m_dStep) / m_dStep + EPS_SMALL))), 0) ; 
+         nYBlock.emplace_back( min( nI / m_nDexNumPBlock, m_nFracLin[1] - 1)) ; 
+         nZBlock.emplace_back( min( nJ / m_nDexNumPBlock, m_nFracLin[2] - 1)) ;
+
+         if ( nI % N_DEXBLOCK == 0  &&  nYBlock[0] > 0)
+            nYBlock.emplace_back( nYBlock[0] - 1) ;
+
+         if ( nJ % N_DEXBLOCK == 0  &&  nZBlock[0] > 0)
+            nZBlock.emplace_back( nZBlock[0] - 1) ;
+
+         int nMinI = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / m_dStep - EPS_SMALL))), 0, m_nNx[0] - 1) ; 
+         int nMaxI = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / m_dStep + EPS_SMALL))), 0, m_nNx[0] - 1) ; 
 
          int nMinXBlock = max( 0, nMinI / int( m_nDexNumPBlock)) ;
          int nMaxXBlock = min( int( m_nFracLin[0] - 1), nMaxI / int( m_nDexNumPBlock)) ;
          
-         for ( int k = nMinXBlock ; k <= nMaxXBlock ; ++ k) {
-            int nBlockNum = nZBlock * nLayerBlock + nYBlock * m_nFracLin[0] + k ;
-            m_BlockToUpdate[nBlockNum] = true ;           
-         }
+         for ( size_t tI = 0 ; tI < nYBlock.size() ; ++ tI) {
+            for ( size_t tJ = 0 ; tJ < nZBlock.size() ; ++ tJ) {
+               for ( int k = nMinXBlock ; k <= nMaxXBlock ; ++ k) {
+                  int nBlockNum = nZBlock[tJ] * nLayerBlock + nYBlock[tI] * m_nFracLin[0] + k ;
+                  m_BlockToUpdate[nBlockNum] = true ;           
+               }
+            }
+         }        
       }
 
       else if ( nGrid == 2) {
 
-         int nXBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[0] - 1) ;
-         int nZBlock = min( nI / m_nDexNumPBlock, m_nFracLin[2] - 1) ;
+         INTVECTOR nXBlock ;
+         INTVECTOR nZBlock ;
 
-         int nMinJ = max( int( floor( ( ( dMin - 0.5 * m_dStep) / m_dStep - EPS_SMALL))), 0) ; 
-         int nMaxJ = max( int( floor( ( ( dMax + 0.5 * m_dStep) / m_dStep + EPS_SMALL))), 0) ; 
+         nXBlock.emplace_back( min( nJ / m_nDexNumPBlock, m_nFracLin[0] - 1)) ;
+         nZBlock.emplace_back( min( nI / m_nDexNumPBlock, m_nFracLin[2] - 1)) ;
+
+         if ( nJ % N_DEXBLOCK  &&  nXBlock[0] > 0)
+            nXBlock.emplace_back( nXBlock[0] - 1) ;
+
+         if ( nI % N_DEXBLOCK  &&  nZBlock[0] > 0)
+            nZBlock.emplace_back( nZBlock[0] - 1) ;
+         
+         int nMinJ = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / m_dStep - EPS_SMALL))), 0, m_nNy[0] - 1) ; 
+         int nMaxJ = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / m_dStep + EPS_SMALL))), 0, m_nNy[0] - 1) ; 
 
          int nMinYBlock = max( 0, nMinJ / int( m_nDexNumPBlock)) ;
          int nMaxYBlock = min( int( m_nFracLin[1] - 1), nMaxJ / int( m_nDexNumPBlock)) ;
          
-         for ( int k = nMinYBlock ; k <= nMaxYBlock ; ++ k) { 
-            int nBlockNum = nZBlock * nLayerBlock + k * m_nFracLin[0] + nXBlock ;
-            m_BlockToUpdate[nBlockNum] = true ;           
-         }
+         for ( size_t tI = 0 ; tI < nZBlock.size() ; ++ tI) {
+            for ( size_t tJ = 0 ; tJ < nXBlock.size() ; ++ tJ) {
+               for ( int k = nMinYBlock ; k <= nMaxYBlock ; ++ k) { 
+                  int nBlockNum = nZBlock[tI] * nLayerBlock + k * m_nFracLin[0] + nXBlock[tJ] ;
+                  m_BlockToUpdate[nBlockNum] = true ;           
+               }
+            }
+         }        
       }
 
       m_OGrMgr.Reset() ;