#define PT0(P) (*(struct avlt_node**)((uintp)(P) + soff[1 + vi]))
#define PT1(P) (*(struct avlt_node**)((uintp)(P) + soff[1 - vi]))

#define SB0(P) sb[3 + vi*3 + 1 + (P)->vb]
#define SB1(P) sb[3 - vi*3 + 1 + (P)->vb]


struct avlt_node* fu_avltbalance_(struct avlt_node *pc, int vi) {

  const static uintp soff[3] = { (uintp)( &((struct avlt_node*)0)->pl), 0,
                                 (uintp)( &((struct avlt_node*)0)->pr) };

  const static int   sb[9] = { 0, 0,-1,  0, 0, 0,  1, 0, 0 };

  struct avlt_node *p0, *p1;


  if (PT0(pc)->vb == -vi) {

    p0 = PT0(pc);
    p1 = PT1(PT0(pc));
    PT0(pc) = PT1(p1);
    PT1(p0) = PT0(p1);
    PT1(p1) = pc;
    PT0(p1) = p0;

    pc->vb = SB1(p1);
    p0->vb = SB0(p1);
    p1->vb = 0;

  } else {
    /*  PT0(pc)->vb == vi */

    p1 = PT0(pc);
    PT0(pc) = PT1(p1);
    PT1(p1) = pc;

    pc->vb = 0;
    p1->vb = 0;
  }

  return p1;
}

#undef PT0
#undef PT1
#undef SB0
#undef SB1



void fuavlt_add(struct avlt_head *ph, struct avlt_node *pn) {

  const static uintp soff[3] = { (uintp)( &((struct avlt_node*)0)->pl), 0,
                                 (uintp)( &((struct avlt_node*)0)->pr) };

  struct avlt_node*  stn[46]; /* буфера обеспечения возврата */
  int8               std[46];
  struct avlt_node *pc, *p0, **px;
  uint32 va;

  assert(ph != NULL);
  assert(pn != NULL);



  pn->vb = 0;
  pn->pr = NULL;
  pn->pl = NULL;



  if (ph->pt == NULL) {

    ph->pt = pn;
    return;
  }


  for (pc = ph->pt, va = 0; ; va++) {

    if (pn->vk < pc->vk) { std[va] = -1;
    } else {               std[va] =  1;
    }
      /* (void**) */
    px = (void*)((uintp)pc+soff[1 + std[va]]);

    if (*px == NULL) {

      *px = pn; break;
    }

    stn[va] = pc;
    pc = *px;
  }


  for ( ; ; pc = stn[--va]) {

    if ((pc->vb += std[va]) == 0) {
      break;
    }

    if (pc->vb ==  2) {

      p0 = fu_avltbalance_(pc, 1);

      if (va == 0) { ph->pt = p0;
      } else {
        *(void**)((uintp)stn[va-1] + soff[1 + std[va - 1]]) = p0;
      }
      break;

    } else
    if (pc->vb == -2) {

      p0 = fu_avltbalance_(pc, -1);

      if (va == 0) { ph->pt = p0;
      } else {
        *(void**)((uintp)stn[va-1] + soff[1 + std[va - 1]]) = p0;
      }
      break;
    }

    if (va == 0) { break; }
  }

  return;
}