      .

  [0..J]   
   :

[0  .. n0 - 1]
[n0 .. n1 - 1]
...
[nx .. m0 - 1]
[m0 .. m1 - 1]
[m1 .. m2 - 1]
...
[mx .. l0 - 1]
[l0 .. l1 - 1]
[l1 .. l2 - 1]
...
[kx .. N - 1]

,  n0, n1 - n0, ..., m0 - nx, m1 - m0, ..., l0 - mx, l1 - l0,
..., N - lx -   .
     ( 1- )
     mular_indir 2- :

[0 .. n - 1]
[0 .. m - n]
[0 .. l - m]
...

  mular_indir     
       ,
       .

 [0 .. n - 1]  :
    {&[0  .. n0 - 1], n0}
    {&[n0 .. n1 - 1], n1}
    ...
    {&[nx .. m0 - 1], m0}

 [0 .. m - n]  :
    {&[m0 .. m1 - 1], m1}
    {&[m1 .. m2 - 1], m2}
    ...
    {&[mx .. l0 - 1], l0}

 [0 .. l - m]  :
    {&[l0 .. l1 - 1], l1}
    {&[l1 .. l2 - 1], l2}
    ...

       
  mular_indir 3- :

    {&[0 .. n - 1], m0}
    {&[0 .. m - n], l0}
    {&[0 .. l - m], ...
    ...

 ..
        2-
       ,
   .

mular_descriptor    
 .  size   
1-      ,  1- 
     unit,   
   mular_indir.
     lemax, 
   level.
 level == 0,   ,   
         
 .     
,    top, level  1.
level == 1 ,  top  
   .
       ,
    , ,
       
,     2,   
     1,  top  
   2,  level  2.
     - ,
   lemax,    
      
    size,
    .

########################################################################################################
   :

mular_descriptor *mular;

void
(size_t indx, size_t mindx, mular_indir *idx, int level) {
        // idx -   ( !)
    size_t i;

    if  (indx < mindx || indx > idx->index || level < 1) {
           , 
    } else if (level == 1) {
        if  (  ) {
            for (i = 0; i + mindx < idx->index; i++) {
                (ATERM(*idx, i));                         //     
            }
            (TERM(*idx), i); //        ( )
        } else {
            ATERM(*idx, indx - mindx)                                          //   
        }
    } else {
        ssize_t cont;
        mular_indir *t, *f;
        size_t j, relidx, midx;
                               /****** #1 ******/
        for (i = 0, j = mindx; i < SIZE(level) && ((cont = ICONN(idx, i, t)) >= 0); i++) {
                // i -    idx->next
                // j -      idx->next[i]
                // t -     idx->next[i]
            (indx, j, t, level - 1);  /****** #2 ******/
            if  (t->index > indx) break;   /****** #3 ******/
            if  (!cont) break;
            j = t->index;
        }
        relidx = i++;
        midx = j;
        for (; i < SIZE(level) && cont && ((cont = ICONN(idx, i, f)) >= 0);) {
            __(f, level - 1);
            i++;
            if  (!cont) break;
            j = f->index;
        }
        (indx, midx, t, level - 1);   /****** #3 ******/
}   }
#1  ,     
#2    
#3   ,    

  :

(indx, 0, &mular->top, mular->level);
