switch (interrupt_counter)     // to reduce time of function
    {
    case    0:    interrupt_counter=1;        //refresh statuses
            kbd_status3=kbd_status2;
            kbd_status2=kbd_status1;
            kbd_status1=kbd_status0;
            kbd_status0=Kbd;
            interrupt_counter=interrupt_counter;
            break;

    case    1:   interrupt_counter=2;        //check pressed key every tic
            pressed_keys=kbd_status0&kbd_status1&kbd_status2;
            if (pressed_keys&(~kbd_status3))
            if (bSound==SoundAlwaysOn) Beep(5,1);
            found_events|=pressed_keys&(~kbd_status3);        // found edge
            if ((pressed_keys==kUp+kDn)&&  // now this two keys
                ((~kbd_status3)&(kUp+kDn)))//and before it wasn't so
                {found_events|=kUpDn;    // set new bit
                found_events&=~(kUp+kDn);    break; } //reset usual bits
            if ((pressed_keys==kUp+kSt)&&  // now this two keys
                ((~kbd_status3)&(kUp+kSt)))//and before it wasn't so
                {found_events|=kUpSt;    // set new bit
                found_events&=~(kUp+kSt);    break; }//reset usual bits                
            if ((pressed_keys==kDn+kSt)&&  // now this two keys
                ((~kbd_status3)&(kDn+kSt)))//and before it wasn't so
                {found_events|=kDnSt;    // set new bit
                found_events&=~(kDn+kSt); break; }    //reset usual bits                    
        break;            
                
    case    2:    interrupt_counter=3;        //check if key the same as before
            if ((pressed_keys&kUp)||(pressed_keys&kDn))    //key for repeat
            {    if (pressed_keys==old_pressed_keys) // same key?
                {    if (pressed_counter)         // yes, time over?
                    {pressed_counter--;}      //No
                    else     {    pressed_counter=NextDelay;        //Yes
                            found_events=pressed_keys; }        //reset
                    }
                else                                            // other key
                    {pressed_counter=StartDelay;    
                    }
            };
            old_pressed_keys=pressed_keys;
            break;
    case    3:    interrupt_counter++;
              break;
    default: interrupt_counter=0;
  }

__no_init    uint8_t        static    *uFaz1,*uFaz2,*uFaz3,
                                *uFaz4,*uFaz5,*uFaz6;    // Вспомогательный. Указатель на текущую фазу двигателя

// Обработка Шима тех каналов (двигателей) которые отрабатывают угол 45
// вывод уровня 0.707 уровень 2
#pragma    vector=TIMER1_COMPB_vect
__interrupt    static void    pvPWWLvl2(void)
{
// Вывод предварительно расчитанных значений портов
PORTE = bOportE[2];
PORTA = bOportA[2];
PORTC = bOportC[2];
// Предварительный расчёт фаз двигателей. Требуется для фазы C
uint8_t    bFaz;
bFaz = (wStateReal[0] & (MAXFAZ-1))>>2;                // Выделить фазу одного двигателя порта
uFaz1 = &bfPortSh1[0][0]+bFaz;
bFaz = (wStateReal[1] & (MAXFAZ-1))>>2;                // Выделить фазу одного двигателя порта
uFaz2 = &bfPortSh2[0][0]+bFaz;
bFaz = (wStateReal[2] & (MAXFAZ-1))>>2;                // Выделить фазу одного двигателя порта
uFaz3 = &bfPortSh3[0][0]+bFaz;
bFaz = (wStateReal[3] & (MAXFAZ-1))>>2;                // Выделить фазу одного двигателя порта
uFaz4 = &bfPortSh4[0][0]+bFaz;
bFaz = (wStateReal[4] & (MAXFAZ-1))>>2;                // Выделить фазу одного двигателя порта
uFaz5 = &bfPortSh5[0][0]+bFaz;
bFaz = (wStateReal[5] & (MAXFAZ-1))>>2;                // Выделить фазу одного двигателя порта
uFaz6 = &bfPortSh6[0][0]+bFaz;
}

// Обработка Шима тех каналов (двигателей) которые отрабатывают угол 67.5. Расчёт предустановленных значений портов.
// вывод уровня 0.9239 уровень 3
#pragma    vector=TIMER1_COMPC_vect
__interrupt    static void    pvPWWLvl3(void)
{
// Вывод предварительно расчитанных значений портов
PORTE = bOportE[3];
PORTA = bOportA[3];
PORTC = bOportC[3];
// Расчёт предустановленных значений портов.
uint8_t    i, *faz1,*faz2,*faz3,*faz4,*faz5,*faz6;
faz1=uFaz1;
faz2=uFaz2;
faz3=uFaz3;
faz4=uFaz4;
faz5=uFaz5;
faz6=uFaz6;
for(i=0;i<MAXLVLPWW;i++)
{
   bOportE[i] = *faz1++ | *faz2++;                    // сформировать значение порта
   bOportA[i] = *faz3++ | *faz4++;                    // сформировать значение порта
   bOportC[i] = *faz5++ | *faz6++;                    // сформировать значение порта
};
}

//Заменяем массивы на просто переменные
char bOportE0;
char bOportE1;
char bOportE2;
char bOportE3;
char bOportA0;
char bOportA1;
char bOportA2;
char bOportA3;
char bOportC0;
char bOportC1;
char bOportC2;
char bOportC3;
#pragma    vector=TIMER1_COMPC_vect
__interrupt    static void    pvPWWLvl3(void)
{
  PORTE = bOportE3;
  PORTA = bOportA3;
  PORTC = bOportC3;
  uint8_t *faz1,*faz2;
  
  faz1=uFaz1;
  faz2=uFaz2;
  bOportE0=*faz1++|*faz2++;
  bOportE1=*faz1++|*faz2++;
  bOportE2=*faz1++|*faz2++;
  bOportE3=*faz1++|*faz2++;

  faz1=uFaz3;
  faz2=uFaz4;
  bOportA0=*faz1++|*faz2++;
  bOportA1=*faz1++|*faz2++;
  bOportA2=*faz1++|*faz2++;
  bOportA3=*faz1++|*faz2++;
  
  faz1=uFaz5;
  faz2=uFaz6;
  bOportC0=*faz1++|*faz2++;
  bOportC1=*faz1++|*faz2++;
  bOportC2=*faz1++|*faz2++;
  bOportC3=*faz1++|*faz2++;

}

#define LASER_CODE           0
#define TPREVIOUS_POINT      2
#define STATE                4
#define NSPURIOUS            5
#define NSYMBOLS             6
#define FLASER_CODE_DONE     7

  rseg    UDATA0

     Laser_code:         ds   2   ; 0-1
     tPrevious_point:    ds   2   ; 2-3
     State:              ds   1   ; 4
     nSpurious:          ds   1   ; 5
     nSymbols:           ds   1   ; 6
     fLaser_code_done:   ds   1   ; 7
...

  rseg    RCODE
    ...
    ldi   r30, low(Laser_code)
    ldi   r31,high(Laser_code)
    ...
    ldd   r18,Z+TPREVIOUS_POINT        ;  load previous point
    ldd   r19,Z+TPREVIOUS_POINT + 1    ;
    ...
    ldd   r18,Z+STATE                  ; load state
    ...
    ldd   r18,Z+LASER_CODE   ; load laser code
    ldd   r19,Z+LASER_CODE+1 ;
    ror   r19                ; modify laser code
    ror   r18                ;
    std   Z+LASER_CODE,r18   ; store laser code
    std   Z+LASER_CODE+1,r19 ;
    ...
    std   Z+TPREVIOUS_POINT,r20   ; store current point as previous
    std   Z+TPREVIOUS_POINT+1,r21 ;
                             ;
    ldd   r18,Z+NSYMBOLS     ;
    inc   r18                ; inc nSymbols
    std   Z+NSYMBOLS,r18     ;
    ...
    ldd   r18,Z+NSPURIOUS              ;  inc nSpurious
    inc   r18                          ;
    std   Z+NSPURIOUS,r18              ;
    ...