int16_t Xarg,Yarg,Zarg;
........................
Zarg= (Xarg*Yarg) >>16;

lds r16,Xarg
lds r17,Xarg+1
lds r18,Yarg
lds r19,Yarg+1
clr r6 //9
// дальше стандартное знаковое умножение
muls r17,19
movw r4,r0
mul 16,r18
movw r2,r0
mulsu r19,r16
sbc r5,r6
add r3,r0
adc r4,r1
adc r5,r6
mulsu r17,r18
sbc r5,r6
add r3,r0
adc r4,r1
adc r5,r6
// и выделение старшей части 32-битного результата
sts Zarg,r4
sts Zarg+1,r5
// итого 22+9 = 31 такт

static int16_t TR1=-1039; TR0=0;
static uint8_t TR2=30;
.........<skipped>...........................
for(;;)
{
TR0 = (TR1*TR2)>>8;
..<skipped>...............
}

103:      TR0 = (TR1*TR2)>>8;
+00000833:   91800200    LDS     R24,0x0200       Load direct from data space
+00000835:   91900201    LDS     R25,0x0201       Load direct from data space
+00000837:   019C        MOVW    R18,R24          Copy register pair
+00000838:   E065        LDI     R22,0x05         Load immediate
+00000839:   0F22        LSL     R18              Logical Shift Left
+0000083A:   1F33        ROL     R19              Rotate Left Through Carry
+0000083B:   956A        DEC     R22              Decrement
+0000083C:   F7E1        BRNE    PC-0x03          Branch if not equal
+0000083D:   0F88        LSL     R24              Logical Shift Left
+0000083E:   1F99        ROL     R25              Rotate Left Through Carry
+0000083F:   1B28        SUB     R18,R24          Subtract without carry
+00000840:   0B39        SBC     R19,R25          Subtract with carry
+00000841:   2F23        MOV     R18,R19          Copy register
+00000842:   0F33        LSL     R19              Logical Shift Left
+00000843:   0B33        SBC     R19,R19          Subtract with carry
+00000844:   9330031A    STS     0x031A,R19       Store direct to data space
+00000846:   93200319    STS     0x0319,R18       Store direct to data space

LDS     R24,0x0200//       Load direct from data space
LDS     R25,0x0201//       Load direct from data space
LDI      R18,0x1E// я не говорю о том, что здесь не западло и LDS оставить и не оптимизировать ненужное
// было 5 тактов
mul r24,r18
movw r2,r0
mulsu  r25,r18
ldi  r18,0
sbc r1,r18
add r0,r3
adc r1,r18
//14
STS     0x031A,R1       Store direct to data space
STS     0x0319,R0       Store direct to data space
//18

#define arg1L  r16
#define arg1H r17
#define scalar r18
#define NULL_REG r6
scale16x8:
  clr       NULL_REG
//...........................
  mul     arg1L,scalar
  mov    r2,r1
  mulsu  arg1H,scalar
  adc     r0,r2
  adc     r1,NULL_REG

; result in r0:r1

static inline uint16_t scale16x8(uint16_t a, uint8_t b)
{
    uint16_t result;
    uint8_t tmp;
/*
%A0 - low byte of result,
%B0 - hi byte of result,
%1  - tmp
%A2 - low byte of the first operand,
%B2 - hi byte of the first operand,
%3 - second operand
*/

    asm (
        "clr    %1 \n\t"
        "mul    %A2,%3 \n\t"
        "mov    r2,r1 \n\t"
        "mulsu    %B2,%3 \n\t"
        "adc    r0,r2 \n\t"
        "adc    r1,%1 \n\t"
        "movw    %A0, r0 \n\t"
        "clr    __zero_reg__ \n\t"
        : "=&r" (result), "=&r" (tmp)
        : "a" (a), "a" (b)
    );

    return result;
}

int scale_test(void)
{
    uint16_t a = 0;
    uint8_t b = 0;
    while (TRUE)
    {
        if (scale16x8(a, b) != ((unsigned long)a*b/256))
        {
            nokia_puts_p("a = ");
            nokia_put_word(a);
            nokia_puts_p(",  b = ");
            nokia_put_word(b);
            return FALSE;
        }
        if (a == 0xFFFF && b == 0xFF) return TRUE;
        if (!++b) a++;
    }
}

static inline int16_t scale16x8(int16_t a, uint8_t b)
{
    int16_t result;
    uint8_t tmp;
/*
%A0 - low byte of result,
%B0 - hi byte of result,
%1  - tmp
%A2 - low byte of the first operand,
%B2 - hi byte of the first operand,
%3 - second operand
*/

    asm (
        "clr    %1 \n\t"
        "mul    %A2,%3 \n\t"
        "mov    r2,r1 \n\t"
        "mulsu    %B2,%3 \n\t"
        "adc    r0,r2 \n\t"
        "adc    r1,%1 \n\t"
        "movw    %A0, r0 \n\t"
        "clr    __zero_reg__ \n\t"
        : "=&r" (result), "=&r" (tmp)
        : "a" (a), "a" (b)
    );

    return result;
}

int scale_test(void)
{
    int16_t i = -32768;
    uint8_t b = 0;
    int16_t i1, i2;
    while (TRUE)
    {
        i1 = scale16x8(i, b);
        i2 = (signed long)i*b/256;
        if (i1 != i2)
        {
            nokia_puts_p("   a = ");
            nokia_put_int(i);
            nokia_puts_p(",   b = ");
            nokia_put_word(b);
            return FALSE;
        }
        b++;
        if (!b)
        {
            i++;
        }
        if ((i == 32767) && (b == 0xFF)) break;
    }
    return TRUE;
}

#define PWM_OFFSET 512
uint8_t wrk;
int16_t generator_out;

//................................
// having outgoing milestone :)

// read ADC
wrk=ADCH;
// output
OCR1=scale16x8(generator_out,wrk)+ PWM_OFFSET;

i2 = (signed long)i*b/256;

    int16_t i1;
    int16_t i2;
    i1 = scale16x8(i, b);
    i2 = (signed long)i*b/256;
...
    nokia_put_int(i1);
    nokia_put_int(i2);