macro ifSkobka z,m {
        cmp  al,z
        jnz  @f
        m
@@:
        }
macro _math_ops f,t { local .ll
        mov eax,[OutCalcMathTxt2]
        cmp dword[eax-4],t
        jnz .ll
        fld dword [sin_flts]
        f
        fstp dword [sin_flts]
.ll:
        }
macro sse_math_ops f,t,mtk { local .ll
        mov eax,[OutCalcMathTxt2]
        cmp dword[eax-5],t
        jnz .ll
        xorps xmm0,xmm0
        xorps xmm1,xmm1
        movss xmm1, dword [sin_flts]
        f
        movss dword [sin_flts],xmm1
        jmp  mtk
.ll:
        }
macro calc_This { local .a,.1
        pusha
        mov dword [cmd_txtOfst+8],ecx
        mov edi,[OutCalcMathTxt2]
        call reshimThis
        
        mov eax,[OutCalcMathTxt2]
        cmp dword [eax-5],'flow'
        jnz .1
        movss xmm1,[sin_flts]
        roundss xmm0,xmm1,9
        subss xmm1,xmm0
        movss [sin_flts],xmm1
        jmp   .a
.1:
sse_math_ops <rsqrtss xmm1,xmm1>,'rsqr',.a        ;inache do 'sqr('
sse_math_ops <roundss xmm1,xmm1,9 >,'flrl',.a
sse_math_ops <roundss xmm1,xmm1,10 >,'flrh',.a
_math_ops fabs,'abs('
_math_ops fsin,'sin('
_math_ops fcos,'cos('
_math_ops fsqrt,'sqr('
.a:
        mov  esi,dword [cmd_txtOfst+8]
        PrintFloat sin_flts,esi
        movd xmm3,eax
        popa
        movd eax,xmm3
        add  ecx,eax
        mov  al,32
        dec  ecx
        }
macro mSkaba { local .1
        ;mov  eax,[cur_OfstFlts]
        ;add [cur_OfstFlts],4
        inc ebx
        mov dword [OutCalcMathTxt2],ebx
        ;mov ah,[cur_Vnum]
        ;inc [cur_Vnum]
        ;mov al,'v'
        ;mov word [ecx],ax
        ;add ecx,2
        ;mov al,32
.1:     ;if_Def  AllMathDefs
        inc ebx
        cmp byte [ebx],')'
        jnz .1
        mov byte [ebx],0
        mov eax,dword [ebx]
        mov dword [ebx],0
        mov word [ebx],'+0'
        mov [cur_OfstFlts],eax
        calc_This
        movss xmm3,[cur_OfstFlts]
        movss [ebx],xmm3
        }
macro GetAll_Defs znk,t { local .l1,.l2,.ee
      mov ecx,AllMathDefs
      mov dword [ecx],0
      mov dword [ecx+4],0
      mov ebx,t
      dec ebx
.l1:  inc ebx
      cmp byte [ebx],0
      jz  .ll
      cmp word [ebx],znk
      jnz .l1
.l2:  inc ebx
      cmp byte [ebx],32
      jnz .l2
      mov [ecx],ebx
      add ecx,4
      jmp .l1
.ll:  cmp dword [ecx-4],0
      jz  .e2
      mov ebx,[ecx-4]
.ee:  inc ebx
      cmp byte [ebx],13
      ja .ee
      add ebx,2
      ;pusha
      ;Msg ebx
      ;Msg dword [AllMathDefs]
      ;Msg dword [AllMathDefs+4]
      ;popa
.e2:
      }
macro get_Eques { local .l,.2
      mov ax,word [edx]
      mov edi,esi
      dec edi
.l:   inc edi
      cmp byte [edi],0
      jz  .2
      cmp word [edi],ax
      jnz .l
        add edi,3
      DoCopy_ edi,ecx,';'
.2:
}
macro DoCopy_ a,b,z { local .1,.2
.1:   mov al,[a]
      cmp al,13
      jbe .2
      cmp al,z
      jz .2             ;jbe
      mov [b],al
      inc  a
      inc  b
      jmp  .1
.2:
      }
macro DoCopy a,b,z,z2,mm { local .1,.1b,.2
.1:   mov al,[a]
      cmp al,z2
      jnz .1b
      mm
.1b:
      cmp al,13
      jbe .2
      cmp al,z
      jz .2             ;jbe
      mov [b],al
      inc  a
      inc  b
      jmp  .1
.2:
      }
macro if_Def t { local .1,.2,.l
      cmp byte [ebx],'#'
      jnz .1
      mov ax,word [ebx+1]
      add ebx,3
      push ebx
      mov  ebx,AllMathDefs-4
.2:   add  ebx,4
      cmp  ebx,AllMathDefs+4000*4
      jae  .l
      mov  edx,[ebx]
      test edx,edx
      jz   .l
      ;pusha
      ;dec edx
      ;Msg edx
      ;popa
      cmp  ax,word [edx-2]
      jnz  .2
      DoCopy edx,ecx,';','@',get_Eques
      ;pusha
      ;Msg 'copy'
      ;popa
.l:
      pop  ebx
.1:   mov al,[ebx]

      }
macro SplitSkobki t,ot { local .01,.1,.2,.3,.4,.uu
        GetAll_Defs '##',t
        cmp   dword [AllMathDefs],0
        jnz   .uu
        mov   ebx,t
.uu:
        mov   esi,t
        ;push ebx
        mov  ecx,UnrollDefsRichMath ;ot
.01:    mov  al,[ebx]
        ;mov  [ecx],al
        if_Def  AllMathDefs     ;copy all text and unroll all defs #
        mov  [ecx],al
        inc  ebx
        inc  ecx
        test  al,al
        jnz  .01
        mov  dword [ecx],0
        ;Msg  UnrollDefsRichMath ;ot
        ;pop  ebx
        mov  ebx,UnrollDefsRichMath
        ;mov  ebx,t
        mov  ecx,ot
.1:     mov  al,[ebx]
        ifSkobka '(',mSkaba
        ;if_Def  AllMathDefs
        mov  [ecx],al
        inc  ebx
        inc  ecx
        test  al,al
        jnz  .1
        mov  dword [ecx],0
       ; Msg  ot ;dla debaga
        mov  edi,ot
        mov     ebx,sin_flts
        }
macro nxtDig t,mtk { local .1,.2
.2:   cmp byte [t],0
      jz  mtk
      inc t
      cmp byte [t],'.'
      jz  .2
      cmp byte [t],'0'
      jb  .1
      cmp byte [t],'9'
      ja  .1
      jmp .2
.1:   dec  t
      }
macro GetZnak t,z {
      cmp byte [t],z
      jnz @f
      mov byte [ecx],z
      inc ecx
@@:
        }
macro GetZnaki t {
      cmp byte [t],'*'
      jnz @f
      mov byte [ecx],'*'
      inc ecx
@@:   cmp byte [t],'+'
      jnz @f
      mov byte [ecx],'+'
      inc ecx
@@:   cmp byte [t],'/'
      jnz @f
      mov byte [ecx],'/'
      inc ecx
@@:   cmp byte [t],')'
      jnz @f
      mov byte [ecx],')'
      inc ecx
@@:
      }
macro IfDigs t { local .1,.2
      ;mov eax,t
      mov edx,cmd_txtOfst
      mov ecx,strng_cmd
.0:   cmp byte [t],'-'
      jz  .e
      cmp byte [t],'0'
      jb  .1
      cmp byte [t],'9'
      ja  .1
.e:   ;mov [edx],eax
      ;add edx,4
      push ecx
      cinvoke sscanf,t,'%f',ebx
      pop ecx
      add ebx,4
      nxtDig t,.ll
.1:   inc t
      ;GetZnaki t
      GetZnak t,'*'
      GetZnak t,'/'
      GetZnak t,'+'
      GetZnak t,')'

      cmp byte [t],0
      jnz .0
.ll:
      }
macro reshi t { local .ii,.a1,.a2,.app,.y1,.y3,.y2,.uu,.yy,.hh
      xorps xmm0,xmm0
      cmp   dword [t+4],'+'
      jnz   .ii
      movss xmm0,[t]
.ii:  mov   eax,t
      cmp   dword [eax+4],'+'
      jnz   .a1
      cmp   dword [eax+4+8],0
      jz   .app
      cmp   dword [eax+4+8],'+'
      jnz   .a2
      addss xmm0,[t+8]
      add   t,8
      jmp   .ii
.a1:  movss xmm1,[eax]
      add   eax,4
      jmp   .y1
.a2:  movss xmm1,[eax+8]
      add   eax,12
.y1:  cmp  dword [eax],0
      jz   .uu                 ;bil xmm0=0 i jmp .uu i xmm1 stal =xmm0
      cmp  dword [eax],'+'
      jz   .y3
      cmp  dword [eax],'/'
      jz   .y2
      mulss xmm1,[eax+4]
      jmp   .yy
.y2:  divss xmm1,[eax+4]
.yy:  add   eax,8
      jmp   .y1
.y3:  ;addss xmm1,[t]
      ;addss xmm1,[eax+4]
      addss  xmm0,xmm1
      cmp    dword [eax+8],0
      jnz    .hh
      addss  xmm0,[eax+4]
      jmp    .uu
.hh:
      sub    eax,4
      mov    t,eax
      jmp .ii
.app: addss xmm0,[eax+8]
.uu:  movss xmm1,xmm0
      ;addss xmm1,xmm0

}
macro GetCurZnak from,to,znk {
      cmp byte [from],znk
      jnz @f
      mov byte [to-4],znk
@@:
      }
macro PrintFloat chVal,kuda {
                       movss xmm1,dword [chVal]
                       cvtss2sd xmm1,xmm1
                       movsd qword [kuda],xmm1
                       cinvoke sprintf,kuda,"%1.8f ", dword [kuda], dword [kuda+4]
                       ;add  esp,4
                       ;Msg     kuda
                 }   
