
  References to the various Central Processing Units (CPUs) as the "86"
refers to either the 8088, 8086, 80186, 80286, etc.
  References to the various coProcessors as the "87"
refers to either the 8087, the 287, the 387, or the special IIT-2C87 processor.

        The 8087 and 287 coProcessors (FPU)

  All IBM-PC's, and most clones, contain a socket for a floating
point coprocessor.  If you shell out between $80 and $300, and
plug the appropriate chip into that socket, then a host of
floating point instructions is added to the assembly language
instruction set.

  The original IBM-PC, and the XT, accept the original floating
point chip, the 8087.  The AT accepts a later update, the 287.
  From a programming standpoint, the two chips are nearly
identical: the 287 adds the instructions
                   FSETPM
               and
                   FSTSW AX,
               and
ignores the instructions
                   FENI
               and
                   FDISI.
  There is, however, a rather nasty design flaw in the 8087,
that was corrected in the 287.

  To understand the flaw, you must understand how the 86 and 87
work as coprocessors. Whenever the 86 sees a floating point
instruction, it communicates the instruction, and any associated
memory operands, to the 87.
  Then the 86 goes on to its next instruction, operating in parallel
with the 87.
  That's OK, so long as the following instructions don't
do one of the following:

  1. Execute another floating point instruction;
or
  2. Try to read the results of the still-executing floating
     point instruction.

  If they do, then you must provide an instruction called WAIT (or
synonymously FWAIT), which halts the 86 until the 87 is finished.
  For almost all floating point instructions, it should not be
necessary to provide an explicit FWAIT; the 86 ought to know that
it should wait.  For the 8087, it IS necessary to give an
explicit FWAIT before each floating point instruction: that is
the flaw.

  Because of the flaw, all assemblers supporting the 8087 will
silently insert an FWAIT code (hex 9B) before all 87
instructions, except those few (the FN instructions other than
FNOP) not requiring the FWAIT.  

* Microsoft recognizes the new 287 instructions, if and only if
  it sees the .287 directive. In general, don't attempt to police
  your instruction usage -- if you use an instruction available on a
  limited number of processors, I trust that you are programming
  for one of those processors.

  In summary, if your program will be running only on machines with
a 287, you can give ".287" directive. Your programs will be
significantly shorter than if they were assembled by Microsoft.
If you want your programs to run on all machines containing a
floating point chip, you should refrain from specifying .287.

  WARNING: The most common mistake 87 programmers make is to try to
read the results of an 87 operation in 86 memory, before the
results are ready.  At least on my AT, the system often crashes
when you do this!  If your program runs correctly when single
stepped, but crashes when set loose, then chances are you need an
extra explicit FWAIT somewhere.


           Emulating the 8087 by Software

  There is a software package provided with many compilers
(Borland's Turbo C and most Microsoft compilers, for example)
that emulates the 8087 instruction set.  The emulator is very
cleverly implemented so that the programmer need not know whether
a floating point chip will be available, or whether emulation
will be necessary.  This is done by having the linker replace all
floating point machine instructions with INT calls to certain
interrupts, dedicated to emulation.  The interrupt handlers
interpret the operands to the instructions, and emulate the 8087.

              The Floating Point Stack

  The 87 has its own register set, of 8 floating point numbers
occupying 10 bytes each, plus 14 bytes of status and control
information.
  Many of the 87's instructions cause the numbers to act like a stack,
much like a Hewlett-Packard calculator. For this reason, the
numbers are called the floating point stack.

  The standard name for the top element of the floating point stack
is either ST or ST(0); the others are named ST(1) through ST(7).
Thus, for example, the instruction to add stack element number 3
into the top stack element is usually coded FADD ST,ST(3).


              Floating Point Initializations

  In general, you use the 87 by loading numbers from 86 memory to
the 87 stack
                 (using FLD
                             instructions),
calculating on the 87 stack, and storing the results
back to 86 memory
                 (using FST
                    and
                        FSTP instructions).

  There are seven constant numbers built into the 87 instruction set:
        zero, one, Pi,
    and
        four logarithmic conversion constants.

  These can be loaded using the

    FLD0,    ; ST0 <- 0
    FLD1,    ; ST0 <- 1
    FLDPI,   ; ST0 <- PI
    FLDL2T,  ; ST0 <- log2(10)
    FLDL2E,  ; ST0 <- log2(E)
    FLDLG2,  ; ST0 <- log10(2)
and FLDLN2   ; ST0 <- ln(2)

instructions.

  All other constants must be declared in, then loaded from, 86 memory.
Integer constant words and doublewords can be loaded via

    FILD dword []  ; ST0 <- Цел32 // 2x2w = 4 байта

Non-integer constant doubleword, quadwords, and ten-byte numbers
can be loaded via

    FLD  qword []  ; ST0 <- Вещ64 // 4x2w = 8 байт
    FLD  tword []  ; ST0 <- Вещ80 //      =10 байт


            Floating Point Operand Types

  The list of floating point instructions contains a variety of
operand types.  Here is a brief explanation of those types:

0        stands for the top element of the floating point stack.
         A synonym for 0 is ST or ST(0).

i        stands for element number i of the floating point stack.
         i can range from 0 through 7.  A synonym for i is ST(i).

mem10r   is a 10-byte memory quantity (typically declared with a
         DT directive) containing a full precision floating point
         number.

   Intel recommends that you NOT store your numbers in full precision;

         that you use the following double precision format instead.
    Full precision numbers are intended for storage of intermediate
         results (on the stack);
         they exist to insure maximum accuracy for calculations on
         double precision numbers, which is the
         official external format of 87 numbers.

mem8r    is an 8-byte memory quantity (typically declared with a
         DQ directive) containing a double precision floating
         point number.  This is the best format for floating
         point numbers on the 87.  The 87 takes the same amount
         of time on double precision calculations as it does on
         single precision.  The only extra time is the memory
         access of 4 more bytes; negligible in comparison to the
         calculation time.

mem4r    is a 4-byte quantity (typically defined with a DD
         directive) containing a single precision floating point
         number.

mem10d   is a 10-byte quantity (also defined via DT) containing a
         special Binary Coded Decimal format recognized by the
         FBLD and FBSTP instructions.  This format is useful for
         input and output of floating point numbers.

mem4i    is a 4-byte quantity representing a signed integer in
         two's-complement notation (во 2-й дополнительной записи).

mem2i    is a 2-byte quantity representing a signed integer in
         two's-complement notation (во 2-й дополнительной записи).

mem14    and mem94 are 14- and 94-byte buffers containing the 87
         machine state.

                   The 87 Instruction Set

  Following is the 87 instruction set.  The "w" in the opcode field
is the FWAIT opcode, hex 9B, which is suppressed if .287 is selected.
  Again, "0", "1", and "i" stand for the associated floating point
stack registers, not constant numbers!
  Constant numbers in the descriptions are given with decimal points:
0.0, 1.0, 2.0, 10.0.


    OpCode    Instruction  ;   Description

 w  D9 F0     F2XM1        ; ST0 <- (2.0 ** ST0) - 1.0  // = 2^x - 1
 w  DB F1     F4X4         ;  IIT only: 4 by 4 matrix multiply
 w  D9 E1     FABS         ; ST0 := |ST0| - МОДУЛЬ(ST0) //или абсолютная величина ST0

 w  D8 /0     FADD mem4r   ; ST0 := ST0 + mem4r или ST0+=mem4r - добавить mem4r к ST0    // - увеличение ST0 на mem4r
 w  DC /0     FADD mem8r   ; ST0 := ST0 + mem8r или ST0+=mem8r - добавить mem8r к ST0    // - увеличение ST0 на mem8r
 w  D8 C0+i   FADD STi     ; ST0 := ST0 + STi или ST0+=STi - добавить STi к ST0
 w  DC C0+i   FADD STi,ST0 ; STi := STi + ST0 или STi+=ST0 - добавить ST0 к STi
 w  D8 C0+i   FADD ST0,STi ; ST0 := ST0 + STi или ST0+=STi - добавить STi к ST0 //возможен повтор, как бы в цикле

 w  DE C1     FADD         ; ST1 := ST1 + ST0 или ST1+=ST0 - добавить ST0 к ST1
 w  DE C0+i   FADDP STi,ST0; STi := STi + ST0 или STi+=ST0 - добавить ST0 к STi, pop - взять ST0 из стэка FPU, т.е. ST0 <- ST1

 w  DB E8     FBANK 0      ;  IIT only: set bank pointer to default
 w  DB EB     FBANK 1      ;  IIT only: set bank pointer to bank 1
 w  DB EA     FBANK 2      ;  IIT only: set bank pointer to bank 2

 w  DF /4     FBLD mem10d  ;  push - затолкать в стэк FPU, ST0 := mem10d
 w  DF /6     FBSTP mem10d ;  mem10d := ST0, pop - взять из стэка FPU

 w  D9 E0     FCHS         ; ST0 := -ST0 //минус ST0 (инверсия знака)

9B  DB E2     FCLEX        ;  clear exceptions
 w  D8 D1     FCOM         ;  compare ST0 - ST1 # 0
 w  D8 D0+i   FCOM ST0,STi ;  compare ST0 - STi
 w  D8 D0+i   FCOM STi     ;  compare ST0 - STi
 w  D8 /2     FCOM mem4r   ;  compare ST0 - mem4r
 w  DC /2     FCOM mem8r   ;  compare ST0 - mem8r
 w  D8 D9     FCOMP        ;  compare ST0 - ST1 # 0, pop - взять ST0 из стэка FPU, т.е. ST0 <- ST1
 w  D8 D8+i   FCOMP ST0,STi;  compare ST0 - STi # 0, pop - взять ST0 из стэка FPU, т.е. ST0 <- ST1
 w  D8 D8+i   FCOMP STi    ;  compare ST0 - STi # 0, pop - взять ST0 из стэка FPU, т.е. ST0 <- ST1
 w  D8 /3     FCOMP mem4r  ;  compare ST0 - mem4r # 0, pop - взять ST0 из стэка FPU, т.е. ST0 <- ST1
 w  DC /3     FCOMP mem8r  ;  compare ST0 - mem8r # 0, pop - взять ST0 из стэка FPU, т.е. ST0 <- ST1
 w  DE D9     FCOMPP       ;  compare ST0 - ST1 # 0, pop both - взять оба из стэка FPU, т.е. ST0 <- ST2, ST1 <- ST3
 w  D9 FF     FCOS         ;  387 only: push - затолкать в стэк FPU, 1/0 := cosine(old 0)
 w  D9 F6     FDECSTP      ;  decrement stack pointer
 w  DB E1     FDISI        ;  disable interrupts (.287 ignore)
//         ; прямое деление  ST0 := ST0 / x  (одноместное ST0/=x)              - уменьшение ST0 в x раз
 w  D8 /6     FDIV mem4r   ; ST0 := ST0 / mem4r или ST0/=mem4r - уменьшить ST0 в mem4r раз //прямое деление (ST0/=x)
 w  DC /6     FDIV mem8r   ; ST0 := ST0 / mem8r или ST0/=mem8r - уменьшить ST0 в mem8r раз
 w  D8 F0+i   FDIV STi     ; ST0 := ST0 / STi   или ST0/=STi   - уменьшить ST0 в STi раз
//         ; прямое деление    x :=   x / y  (двуместное    x/=y)              - уменьшение x в y раз
 w  DC F8+i   FDIV STi,ST0 ; STi := STi / ST0   или STi/=ST0 - уменьшить STi в ST0 раз
 w  D8 F0+i   FDIV ST0,STi ; ST0 := ST0 / STi   или ST0/=STi - уменьшить ST0 в STi раз //возможен повтор, как бы в цикле
//         ; прямое деление  ST1 := ST1 / ST0                                  - уменьшение ST1 в ST0 раз
 w  DE F9     FDIV         ; ST1 := ST1 / ST0   или ST1/=ST0 - уменьшить ST1 в ST0 раз
//         ; прямое деление  STi := STi / ST0                                  - уменьшение STi в ST0 раз
 w  DE F8+i   FDIVP STi,ST0; STi := STi / ST0   или STi/=ST0 - уменьшить STi в ST0 раз, pop - взять ST0 из стэка FPU, т.е. ST0 <- ST1
//         ;обратное деление ST0 :=     x / ST0        (одноместное ST0=x/ST0) - обычное деление
 w  D8 /7     FDIVR mem4r  ; ST0 := mem4r / ST0 //обратное деление (ST0=x/ST0)
 w  DC /7     FDIVR mem8r  ; ST0 := mem8r / ST0
 w  D8 F8+i   FDIVR STi    ; ST0 :=   STi / ST0
//         ;обратное деление   x :=     y / x          (двуместное    x=y/x)   - обычное деление
 w  DC F0+i   FDIVR STi,ST0; STi :=   ST0 / STi
 w  D8 F8+i   FDIVR ST0,STi; ST0 :=   STi / ST0 //                                              //возможен повтор, как бы в цикле
//         ;обратное деление ST1 := ST0 / ST1                                  - обычное деление
 w  DE F1     FDIVR        ; ST1 := ST0 / ST1   //обратное деление (ST1=ST0/ST1)
//         ;обратное деление STi := ST0 / STi          (двуместное    x=y/x)   - обычное деление
 w  DE F0+i   FDIVRP STi,ST0; STi:= ST0 / STi   //обратное деление (ST1=ST0/ST1), pop - взять ST0 из стэка FPU, т.е. ST0 <- ST1

 w  DB E0     FENI         ;  enable interrupts (.287 ignore)
 w  DD C0+i   FFREE STi    ;  empty STi

 w  DE /0     FIADD mem2i  ; ST0 := ST0 + mem4i
 w  DA /0     FIADD mem4i  ; ST0 := ST0 + mem2i
 w  DE /2     FICOM mem2i  ;  compare ST0 - mem2i # 0
 w  DA /2     FICOM mem4i  ;  compare ST0 - mem4i
 w  DE /3     FICOMP mem2i ;  compare ST0 - mem2i, pop - взять из стэка FPU
 w  DA /3     FICOMP mem4i ;  compare ST0 - mem4i, pop - взять из стэка FPU
 w  DE /6     FIDIV mem2i  ; ST0 := ST0 / mem2i
 w  DA /6     FIDIV mem4i  ; ST0 := ST0 / mem4i
 w  DE /7     FIDIVR mem2i ; ST0 := mem2i / ST0
 w  DA /7     FIDIVR mem4i ; ST0 := mem4i / ST0
 w  DF /0     FILD mem2i   ;  push - затолкать в стэк FPU, ST0 := mem2i
 w  DB /0     FILD mem4i   ;  push - затолкать в стэк FPU, ST0 := mem4i
 w  DF /5     FILD mem8i   ;  push - затолкать в стэк FPU, ST0 := mem8i
 w  DE /1     FIMUL mem2i  ; ST0 := ST0 * mem2i
 w  DA /1     FIMUL mem4i  ; ST0 := ST0 * mem4i
 w  D9 F7     FINCSTP      ;  increment stack pointer
9B  DB E3     FINIT        ;  initialize 87
 w  DF /2     FIST mem2i   ;  mem2i := ST0 - списать из ST0 в Цел16
 w  DB /2     FIST mem4i   ;  mem4i := ST0 - списать из ST0 в Цел32
 w  DF /3     FISTP mem2i  ;  mem2i := ST0 - списать из ST0 в Цел16, pop - взять из стэка FPU
 w  DB /3     FISTP mem4i  ;  mem4i := ST0 - списать из ST0 в Цел32, pop - взять из стэка FPU
 w  DF /7     FISTP mem8i  ;  mem8i := ST0 - списать из ST0 в Цел64, pop - взять из стэка FPU
 w  DE /4     FISUB mem2i  ; ST0 := ST0 - mem2i - вычесть Цел16
 w  DA /4     FISUB mem4i  ; ST0 := ST0 - mem4i - вычесть Цел32
 w  DE /5     FISUBR mem2i ; ST0 := mem2i - ST0 - вычесть от Цел16
 w  DA /5     FISUBR mem4i ; ST0 := mem4i - ST0 - вычесть от Цел32

 w  D9 C0+i   FLD STi      ;  push - затолкать в стэк FPU, ST0 := old STi - списать в ST0 из STi
 w  DB /5     FLD mem10r   ;  push - затолкать в стэк FPU, ST0 := mem10r  - списать в ST0
 w  D9 /0     FLD mem4r    ;  push - затолкать в стэк FPU, ST0 := mem4r   - списать в ST0
 w  DD /0     FLD mem8r    ;  push - затолкать в стэк FPU, ST0 := mem8r   - списать в ST0
 w  D9 E8     FLD1         ;  push - затолкать в стэк FPU, ST0 := 1.0     - списать в ST0 <- 1.0
 w  D9 /5     FLDCW mem2i  ;  control word := mem2i
 w  D9 /4     FLDENV mem14 ;   environment := mem14
 w  D9 EA     FLDL2E       ;  push - затолкать в стэк FPU, ST0 := log2(e)
 w  D9 E9     FLDL2T       ;  push - затолкать в стэк FPU, ST0 := log2(10.0)
 w  D9 EC     FLDLG2       ;  push - затолкать в стэк FPU, ST0 := log10(2.0)
 w  D9 ED     FLDLN2       ;  push - затолкать в стэк FPU, ST0 := ln(2.0)
 w  D9 EB     FLDPI        ;  push - затолкать в стэк FPU, ST0 := Pi
 w  D9 EE     FLDZ         ;  push - затолкать в стэк FPU, ST0 := +0.0    - списать в ST0 <- 0.0

 w  D8 /1     FMUL mem4r   ; ST0 := ST0 * mem4r или ST0*=mem4r - умн. ST0 на Вещ32    // - увеличение ST0 в mem4r раз
 w  DC /1     FMUL mem8r   ; ST0 := ST0 * mem8r или ST0*=mem8r - умн. ST0 на Вещ64    // - увеличение ST0 в mem8r раз
 w  D8 C8+i   FMUL STi     ; ST0 := ST0 * STi или ST0*=STi - умн. ST0 на STi
 w  DC C8+i   FMUL STi,ST0 ; STi := STi * ST0 или STi*=ST0 - умн. STi на ST0
 w  D8 C8+i   FMUL ST0,STi ; ST0 := ST0 * STi или ST0*=STi - умн. ST0 на STi //возможен повтор, как бы в цикле

 w  DE C9     FMUL         ; ST1 := ST1 * ST0 или ST1*=ST0 - умн. ST1 на ST0
 w  DE C8+i   FMULP STi,ST0; STi := STi * ST0 = [ST0.STi]  - умн. STi на ST0, pop - взять ST0 из стэка FPU, т.е. ST0 <- ST1

    DB E2     FNCLEX       ;  nowait clear exceptions
    DB E1     FNDISI       ;  disable interrupts (.287 ignore)
    DB E0     FNENI        ;  enable interrupts (.287 ignore)
    DB E3     FNINIT       ;  nowait initialize 87
 w  D9 D0     FNOP         ;  no operation
    DD /6     FNSAVE mem94 ;  mem94 := 87 state
    D9 /7     FNSTCW mem2i ;  mem2i := control word
    D9 /6     FNSTENV mem14;  mem14 := environment
    DF E0     FNSTSW AX    ;  AX := status word
    DD /7     FNSTSW mem2i ;  mem2i := status word

 w  D9 F3     FPATAN       ; ST0 := arctan(ST1/ST0), pop - взять из стэка FPU
 w  D9 F8     FPREM        ; ST0 := REPEAT(ST0 - ST1) - последовательное вычитание ST1 из ST0 в цикле 
 w  D9 F5     FPREM1       ;  387 only: ST0 := REPEAT(ST0 - ST1) IEEE compat.
 w  D9 F2     FPTAN        ;            push - затолкать/занести в стэк FPU, ST1/ST0 := tan(old ST0)
 w  D9 FC     FRNDINT      ; ST0 := round(ST0) - округление до Целого64
 w  DD /4     FRSTOR mem94 ;  87 state := mem94
 w  DD /6     FSAVE mem94  ;  mem94 := 87 state
 w  D9 FD     FSCALE       ; ST0 := ST0 * 2.0 ** ST1
9B  DB E4     FSETPM       ;  set protection mode
 w  D9 FE     FSIN         ;  387 only: push - затолкать/занести в стэк FPU, ST1/ST0 := sin(old ST0)
 w  D9 FB     FSINCOS      ;  387 only: push - затолкать/занести в стэк FPU,     ST1 := sin ,   ST0 := cos(old ST0)

 w  D9 FA     FSQRT        ; ST0 := square root of ST0 - кв.корень из ST0

 w  D9 /2     FST mem4r    ;  mem4r := ST0 - списать из ST0 в память86 //сохранить в Вещ32
 w  DD /2     FST mem8r    ;  mem8r := ST0 - списать из ST0 в память86 //сохранить в Вещ64

 w  D9 /7     FSTCW mem2i  ;  mem2i := control word //сохранить управляющее слово в Цел16 
 w  D9 /6     FSTENV mem14 ;  mem14 := environment  //сохранить среду 14 байтах

 w  DD D0+i   FST STi      ; STi := ST0 - списать из ST0 в STi //сохранить 
 w  DD D8+i   FSTP STi     ; STi := ST0 - списать из ST0 в STi //сохранить, pop - взять из стэка FPU 

 w  DB /7     FSTP mem10r  ;  mem10r:= ST0 - списать из ST0 в память86 //сохранить в Вещ80, pop - взять из стэка FPU
 w  DD /3     FSTP mem8r   ;  mem8r := ST0 - списать из ST0 в память86 //сохранить в Вещ64, pop - взять из стэка FPU
 w  D9 /3     FSTP mem4r   ;  mem4r := ST0 - списать из ST0 в память86 //сохранить в Вещ32, pop - взять из стэка FPU

 w  DF E0     FSTSW AX     ;  AX := status word     //сохранить слово состояние в рег.AX 
 w  DD /7     FSTSW mem2i  ;  mem2i := status word  //сохранить слово состояние в  Цел16

 w  D8 /4     FSUB mem4r   ; ST0 := ST0 - mem4r или ST0-=mem4r - отнять mem4r от ST0    // - уменьшение ST0 на mem4r
 w  DC /4     FSUB mem8r   ; ST0 := ST0 - mem8r или ST0-=mem8r - отнять mem8r от ST0    // - уменьшение ST0 на mem8r
 w  D8 E0+i   FSUB STi     ; ST0 := ST0 - STi или ST0-=STi - отнять STi от ST0
 w  DC E8+i   FSUB STi,ST0 ; STi := STi - ST0 или STi-=ST0 - отнять ST0 от STi
 w  D8 E0+i   FSUB ST0,STi ; ST0 := ST0 - STi или ST0-=STi - отнять STi от ST0 //возможен повтор, как бы в цикле

 w  DE E9     FSUB         ; ST1 := ST1 - ST0 или ST1-=ST0 - отнять ST0 от ST1
 w  DE E8+i   FSUBP STi,ST0; STi := STi - ST0 или STi-=ST0 - отнять ST0 от STi, pop - взять ST0 из стэка FPU, т.е. ST0 <- ST1

 w  D8 E8+i   FSUBR STi    ; ST0 := STi - ST0  //обратное вычитание (со знаком "-")
 w  DC E0+i   FSUBR STi,ST0; STi := ST0 - STi
 w  D8 E8+i   FSUBR ST0,STi; ST0 := STi - ST0
 w  D8 /5     FSUBR mem4r  ; ST0 := mem4r - ST0
 w  DC /5     FSUBR mem8r  ; ST0 := mem8r - ST0
 w  DE E1     FSUBR        ; ST1 := ST0 - ST1  //обратное вычитание (со знаком "-"), pop - взять из стэка FPU
 w  DE E0+i   FSUBRP STi,ST0; STi:= ST0 - STi                                      , pop - взять из стэка FPU

 w  D9 E4     FTST         ;  compare ST0 - 0.0

 w  DD E0+i   FUCOM i      ;  387 only: unordered compare 0 - i
 w  DD E1     FUCOM        ;  387 only: unordered compare 0 - 1
 w  DD E8+i   FUCOMP i     ;  387 only: unordered compare 0 - i, pop - взять из стэка FPU
 w  DD E9     FUCOMP       ;  387 only: unordered compare 0 - 1, pop - взять из стэка FPU
 w  DA E9     FUCOMPP      ;  387 only: unordered compare 0 - 1, pop both - взять оба из стэка FPU
9B            FWAIT        ;  wait for 87 ready
 w  D9 E5     FXAM         ;  C3 -- C0 := type of 0
                                                   - рокировка номеров (или содержимого) регистов
 w  D9 C9     FXCH         ;  обмен (рокировка) содержимым ST0 и ST1 //ST0 <-> ST1
 w  D9 C8+i   FXCH STi     ;  обмен (рокировка) содержимым ST0 и STi //ST0 <-> STi
 w  D9 C8+i   FXCH STi,ST0 ;  обмен (рокировка) содержимым STi и ST0 //STi <-> ST0
 w  D9 C8+i   FXCH ST0,STi ;  обмен (рокировка) содержимым ST0 и STi //ST0 <-> STi  //повтор

 w  D9 F4     FXTRACT      ;  push - затолкать в стэк FPU, ST1 := expo, ST0 := sig

 w  D9 F1     FYL2X        ; ST0 := ST1 * log2(ST0    ), pop - взять из стэка FPU
 w  D9 F9     FYL2XP1      ; ST0 := ST1 * log2(ST0+1.0), pop - взять из стэка FPU
