code.inc

Переключить прокрутку окна
Загрузить этот исходный код

;
  ; Динамически подключаемая библиотека avo. Версия 1.0.
  ; Реализация векторных операций.
  ; Поддержка комплексных чисел, кватернионов и октонионов.
  ;
  ; Copyright © 2026 Малик Разработчик
  ;
  ; Это свободная программа: вы можете перераспространять ее и/или изменять
  ; ее на условиях Меньшей Стандартной общественной лицензии GNU в том виде,
  ; в каком она была опубликована Фондом свободного программного обеспечения;
  ; либо версии 3 лицензии, либо (по вашему выбору) любой более поздней версии.
  ;
  ; Эта программа распространяется в надежде, что она будет полезной,
  ; но БЕЗО ВСЯКИХ ГАРАНТИЙ; даже без неявной гарантии ТОВАРНОГО ВИДА
  ; или ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННЫХ ЦЕЛЕЙ. Подробнее см. в Меньшей Стандартной
  ; общественной лицензии GNU.
  ;
  ; Вы должны были получить копию Меньшей Стандартной общественной лицензии GNU
  ; вместе с этой программой. Если это не так, см.
  ; <https://www.gnu.org/licenses/>.
;

; <fold проверка поддержки AVX-512>
                function    IsAVX512SupportedByCPU
                push        rbx
                mov         eax,  $00000001
                cpuid
                and         ecx,  $10000001 ; SSE3 [бит 0], AVX [бит 28]
                cmp         ecx,  $10000001
                jne         @F
                mov         eax,  $00000007
                mov         ecx,  $00000000
                cpuid
                and         ebx,  $80030020 ; AVX2 [бит 5], AVX512F [бит 16], AVX512DQ [бит 17], AVX512VL [бит 31]
                cmp         ebx,  $80030020
                jne         @F
                mov         eax,  $00000001
                jmp         .exit
         @@:    xor         eax,  eax
      .exit:    pop         rbx
                ret

                function    IsAVX512SupportedByOS
                push        rbx
                mov         eax,  $00000001
                cpuid
                test        ecx,  $08000000 ; инструкция XGETBV включена операционной системой?
                jz          @F
                xor         ecx,  ecx
                xgetbv
                and         eax,  $000000e7 ; состояние регистров FPU, SSE, AVX и AVX-512 сохраняется операционной системой при переключении контекстов?
                cmp         eax,  $000000e7
                jne         @F
                mov         eax,  $00000001
                jmp         .exit
         @@:    xor         eax,  eax
      .exit:    pop         rbx
                ret
; </fold>

; <fold побитовое «и»>
                function    BitAndByte2
                movzx       eax,   word   [val1]
                movzx       iVal2, word   [val2]
                and         eax,   iVal2
                mov         word   [res], ax
                ret

                function    BitAndByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpand       xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    BitAndByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpand       xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    BitAndShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpand       xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    BitAndInt8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpand       ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    BitAndLong8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vpandq      zmm0, zmm0, zmm1
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold побитовое «не»>
                function    BitNotByte2
                movzx       eax,  word  [val]
                not         eax
                mov         word  [res], ax
                ret

                function    BitNotByte4
                vmovd       xmm0, [val]
                vpxor       xmm0, xmm0, [byte8.mask4]
                vmovd       dword [res], xmm0
                ret

                function    BitNotByte8
                vmovq       xmm0, [val]
                vpxor       xmm0, xmm0, [byte8.mask8]
                vmovq       qword [res], xmm0
                ret

                function    BitNotShort8
                vmovdqu     xmm0, [val]
                vpxor       xmm0, xmm0, [short8.mask8]
                vmovdqu     xword [res], xmm0
                ret

                function    BitNotInt8
                vmovdqu     ymm0, [val]
                vpxor       ymm0, ymm0, [int8.m1]
                vmovdqu     yword [res], ymm0
                ret

                function    BitNotLong8
                vmovdqu64   zmm0, [val]
                vpxorq      zmm0, zmm0, [long8.m1]
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold побитовое «или»>
                function    BitOrByte2
                movzx       eax,   word   [val1]
                movzx       iVal2, word   [val2]
                or          eax,   iVal2
                mov         word   [res], ax
                ret

                function    BitOrByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpor        xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    BitOrByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpor        xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    BitOrShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpor        xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    BitOrInt8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpor        ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    BitOrLong8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vporq       zmm0, zmm0, zmm1
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold побитовое «исключающее или»>
                function    BitXorByte2
                movzx       eax,   word   [val1]
                movzx       iVal2, word   [val2]
                xor         eax,   iVal2
                mov         word   [res], ax
                ret

                function    BitXorByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpxor       xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    BitXorByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpxor       xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    BitXorShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpxor       xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    BitXorInt8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpxor       ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    BitXorLong8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vpxorq      zmm0, zmm0, zmm1
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold приведение значения типа double2 к другим типам>
                function    CastDouble2ToFloat2
                vmovdqu     xmm0, [val]
                vcvtpd2ps   xmm0, xmm0
                vmovq       qword [res], xmm0
                ret

                function    CastDouble2ToByte2
                vmovdqu     xmm0, [val]
                vcvttpd2dq  xmm1, xmm0
                vmovdqa     xmm2, [double8.imax]
                vmovdqa     xmm3, [int8.m1_0]
                vcmppd      msk1, xmm2, xmm0, $02
                vcmppd      msk2, xmm0, xmm0, $07
                vmovdqa32   xmm2{k1}{z}, xmm3
                vmovdqa32   xmm3{k2}{z}, xmm3
                vpaddd      xmm0, xmm1, xmm2
                vpand       xmm0, xmm0, xmm3
                vpand       xmm0, xmm0, [int8.maskb]
                vpackusdw   xmm0, xmm0, [zero]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    CastDouble2ToShort2
                vmovdqu     xmm0, [val]
                vcvttpd2dq  xmm1, xmm0
                vmovdqa     xmm2, [double8.imax]
                vmovdqa     xmm3, [int8.m1_0]
                vcmppd      msk1, xmm2, xmm0, $02
                vcmppd      msk2, xmm0, xmm0, $07
                vmovdqa32   xmm2{k1}{z}, xmm3
                vmovdqa32   xmm3{k2}{z}, xmm3
                vpaddd      xmm0, xmm1, xmm2
                vpand       xmm0, xmm0, xmm3
                vpand       xmm0, xmm0, [int8.maskw]
                vpackusdw   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    CastDouble2ToInt2
                vmovdqu     xmm0, [val]
                vcvttpd2dq  xmm1, xmm0
                vmovdqa     xmm2, [double8.imax]
                vmovdqa     xmm3, [int8.m1_0]
                vcmppd      msk1, xmm2, xmm0, $02
                vcmppd      msk2, xmm0, xmm0, $07
                vmovdqa32   xmm2{k1}{z}, xmm3
                vmovdqa32   xmm3{k2}{z}, xmm3
                vpaddd      xmm0, xmm1, xmm2
                vpand       xmm0, xmm0, xmm3
                vmovq       qword [res], xmm0
                ret

                function    CastDouble2ToLong2
                vmovdqu     xmm0, [val]
                vcvttpd2qq  xmm1, xmm0
                vmovdqa     xmm2, [double8.lmax]
                vcmppd      xmm2, xmm2, xmm0, $02
                vcmppd      xmm3, xmm0, xmm0, $07
                vpaddq      xmm0, xmm1, xmm2
                vpand       xmm0, xmm0, xmm3
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold приведение значения типа double4 к другим типам>
                function    CastDouble4ToFloat4
                vmovdqu     ymm0, [val]
                vcvtpd2ps   xmm0, ymm0
                vmovdqu     xword [res], xmm0
                ret

                function    CastDouble4ToByte4
                vmovdqu     ymm0, [val]
                vcvttpd2dq  xmm1, ymm0
                vmovdqa     ymm2, [double8.imax]
                vmovdqa     xmm3, [int8.m1]
                vcmppd      msk1, ymm2, ymm0, $02
                vcmppd      msk2, ymm0, ymm0, $07
                vmovdqa32   xmm2{k1}{z}, xmm3
                vmovdqa32   xmm3{k2}{z}, xmm3
                vpaddd      xmm0, xmm1, xmm2
                vpand       xmm0, xmm0, xmm3
                vpand       xmm0, xmm0, [int8.maskb]
                vpackusdw   xmm0, xmm0, [zero]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    CastDouble4ToShort4
                vmovdqu     ymm0, [val]
                vcvttpd2dq  xmm1, ymm0
                vmovdqa     ymm2, [double8.imax]
                vmovdqa     xmm3, [int8.m1]
                vcmppd      msk1, ymm2, ymm0, $02
                vcmppd      msk2, ymm0, ymm0, $07
                vmovdqa32   xmm2{k1}{z}, xmm3
                vmovdqa32   xmm3{k2}{z}, xmm3
                vpaddd      xmm0, xmm1, xmm2
                vpand       xmm0, xmm0, xmm3
                vpand       xmm0, xmm0, [int8.maskw]
                vpackusdw   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    CastDouble4ToInt4
                vmovdqu     ymm0, [val]
                vcvttpd2dq  xmm1, ymm0
                vmovdqa     ymm2, [double8.imax]
                vmovdqa     xmm3, [int8.m1]
                vcmppd      msk1, ymm2, ymm0, $02
                vcmppd      msk2, ymm0, ymm0, $07
                vmovdqa32   xmm2{k1}{z}, xmm3
                vmovdqa32   xmm3{k2}{z}, xmm3
                vpaddd      xmm0, xmm1, xmm2
                vpand       xmm0, xmm0, xmm3
                vmovdqu     xword [res], xmm0
                ret

                function    CastDouble4ToLong4
                vmovdqu     ymm0, [val]
                vcvttpd2qq  ymm1, ymm0
                vmovdqa     ymm2, [double8.lmax]
                vcmppd      ymm2, ymm2, ymm0, $02
                vcmppd      ymm3, ymm0, ymm0, $07
                vpaddq      ymm0, ymm1, ymm2
                vpand       ymm0, ymm0, ymm3
                vmovdqu     yword [res], ymm0
                ret
; </fold>

; <fold приведение значения типа double8 к другим типам>
                function    CastDouble8ToFloat8
                vmovdqu64   zmm0, [val]
                vcvtpd2ps   ymm0, zmm0
                vmovdqu     yword [res], ymm0
                ret

                function    CastDouble8ToByte8
                vmovdqu64   zmm0, [val]
                vcvttpd2dq  ymm1, zmm0
                vmovdqa64   zmm2, [double8.imax]
                vmovdqa     ymm3, [int8.m1]
                vcmppd      msk1, zmm2, zmm0, $02
                vcmppd      msk2, zmm0, zmm0, $07
                vmovdqa32   ymm2{k1}{z}, ymm3
                vmovdqa32   ymm3{k2}{z}, ymm3
                vpaddd      ymm0, ymm1, ymm2
                vpand       ymm0, ymm0, ymm3
                vpand       ymm0, ymm0, [int8.maskb]
                vextracti128 xmm1, ymm0, $01
                vpackusdw   xmm0, xmm0, xmm1
                vpackuswb   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    CastDouble8ToShort8
                vmovdqu64   zmm0, [val]
                vcvttpd2dq  ymm1, zmm0
                vmovdqa64   zmm2, [double8.imax]
                vmovdqa     ymm3, [int8.m1]
                vcmppd      msk1, zmm2, zmm0, $02
                vcmppd      msk2, zmm0, zmm0, $07
                vmovdqa32   ymm2{k1}{z}, ymm3
                vmovdqa32   ymm3{k2}{z}, ymm3
                vpaddd      ymm0, ymm1, ymm2
                vpand       ymm0, ymm0, ymm3
                vpand       ymm0, ymm0, [int8.maskw]
                vextracti128 xmm1, ymm0, $01
                vpackusdw   xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    CastDouble8ToInt8
                vmovdqu64   zmm0, [val]
                vcvttpd2dq  ymm1, zmm0
                vmovdqa64   zmm2, [double8.imax]
                vmovdqa     ymm3, [int8.m1]
                vcmppd      msk1, zmm2, zmm0, $02
                vcmppd      msk2, zmm0, zmm0, $07
                vmovdqa32   ymm2{k1}{z}, ymm3
                vmovdqa32   ymm3{k2}{z}, ymm3
                vpaddd      ymm0, ymm1, ymm2
                vpand       ymm0, ymm0, ymm3
                vmovdqu     yword [res], ymm0
                ret

                function    CastDouble8ToLong8
                vmovdqu64   zmm0, [val]
                vcvttpd2qq  zmm1, zmm0
                vmovdqa64   zmm2, [double8.lmax]
                vmovdqa64   zmm3, [long8.m1]
                vcmppd      msk1, zmm2, zmm0, $02
                vcmppd      msk2, zmm0, zmm0, $07
                vmovdqa64   zmm2{k1}{z}, zmm3
                vmovdqa64   zmm3{k2}{z}, zmm3
                vpaddq      zmm0, zmm1, zmm2
                vpandq      zmm0, zmm0, zmm3
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold приведение значения типа float2 к другим типам>
                function    CastFloat2ToDouble2
                vmovq       xmm0, [val]
                vcvtps2pd   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    CastFloat2ToByte2
                vmovq       xmm0, [val]
                vcvttps2dq  xmm1, xmm0
                vmovdqa     xmm2, [float8.imax]
                vcmpps      xmm2, xmm2, xmm0, $02
                vcmpps      xmm3, xmm0, xmm0, $07
                vpaddd      xmm0, xmm1, xmm2
                vpand       xmm0, xmm0, xmm3
                vpand       xmm0, xmm0, [int8.maskb]
                vpackusdw   xmm0, xmm0, [zero]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    CastFloat2ToShort2
                vmovq       xmm0, [val]
                vcvttps2dq  xmm1, xmm0
                vmovdqa     xmm2, [float8.imax]
                vcmpps      xmm2, xmm2, xmm0, $02
                vcmpps      xmm3, xmm0, xmm0, $07
                vpaddd      xmm0, xmm1, xmm2
                vpand       xmm0, xmm0, xmm3
                vpand       xmm0, xmm0, [int8.maskw]
                vpackusdw   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    CastFloat2ToInt2
                vmovq       xmm0, [val]
                vcvttps2dq  xmm1, xmm0
                vmovdqa     xmm2, [float8.imax]
                vcmpps      xmm2, xmm2, xmm0, $02
                vcmpps      xmm3, xmm0, xmm0, $07
                vpaddd      xmm0, xmm1, xmm2
                vpand       xmm0, xmm0, xmm3
                vmovq       qword [res], xmm0
                ret

                function    CastFloat2ToLong2
                vmovq       xmm0, [val]
                vcvtps2pd   xmm0, xmm0
                vcvttpd2qq  xmm1, xmm0
                vmovdqa     xmm2, [double8.lmax]
                vcmppd      xmm2, xmm2, xmm0, $02
                vcmppd      xmm3, xmm0, xmm0, $07
                vpaddq      xmm0, xmm1, xmm2
                vpand       xmm0, xmm0, xmm3
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold приведение значения типа float4 к другим типам>
                function    CastFloat4ToDouble4
                vmovdqu     xmm0, [val]
                vcvtps2pd   ymm0, xmm0
                vmovdqu     yword [res], ymm0
                ret

                function    CastFloat4ToByte4
                vmovdqu     xmm0, [val]
                vcvttps2dq  xmm1, xmm0
                vmovdqa     xmm2, [float8.imax]
                vcmpps      xmm2, xmm2, xmm0, $02
                vcmpps      xmm3, xmm0, xmm0, $07
                vpaddd      xmm0, xmm1, xmm2
                vpand       xmm0, xmm0, xmm3
                vpand       xmm0, xmm0, [int8.maskb]
                vpackusdw   xmm0, xmm0, [zero]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    CastFloat4ToShort4
                vmovdqu     xmm0, [val]
                vcvttps2dq  xmm1, xmm0
                vmovdqa     xmm2, [float8.imax]
                vcmpps      xmm2, xmm2, xmm0, $02
                vcmpps      xmm3, xmm0, xmm0, $07
                vpaddd      xmm0, xmm1, xmm2
                vpand       xmm0, xmm0, xmm3
                vpand       xmm0, xmm0, [int8.maskw]
                vpackusdw   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    CastFloat4ToInt4
                vmovdqu     xmm0, [val]
                vcvttps2dq  xmm1, xmm0
                vmovdqa     xmm2, [float8.imax]
                vcmpps      xmm2, xmm2, xmm0, $02
                vcmpps      xmm3, xmm0, xmm0, $07
                vpaddd      xmm0, xmm1, xmm2
                vpand       xmm0, xmm0, xmm3
                vmovdqu     xword [res], xmm0
                ret

                function    CastFloat4ToLong4
                vmovdqu     xmm0, [val]
                vcvtps2pd   ymm0, xmm0
                vcvttpd2qq  ymm1, ymm0
                vmovdqa     ymm2, [double8.lmax]
                vcmppd      ymm2, ymm2, ymm0, $02
                vcmppd      ymm3, ymm0, ymm0, $07
                vpaddq      ymm0, ymm1, ymm2
                vpand       ymm0, ymm0, ymm3
                vmovdqu     yword [res], ymm0
                ret
; </fold>

; <fold приведение значения типа float8 к другим типам>
                function    CastFloat8ToDouble8
                vmovdqu     ymm0, [val]
                vcvtps2pd   zmm0, ymm0
                vmovdqu64   zword [res], zmm0
                ret

                function    CastFloat8ToByte8
                vmovdqu     ymm0, [val]
                vcvttps2dq  ymm1, ymm0
                vmovdqa     ymm2, [float8.imax]
                vcmpps      ymm2, ymm2, ymm0, $02
                vcmpps      ymm3, ymm0, ymm0, $07
                vpaddd      ymm0, ymm1, ymm2
                vpand       ymm0, ymm0, ymm3
                vpand       ymm0, ymm0, [int8.maskb]
                vextracti128 xmm1, ymm0, $01
                vpackusdw   xmm0, xmm0, xmm1
                vpackuswb   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    CastFloat8ToShort8
                vmovdqu     ymm0, [val]
                vcvttps2dq  ymm1, ymm0
                vmovdqa     ymm2, [float8.imax]
                vcmpps      ymm2, ymm2, ymm0, $02
                vcmpps      ymm3, ymm0, ymm0, $07
                vpaddd      ymm0, ymm1, ymm2
                vpand       ymm0, ymm0, ymm3
                vpand       ymm0, ymm0, [int8.maskw]
                vextracti128 xmm1, ymm0, $01
                vpackusdw   xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    CastFloat8ToInt8
                vmovdqu     ymm0, [val]
                vcvttps2dq  ymm1, ymm0
                vmovdqa     ymm2, [float8.imax]
                vcmpps      ymm2, ymm2, ymm0, $02
                vcmpps      ymm3, ymm0, ymm0, $07
                vpaddd      ymm0, ymm1, ymm2
                vpand       ymm0, ymm0, ymm3
                vmovdqu     yword [res], ymm0
                ret

                function    CastFloat8ToLong8
                vmovdqu     ymm0, [val]
                vcvtps2pd   zmm0, ymm0
                vcvttpd2qq  zmm1, zmm0
                vmovdqa64   zmm2, [double8.lmax]
                vmovdqa64   zmm3, [long8.m1]
                vcmppd      msk1, zmm2, zmm0, $02
                vcmppd      msk2, zmm0, zmm0, $07
                vmovdqa64   zmm2{k1}{z}, zmm3
                vmovdqa64   zmm3{k2}{z}, zmm3
                vpaddq      zmm0, zmm1, zmm2
                vpandq      zmm0, zmm0, zmm3
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold приведение значения типа byte2 к другим типам>
                function    CastByte2ToDouble2
                movzx       iVal, word  [val]
                vmovd       xmm0, iVal
                vpmovsxbd   xmm0, xmm0
                vcvtdq2pd   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    CastByte2ToFloat2
                movzx       iVal, word  [val]
                vmovd       xmm0, iVal
                vpmovsxbd   xmm0, xmm0
                vcvtdq2ps   xmm0, xmm0
                vmovq       qword [res], xmm0
                ret

                function    CastByte2ToShort2
                movzx       iVal, word  [val]
                vmovd       xmm0, iVal
                vpmovsxbw   xmm0, xmm0
                vmovd       dword [res], xmm0
                ret

                function    CastByte2ToInt2
                movzx       iVal, word  [val]
                vmovd       xmm0, iVal
                vpmovsxbd   xmm0, xmm0
                vmovq       qword [res], xmm0
                ret

                function    CastByte2ToLong2
                movzx       iVal, word  [val]
                vmovd       xmm0, iVal
                vpmovsxbq   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold приведение значения типа byte4 к другим типам>
                function    CastByte4ToDouble4
                vmovd       xmm0, [val]
                vpmovsxbd   xmm0, xmm0
                vcvtdq2pd   ymm0, xmm0
                vmovdqu     yword [res], ymm0
                ret

                function    CastByte4ToFloat4
                vmovd       xmm0, [val]
                vpmovsxbd   xmm0, xmm0
                vcvtdq2ps   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    CastByte4ToShort4
                vmovd       xmm0, [val]
                vpmovsxbw   xmm0, xmm0
                vmovq       qword [res], xmm0
                ret

                function    CastByte4ToInt4
                vmovd       xmm0, [val]
                vpmovsxbd   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    CastByte4ToLong4
                vmovd       xmm0, [val]
                vpmovsxbq   ymm0, xmm0
                vmovdqu     yword [res], ymm0
                ret
; </fold>

; <fold приведение значения типа byte8 к другим типам>
                function    CastByte8ToDouble8
                vmovq       xmm0, [val]
                vpmovsxbd   ymm0, xmm0
                vcvtdq2pd   zmm0, ymm0
                vmovdqu64   zword [res], zmm0
                ret

                function    CastByte8ToFloat8
                vmovq       xmm0, [val]
                vpmovsxbd   ymm0, xmm0
                vcvtdq2ps   ymm0, ymm0
                vmovdqu     yword [res], ymm0
                ret

                function    CastByte8ToShort8
                vmovq       xmm0, [val]
                vpmovsxbw   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    CastByte8ToInt8
                vmovq       xmm0, [val]
                vpmovsxbd   ymm0, xmm0
                vmovdqu     yword [res], ymm0
                ret

                function    CastByte8ToLong8
                vmovq       xmm0, [val]
                vpmovsxbq   zmm0, xmm0
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold приведение значения типа short2 к другим типам>
                function    CastShort2ToDouble2
                vmovd       xmm0, [val]
                vpmovsxwd   xmm0, xmm0
                vcvtdq2pd   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    CastShort2ToFloat2
                vmovd       xmm0, [val]
                vpmovsxwd   xmm0, xmm0
                vcvtdq2ps   xmm0, xmm0
                vmovq       qword [res], xmm0
                ret

                function    CastShort2ToByte2
                vmovd       xmm0, [val]
                vpand       xmm0, xmm0, [short8.$00ff]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    CastShort2ToInt2
                vmovd       xmm0, [val]
                vpmovsxwd   xmm0, xmm0
                vmovq       qword [res], xmm0
                ret

                function    CastShort2ToLong2
                vmovd       xmm0, [val]
                vpmovsxwq   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold приведение значения типа short4 к другим типам>
                function    CastShort4ToDouble4
                vmovq       xmm0, [val]
                vpmovsxwd   xmm0, xmm0
                vcvtdq2pd   ymm0, xmm0
                vmovdqu     yword [res], ymm0
                ret

                function    CastShort4ToFloat4
                vmovq       xmm0, [val]
                vpmovsxwd   xmm0, xmm0
                vcvtdq2ps   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    CastShort4ToByte4
                vmovq       xmm0, [val]
                vpand       xmm0, xmm0, [short8.$00ff]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    CastShort4ToInt4
                vmovq       xmm0, [val]
                vpmovsxwd   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    CastShort4ToLong4
                vmovq       xmm0, [val]
                vpmovsxwq   ymm0, xmm0
                vmovdqu     yword [res], ymm0
                ret
; </fold>

; <fold приведение значения типа short8 к другим типам>
                function    CastShort8ToDouble8
                vmovdqu     xmm0, [val]
                vpmovsxwd   ymm0, xmm0
                vcvtdq2pd   zmm0, ymm0
                vmovdqu64   zword [res], zmm0
                ret

                function    CastShort8ToFloat8
                vmovdqu     xmm0, [val]
                vpmovsxwd   ymm0, xmm0
                vcvtdq2ps   ymm0, ymm0
                vmovdqu     yword [res], ymm0
                ret

                function    CastShort8ToByte8
                vmovdqu     xmm0, [val]
                vpand       xmm0, xmm0, [short8.$00ff]
                vpackuswb   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    CastShort8ToInt8
                vmovdqu     xmm0, [val]
                vpmovsxwd   ymm0, xmm0
                vmovdqu     yword [res], ymm0
                ret

                function    CastShort8ToLong8
                vmovdqu     xmm0, [val]
                vpmovsxwq   zmm0, xmm0
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold приведение значения типа int2 к другим типам>
                function    CastInt2ToDouble2
                vmovq       xmm0, [val]
                vcvtdq2pd   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    CastInt2ToFloat2
                vmovq       xmm0, [val]
                vcvtdq2ps   xmm0, xmm0
                vmovq       qword [res], xmm0
                ret

                function    CastInt2ToByte2
                vmovq       xmm0, [val]
                vpand       xmm0, xmm0, [int8.maskb]
                vpackusdw   xmm0, xmm0, [zero]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    CastInt2ToShort2
                vmovq       xmm0, [val]
                vpand       xmm0, xmm0, [int8.maskw]
                vpackusdw   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    CastInt2ToLong2
                vmovq       xmm0, [val]
                vpmovsxdq   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold приведение значения типа int4 к другим типам>
                function    CastInt4ToDouble4
                vmovdqu     xmm0, [val]
                vcvtdq2pd   ymm0, xmm0
                vmovdqu     yword [res], ymm0
                ret

                function    CastInt4ToFloat4
                vmovdqu     xmm0, [val]
                vcvtdq2ps   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    CastInt4ToByte4
                vmovdqu     xmm0, [val]
                vpand       xmm0, xmm0, [int8.maskb]
                vpackusdw   xmm0, xmm0, [zero]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    CastInt4ToShort4
                vmovdqu     xmm0, [val]
                vpand       xmm0, xmm0, [int8.maskw]
                vpackusdw   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    CastInt4ToLong4
                vmovdqu     xmm0, [val]
                vpmovsxdq   ymm0, xmm0
                vmovdqu     yword [res], ymm0
                ret
; </fold>

; <fold приведение значения типа int8 к другим типам>
                function    CastInt8ToDouble8
                vmovdqu     ymm0, [val]
                vcvtdq2pd   zmm0, ymm0
                vmovdqu64   zword [res], zmm0
                ret

                function    CastInt8ToFloat8
                vmovdqu     ymm0, [val]
                vcvtdq2ps   ymm0, ymm0
                vmovdqu     yword [res], ymm0
                ret

                function    CastInt8ToByte8
                vmovdqu     ymm0, [val]
                vpand       ymm0, ymm0, [int8.maskb]
                vextracti128 xmm1, ymm0, $01
                vpackusdw   xmm0, xmm0, xmm1
                vpackuswb   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    CastInt8ToShort8
                vmovdqu     ymm0, [val]
                vpand       ymm0, ymm0, [int8.maskw]
                vextracti128 xmm1, ymm0, $01
                vpackusdw   xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    CastInt8ToLong8
                vmovdqu     ymm0, [val]
                vpmovsxdq   zmm0, ymm0
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold приведение значения типа long2 к другим типам>
                function    CastLong2ToDouble2
                vmovdqu     xmm0, [val]
                vcvtqq2pd   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    CastLong2ToFloat2
                vmovdqu     xmm0, [val]
                vcvtqq2ps   xmm0, xmm0
                vmovq       qword [res], xmm0
                ret

                function    CastLong2ToByte2
                vmovdqu     xmm0, [val]
                vpand       xmm0, xmm0, [long8.maskb]
                vshufps     xmm0, xmm0, xmm0, $d8
                vpackusdw   xmm0, xmm0, [zero]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    CastLong2ToShort2
                vmovdqu     xmm0, [val]
                vpand       xmm0, xmm0, [long8.maskw]
                vshufps     xmm0, xmm0, xmm0, $d8
                vpackusdw   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    CastLong2ToInt2
                vmovdqu     xmm0, [val]
                vpand       xmm0, xmm0, [long8.maskd]
                vshufps     xmm0, xmm0, xmm0, $d8
                vmovq       qword [res], xmm0
                ret
; </fold>

; <fold приведение значения типа long4 к другим типам>
                function    CastLong4ToDouble4
                vmovdqu     ymm0, [val]
                vcvtqq2pd   ymm0, ymm0
                vmovdqu     yword [res], ymm0
                ret

                function    CastLong4ToFloat4
                vmovdqu     ymm0, [val]
                vcvtqq2ps   xmm0, ymm0
                vmovdqu     xword [res], xmm0
                ret

                function    CastLong4ToByte4
                vmovdqu     ymm0, [val]
                vpand       ymm0, ymm0, [long8.maskb]
                vshufps     ymm0, ymm0, ymm0, $d8
                vextracti128 xmm1, ymm0, $01
                vpslldq     xmm1, xmm1, $08
                vpor        xmm0, xmm0, xmm1
                vpackusdw   xmm0, xmm0, [zero]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    CastLong4ToShort4
                vmovdqu     ymm0, [val]
                vpand       ymm0, ymm0, [long8.maskw]
                vshufps     ymm0, ymm0, ymm0, $d8
                vextracti128 xmm1, ymm0, $01
                vpslldq     xmm1, xmm1, $08
                vpor        xmm0, xmm0, xmm1
                vpackusdw   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    CastLong4ToInt4
                vmovdqu     ymm0, [val]
                vpand       ymm0, ymm0, [long8.maskd]
                vshufps     ymm0, ymm0, ymm0, $d8
                vextracti128 xmm1, ymm0, $01
                vpslldq     xmm1, xmm1, $08
                vpor        xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold приведение значения типа long8 к другим типам>
                function    CastLong8ToDouble8
                vmovdqu64   zmm0, [val]
                vcvtqq2pd   zmm0, zmm0
                vmovdqu64   zword [res], zmm0
                ret

                function    CastLong8ToFloat8
                vmovdqu64   zmm0, [val]
                vcvtqq2ps   ymm0, zmm0
                vmovdqu     yword [res], ymm0
                ret

                function    CastLong8ToByte8
                vmovdqu64   zmm0, [val]
                vpandq      zmm0, zmm0, [long8.maskb]
                vshufps     zmm0, zmm0, zmm0, $d8
                vshufi64x2  zmm0, zmm0, zmm0, $d8
                vextracti64x4 ymm1, zmm0, $01
                vpslldq     ymm1, ymm1, $08
                vpor        ymm0, ymm0, ymm1
                vextracti128 xmm1, ymm0, $01
                vpackusdw   xmm0, xmm0, xmm1
                vpackuswb   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    CastLong8ToShort8
                vmovdqu64   zmm0, [val]
                vpandq      zmm0, zmm0, [long8.maskw]
                vshufps     zmm0, zmm0, zmm0, $d8
                vshufi64x2  zmm0, zmm0, zmm0, $d8
                vextracti64x4 ymm1, zmm0, $01
                vpslldq     ymm1, ymm1, $08
                vpor        ymm0, ymm0, ymm1
                vextracti128 xmm1, ymm0, $01
                vpackusdw   xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    CastLong8ToInt8
                vmovdqu64   zmm0, [val]
                vpandq      zmm0, zmm0, [long8.maskd]
                vshufps     zmm0, zmm0, zmm0, $d8
                vshufi64x2  zmm0, zmm0, zmm0, $d8
                vextracti64x4 ymm1, zmm0, $01
                vpslldq     ymm1, ymm1, $08
                vpor        ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret
; </fold>

; <fold скалярное сложение>
                function    ScalarAddDouble2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vaddpd      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarAddDouble4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vaddpd      ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarAddDouble8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vaddpd      zmm0, zmm0, zmm1
                vmovdqu64   zword [res], zmm0
                ret

                function    ScalarAddFloat2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vaddps      xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    ScalarAddFloat4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vaddps      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarAddFloat8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vaddps      ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarAddInt2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpaddd      xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    ScalarAddInt4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpaddd      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarAddInt8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpaddd      ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarAddLong2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpaddq      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarAddLong4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpaddq      ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarAddLong8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vpaddq      zmm0, zmm0, zmm1
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold скалярное сопряжение>
                function    ScalarConjDouble2
                vmovdqu     xmm0, [val]
                vmulpd      xmm0, xmm0, [smuld2.c0]
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarConjDouble4
                vmovdqu     ymm0, [val]
                vmulpd      ymm0, ymm0, [smuld4.q0]
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarConjDouble8
                vmovdqu64   zmm0, [val]
                vmulpd      zmm0, zmm0, [smuld8.o0]
                vmovdqu64   zword [res], zmm0
                ret

                function    ScalarConjFloat2
                vmovq       xmm0, [val]
                vmulps      xmm0, xmm0, [smulf2.c0]
                vmovq       qword [res], xmm0
                ret

                function    ScalarConjFloat4
                vmovdqu     xmm0, [val]
                vmulps      xmm0, xmm0, [smulf4.q0]
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarConjFloat8
                vmovdqu     ymm0, [val]
                vmulps      ymm0, ymm0, [smulf8.o0]
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarConjInt2
                vmovq       xmm0, [val]
                vpmulld     xmm0, xmm0, [smuli2.c0]
                vmovq       qword [res], xmm0
                ret

                function    ScalarConjInt4
                vmovdqu     xmm0, [val]
                vpmulld     xmm0, xmm0, [smuli4.q0]
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarConjInt8
                vmovdqu     ymm0, [val]
                vpmulld     ymm0, ymm0, [smuli8.o0]
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarConjLong2
                vmovdqu     xmm0, [val]
                vpmullq     xmm0, xmm0, [smull2.c0]
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarConjLong4
                vmovdqu     ymm0, [val]
                vpmullq     ymm0, ymm0, [smull4.q0]
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarConjLong8
                vmovdqu64   zmm0, [val]
                vpmullq     zmm0, zmm0, [smull8.o0]
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold скалярное деление>
                function    ScalarDivDouble2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vmulpd      xmm1, xmm1, [smuld2.c0]
                vmulpd      xmm2, xmm1, xmm1
                vhaddpd     xmm2, xmm2, xmm2
                vdivpd      xmm1, xmm1, xmm2
                vshufpd     xmm2, xmm1, xmm1, $02
                vshufpd     xmm3, xmm2, xmm2, $01
                vmulpd      xmm2, xmm2, [smuld2.c0]
                vmulpd      xmm1, xmm0, xmm3
                vmulpd      xmm0, xmm0, xmm2
                vhaddpd     xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarDivDouble4
                enterq
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vmulpd      ymm1, ymm1, [smuld4.q0]
                vmulpd      ymm2, ymm1, ymm1
                vextractf128 xmm3, ymm2, $01
                vhaddpd     xmm2, xmm2, xmm3
                vhaddpd     xmm2, xmm2, xmm2
                vinsertf128 ymm2, ymm2, xmm2, $01
                vdivpd      ymm1, ymm1, ymm2
                vshuff64x2  ymm4, ymm1, ymm1, $02
                vshuff64x2  ymm6, ymm4, ymm4, $01
                vshufpd     ymm5, ymm4, ymm4, $05
                vshufpd     ymm7, ymm6, ymm6, $05
                vmulpd      ymm4, ymm4, [smuld4.q0]
                vmulpd      ymm5, ymm5, [smuld4.q1]
                vmulpd      ymm6, ymm6, [smuld4.q2]
                vmulpd      ymm7, ymm7, [smuld4.q3]
                vmulpd      ymm3, ymm0, ymm7
                vmulpd      ymm2, ymm0, ymm6
                vmulpd      ymm1, ymm0, ymm5
                vmulpd      ymm0, ymm0, ymm4
                vextractf128 xmm4, ymm0, $01
                vextractf128 xmm5, ymm1, $01
                vextractf128 xmm6, ymm2, $01
                vextractf128 xmm7, ymm3, $01
                vinsertf128 ymm0, ymm0, xmm2, $01
                vinsertf128 ymm2, ymm1, xmm3, $01
                vinsertf128 ymm1, ymm4, xmm6, $01
                vinsertf128 ymm3, ymm5, xmm7, $01
                vaddpd      ymm0, ymm0, ymm1
                vaddpd      ymm1, ymm2, ymm3
                vshufpd     ymm2, ymm0, ymm1, $00
                vshufpd     ymm3, ymm0, ymm1, $0f
                vaddpd      ymm0, ymm2, ymm3
                vmovdqu     yword [res], ymm0
                leaveq
                ret

                function    ScalarDivDouble8
                entero
                vmovdqu64   zmm00, [val1]
                vmovdqu64   zmm01, [val2]
                vmulpd      zmm01, zmm01, [smuld8.o0]
                vmulpd      zmm02, zmm01, zmm01, {rn-sae}
                vextractf64x2 xmm03, zmm02, $01
                vextractf64x2 xmm04, zmm02, $02
                vextractf64x2 xmm05, zmm02, $03
                vhaddpd     xmm02, xmm02, xmm03
                vhaddpd     xmm03, xmm04, xmm05
                vhaddpd     xmm02, xmm02, xmm03
                vhaddpd     xmm02, xmm02, xmm02
                vbroadcastsd zmm02, xmm02
                vdivpd      zmm01, zmm01, zmm02
                vshuff64x2  zmm08, zmm01, zmm01, $e4
                vshuff64x2  zmm10, zmm08, zmm08, $b1
                vshuff64x2  zmm12, zmm08, zmm08, $4e
                vshuff64x2  zmm14, zmm08, zmm08, $1b
                vshufpd     zmm09, zmm08, zmm08, $55
                vshufpd     zmm11, zmm10, zmm10, $55
                vshufpd     zmm13, zmm12, zmm12, $55
                vshufpd     zmm15, zmm14, zmm14, $55
                vmulpd      zmm08, zmm08, [smuld8.o0]
                vmulpd      zmm09, zmm09, [smuld8.o1]
                vmulpd      zmm10, zmm10, [smuld8.o2]
                vmulpd      zmm11, zmm11, [smuld8.o3]
                vmulpd      zmm12, zmm12, [smuld8.o4]
                vmulpd      zmm13, zmm13, [smuld8.o5]
                vmulpd      zmm14, zmm14, [smuld8.o6]
                vmulpd      zmm15, zmm15, [smuld8.o7]
                vmulpd      zmm07, zmm00, zmm15, {rn-sae}
                vmulpd      zmm06, zmm00, zmm14, {rn-sae}
                vmulpd      zmm05, zmm00, zmm13, {rn-sae}
                vmulpd      zmm04, zmm00, zmm12, {rn-sae}
                vmulpd      zmm03, zmm00, zmm11, {rn-sae}
                vmulpd      zmm02, zmm00, zmm10, {rn-sae}
                vmulpd      zmm01, zmm00, zmm09, {rn-sae}
                vmulpd      zmm00, zmm00, zmm08, {rn-sae}
                vextractf64x4 ymm08, zmm00, $01
                vextractf64x4 ymm09, zmm01, $01
                vextractf64x4 ymm10, zmm02, $01
                vextractf64x4 ymm11, zmm03, $01
                vextractf64x4 ymm12, zmm04, $01
                vextractf64x4 ymm13, zmm05, $01
                vextractf64x4 ymm14, zmm06, $01
                vextractf64x4 ymm15, zmm07, $01
                vinsertf64x4 zmm00, zmm00, ymm02, $01
                vinsertf64x4 zmm02, zmm04, ymm06, $01
                vinsertf64x4 zmm04, zmm01, ymm03, $01
                vinsertf64x4 zmm06, zmm05, ymm07, $01
                vinsertf64x4 zmm01, zmm08, ymm10, $01
                vinsertf64x4 zmm03, zmm12, ymm14, $01
                vinsertf64x4 zmm05, zmm09, ymm11, $01
                vinsertf64x4 zmm07, zmm13, ymm15, $01
                vaddpd      zmm00, zmm00, zmm01
                vaddpd      zmm01, zmm02, zmm03
                vaddpd      zmm02, zmm04, zmm05
                vaddpd      zmm03, zmm06, zmm07
                vshuff64x2  zmm04, zmm00, zmm01, $88
                vshuff64x2  zmm05, zmm00, zmm01, $dd
                vshuff64x2  zmm06, zmm02, zmm03, $88
                vshuff64x2  zmm07, zmm02, zmm03, $dd
                vaddpd      zmm00, zmm04, zmm05
                vaddpd      zmm01, zmm06, zmm07
                vshufpd     zmm02, zmm00, zmm01, $00
                vshufpd     zmm03, zmm00, zmm01, $ff
                vaddpd      zmm00, zmm02, zmm03
                vmovdqu64   zword  [res], zmm00
                leaveo
                ret

                function    ScalarDivFloat2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vmulps      xmm1, xmm1, [smulf2.c0]
                vmulps      xmm2, xmm1, xmm1
                vhaddps     xmm2, xmm2, xmm2
                vshufps     xmm2, xmm2, xmm2, $a0
                vdivps      xmm1, xmm1, xmm2
                vshufps     xmm2, xmm1, xmm1, $e4
                vshufps     xmm3, xmm2, xmm2, $e1
                vmulps      xmm2, xmm2, [smulf2.c0]
                vmulps      xmm1, xmm0, xmm3
                vmulps      xmm0, xmm0, xmm2
                vhaddps     xmm0, xmm0, xmm1
                vshufps     xmm0, xmm0, xmm0, $d8
                vmovq       qword [res], xmm0
                ret

                function    ScalarDivFloat4
                enterq
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vmulps      xmm1, xmm1, [smulf4.q0]
                vmulps      xmm2, xmm1, xmm1
                vhaddps     xmm2, xmm2, xmm2
                vhaddps     xmm2, xmm2, xmm2
                vdivps      xmm1, xmm1, xmm2
                vshufps     xmm4, xmm1, xmm1, $e4
                vshufps     xmm5, xmm4, xmm4, $b1
                vshufps     xmm6, xmm4, xmm4, $4e
                vshufps     xmm7, xmm4, xmm4, $1b
                vmulps      xmm4, xmm4, [smulf4.q0]
                vmulps      xmm5, xmm5, [smulf4.q1]
                vmulps      xmm6, xmm6, [smulf4.q2]
                vmulps      xmm7, xmm7, [smulf4.q3]
                vmulps      xmm3, xmm0, xmm7
                vmulps      xmm2, xmm0, xmm6
                vmulps      xmm1, xmm0, xmm5
                vmulps      xmm0, xmm0, xmm4
                vhaddps     xmm0, xmm0, xmm1
                vhaddps     xmm1, xmm2, xmm3
                vhaddps     xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                leaveq
                ret

                function    ScalarDivFloat8
                entero
                vmovdqu     ymm00, [val1]
                vmovdqu     ymm01, [val2]
                vmulps      ymm01, ymm01, [smulf8.o0]
                vmulps      ymm02, ymm01, ymm01
                vextractf128 xmm03, ymm02, $01
                vhaddps     xmm02, xmm02, xmm03
                vhaddps     xmm02, xmm02, xmm02
                vhaddps     xmm02, xmm02, xmm02
                vinsertf128 ymm02, ymm02, xmm02, $01
                vdivps      ymm01, ymm01, ymm02
                vmovdqa     ymm08, ymm01
                vextractf128 xmm12, ymm08, $01
                vinsertf128 ymm12, ymm12, xmm08, $01
                vshufps     ymm09, ymm08, ymm08, $b1
                vshufps     ymm10, ymm08, ymm08, $4e
                vshufps     ymm11, ymm08, ymm08, $1b
                vshufps     ymm13, ymm12, ymm12, $b1
                vshufps     ymm14, ymm12, ymm12, $4e
                vshufps     ymm15, ymm12, ymm12, $1b
                vmulps      ymm08, ymm08, [smulf8.o0]
                vmulps      ymm09, ymm09, [smulf8.o1]
                vmulps      ymm10, ymm10, [smulf8.o2]
                vmulps      ymm11, ymm11, [smulf8.o3]
                vmulps      ymm12, ymm12, [smulf8.o4]
                vmulps      ymm13, ymm13, [smulf8.o5]
                vmulps      ymm14, ymm14, [smulf8.o6]
                vmulps      ymm15, ymm15, [smulf8.o7]
                vmulps      ymm07, ymm00, ymm15
                vmulps      ymm06, ymm00, ymm14
                vmulps      ymm05, ymm00, ymm13
                vmulps      ymm04, ymm00, ymm12
                vmulps      ymm03, ymm00, ymm11
                vmulps      ymm02, ymm00, ymm10
                vmulps      ymm01, ymm00, ymm09
                vmulps      ymm00, ymm00, ymm08
                vhaddps     ymm00, ymm00, ymm01
                vhaddps     ymm01, ymm02, ymm03
                vhaddps     ymm02, ymm04, ymm05
                vhaddps     ymm03, ymm06, ymm07
                vhaddps     ymm00, ymm00, ymm01
                vhaddps     ymm01, ymm02, ymm03
                vextractf128 xmm02, ymm00, $01
                vextractf128 xmm03, ymm01, $01
                vaddps      xmm00, xmm00, xmm02
                vaddps      xmm01, xmm01, xmm03
                vinsertf128 ymm00, ymm00, xmm01, $01
                vmovdqu     yword  [res], ymm00
                leaveo
                ret
; </fold>

; <fold скалярное обращение>
                function    ScalarInvDouble2
                vmovdqu     xmm0, [val]
                vmulpd      xmm0, xmm0, [smuld2.c0]
                vmulpd      xmm1, xmm0, xmm0
                vhaddpd     xmm1, xmm1, xmm1
                vdivpd      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarInvDouble4
                vmovdqu     ymm0, [val]
                vmulpd      ymm0, ymm0, [smuld4.q0]
                vmulpd      ymm1, ymm0, ymm0
                vextractf128 xmm2, ymm1, $01
                vhaddpd     xmm1, xmm1, xmm2
                vhaddpd     xmm1, xmm1, xmm1
                vinsertf128 ymm1, ymm1, xmm1, $01
                vdivpd      ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarInvDouble8
                vmovdqu64   zmm0, [val]
                vmulpd      zmm0, zmm0, [smuld8.o0]
                vmulpd      zmm1, zmm0, zmm0, {rn-sae}
                vextractf64x2 xmm2, zmm1, $01
                vextractf64x2 xmm3, zmm1, $02
                vextractf64x2 xmm4, zmm1, $03
                vhaddpd     xmm1, xmm1, xmm2
                vhaddpd     xmm2, xmm3, xmm4
                vhaddpd     xmm1, xmm1, xmm2
                vhaddpd     xmm1, xmm1, xmm1
                vbroadcastsd zmm1, xmm1
                vdivpd      zmm0, zmm0, zmm1
                vmovdqu64   zword [res], zmm0
                ret

                function    ScalarInvFloat2
                vmovq       xmm0, [val]
                vmulps      xmm0, xmm0, [smulf2.c0]
                vmulps      xmm1, xmm0, xmm0
                vhaddps     xmm1, xmm1, xmm1
                vshufps     xmm1, xmm1, xmm1, $a0
                vdivps      xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    ScalarInvFloat4
                vmovdqu     xmm0, [val]
                vmulps      xmm0, xmm0, [smulf4.q0]
                vmulps      xmm1, xmm0, xmm0
                vhaddps     xmm1, xmm1, xmm1
                vhaddps     xmm1, xmm1, xmm1
                vdivps      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarInvFloat8
                vmovdqu     ymm0, [val]
                vmulps      ymm0, ymm0, [smulf8.o0]
                vmulps      ymm1, ymm0, ymm0
                vextractf128 xmm2, ymm1, $01
                vhaddps     xmm1, xmm1, xmm2
                vhaddps     xmm1, xmm1, xmm1
                vhaddps     xmm1, xmm1, xmm1
                vinsertf128 ymm1, ymm1, xmm1, $01
                vdivps      ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret
; </fold>

; <fold скалярное равно>
                function    ScalarEqualsDouble2
                vmovdqu     xmm0, [res]
                vmovdqu     xmm1, [val]
                vcmppd      xmm0, xmm0, xmm1, $00
                vmovmskpd   eax,  xmm0
                and         eax,  $03
                cmp         eax,  $03
                sete        al
                ret

                function    ScalarEqualsDouble4
                vmovdqu     ymm0, [res]
                vmovdqu     ymm1, [val]
                vcmppd      ymm0, ymm0, ymm1, $00
                vmovmskpd   eax,  ymm0
                and         eax,  $0f
                cmp         eax,  $0f
                sete        al
                ret

                function    ScalarEqualsDouble8
                vmovdqu64   zmm0, [res]
                vmovdqu64   zmm1, [val]
                vcmppd      msk1, zmm0, zmm1, $00
                kmovw       eax,  msk1
                and         eax,  $ff
                cmp         eax,  $ff
                sete        al
                ret

                function    ScalarEqualsFloat2
                vmovq       xmm0, [res]
                vmovq       xmm1, [val]
                vcmpps      xmm0, xmm0, xmm1, $00
                vmovmskps   eax,  xmm0
                and         eax,  $03
                cmp         eax,  $03
                sete        al
                ret

                function    ScalarEqualsFloat4
                vmovdqu     xmm0, [res]
                vmovdqu     xmm1, [val]
                vcmpps      xmm0, xmm0, xmm1, $00
                vmovmskps   eax,  xmm0
                and         eax,  $0f
                cmp         eax,  $0f
                sete        al
                ret

                function    ScalarEqualsFloat8
                vmovdqu     ymm0, [res]
                vmovdqu     ymm1, [val]
                vcmpps      ymm0, ymm0, ymm1, $00
                vmovmskps   eax,  ymm0
                and         eax,  $ff
                cmp         eax,  $ff
                sete        al
                ret

                function    ScalarEqualsInt2
                vmovq       xmm0, [res]
                vmovq       xmm1, [val]
                vpcmpeqd    xmm0, xmm0, xmm1
                vmovmskps   eax,  xmm0
                and         eax,  $03
                cmp         eax,  $03
                sete        al
                ret

                function    ScalarEqualsInt4
                vmovdqu     xmm0, [res]
                vmovdqu     xmm1, [val]
                vpcmpeqd    xmm0, xmm0, xmm1
                vmovmskps   eax,  xmm0
                and         eax,  $0f
                cmp         eax,  $0f
                sete        al
                ret

                function    ScalarEqualsInt8
                vmovdqu     ymm0, [res]
                vmovdqu     ymm1, [val]
                vpcmpeqd    ymm0, ymm0, ymm1
                vmovmskps   eax,  ymm0
                and         eax,  $ff
                cmp         eax,  $ff
                sete        al
                ret

                function    ScalarEqualsLong2
                vmovdqu     xmm0, [res]
                vmovdqu     xmm1, [val]
                vpcmpeqq    xmm0, xmm0, xmm1
                vmovmskpd   eax,  xmm0
                and         eax,  $03
                cmp         eax,  $03
                sete        al
                ret

                function    ScalarEqualsLong4
                vmovdqu     ymm0, [res]
                vmovdqu     ymm1, [val]
                vpcmpeqq    ymm0, ymm0, ymm1
                vmovmskpd   eax,  ymm0
                and         eax,  $0f
                cmp         eax,  $0f
                sete        al
                ret

                function    ScalarEqualsLong8
                vmovdqu64   zmm0, [res]
                vmovdqu64   zmm1, [val]
                vpcmpeqq    msk1, zmm0, zmm1
                kmovw       eax,  msk1
                and         eax,  $ff
                cmp         eax,  $ff
                sete        al
                ret
; </fold>

; <fold скалярное не равно>
                function    ScalarNotEqualsDouble2
                vmovdqu     xmm0, [res]
                vmovdqu     xmm1, [val]
                vcmppd      xmm0, xmm0, xmm1, $00
                vmovmskpd   eax,  xmm0
                and         eax,  $03
                cmp         eax,  $03
                setne       al
                ret

                function    ScalarNotEqualsDouble4
                vmovdqu     ymm0, [res]
                vmovdqu     ymm1, [val]
                vcmppd      ymm0, ymm0, ymm1, $00
                vmovmskpd   eax,  ymm0
                and         eax,  $0f
                cmp         eax,  $0f
                setne       al
                ret

                function    ScalarNotEqualsDouble8
                vmovdqu64   zmm0, [res]
                vmovdqu64   zmm1, [val]
                vcmppd      msk1, zmm0, zmm1, $00
                kmovw       eax,  msk1
                and         eax,  $ff
                cmp         eax,  $ff
                setne       al
                ret

                function    ScalarNotEqualsFloat2
                vmovq       xmm0, [res]
                vmovq       xmm1, [val]
                vcmpps      xmm0, xmm0, xmm1, $00
                vmovmskps   eax,  xmm0
                and         eax,  $03
                cmp         eax,  $03
                setne       al
                ret

                function    ScalarNotEqualsFloat4
                vmovdqu     xmm0, [res]
                vmovdqu     xmm1, [val]
                vcmpps      xmm0, xmm0, xmm1, $00
                vmovmskps   eax,  xmm0
                and         eax,  $0f
                cmp         eax,  $0f
                setne       al
                ret

                function    ScalarNotEqualsFloat8
                vmovdqu     ymm0, [res]
                vmovdqu     ymm1, [val]
                vcmpps      ymm0, ymm0, ymm1, $00
                vmovmskps   eax,  ymm0
                and         eax,  $ff
                cmp         eax,  $ff
                setne       al
                ret

                function    ScalarNotEqualsInt2
                vmovq       xmm0, [res]
                vmovq       xmm1, [val]
                vpcmpeqd    xmm0, xmm0, xmm1
                vmovmskps   eax,  xmm0
                and         eax,  $03
                cmp         eax,  $03
                setne       al
                ret

                function    ScalarNotEqualsInt4
                vmovdqu     xmm0, [res]
                vmovdqu     xmm1, [val]
                vpcmpeqd    xmm0, xmm0, xmm1
                vmovmskps   eax,  xmm0
                and         eax,  $0f
                cmp         eax,  $0f
                setne       al
                ret

                function    ScalarNotEqualsInt8
                vmovdqu     ymm0, [res]
                vmovdqu     ymm1, [val]
                vpcmpeqd    ymm0, ymm0, ymm1
                vmovmskps   eax,  ymm0
                and         eax,  $ff
                cmp         eax,  $ff
                setne       al
                ret

                function    ScalarNotEqualsLong2
                vmovdqu     xmm0, [res]
                vmovdqu     xmm1, [val]
                vpcmpeqq    xmm0, xmm0, xmm1
                vmovmskpd   eax,  xmm0
                and         eax,  $03
                cmp         eax,  $03
                setne       al
                ret

                function    ScalarNotEqualsLong4
                vmovdqu     ymm0, [res]
                vmovdqu     ymm1, [val]
                vpcmpeqq    ymm0, ymm0, ymm1
                vmovmskpd   eax,  ymm0
                and         eax,  $0f
                cmp         eax,  $0f
                setne       al
                ret

                function    ScalarNotEqualsLong8
                vmovdqu64   zmm0, [res]
                vmovdqu64   zmm1, [val]
                vpcmpeqq    msk1, zmm0, zmm1
                kmovw       eax,  msk1
                and         eax,  $ff
                cmp         eax,  $ff
                setne       al
                ret
; </fold>

; <fold скалярное умножение>
                function    ScalarMulDouble2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vshufpd     xmm2, xmm1, xmm1, $02
                vshufpd     xmm3, xmm2, xmm2, $01
                vmulpd      xmm2, xmm2, [smuld2.c0]
                vmulpd      xmm1, xmm0, xmm3
                vmulpd      xmm0, xmm0, xmm2
                vhaddpd     xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarMulDouble4
                enterq
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vshuff64x2  ymm4, ymm1, ymm1, $02
                vshuff64x2  ymm6, ymm4, ymm4, $01
                vshufpd     ymm5, ymm4, ymm4, $05
                vshufpd     ymm7, ymm6, ymm6, $05
                vmulpd      ymm4, ymm4, [smuld4.q0]
                vmulpd      ymm5, ymm5, [smuld4.q1]
                vmulpd      ymm6, ymm6, [smuld4.q2]
                vmulpd      ymm7, ymm7, [smuld4.q3]
                vmulpd      ymm3, ymm0, ymm7
                vmulpd      ymm2, ymm0, ymm6
                vmulpd      ymm1, ymm0, ymm5
                vmulpd      ymm0, ymm0, ymm4
                vextractf128 xmm4, ymm0, $01
                vextractf128 xmm5, ymm1, $01
                vextractf128 xmm6, ymm2, $01
                vextractf128 xmm7, ymm3, $01
                vinsertf128 ymm0, ymm0, xmm2, $01
                vinsertf128 ymm2, ymm1, xmm3, $01
                vinsertf128 ymm1, ymm4, xmm6, $01
                vinsertf128 ymm3, ymm5, xmm7, $01
                vaddpd      ymm0, ymm0, ymm1
                vaddpd      ymm1, ymm2, ymm3
                vshufpd     ymm2, ymm0, ymm1, $00
                vshufpd     ymm3, ymm0, ymm1, $0f
                vaddpd      ymm0, ymm2, ymm3
                vmovdqu     yword [res], ymm0
                leaveq
                ret

                function    ScalarMulDouble8
                entero
                vmovdqu64   zmm00, [val1]
                vmovdqu64   zmm01, [val2]
                vshuff64x2  zmm08, zmm01, zmm01, $e4
                vshuff64x2  zmm10, zmm08, zmm08, $b1
                vshuff64x2  zmm12, zmm08, zmm08, $4e
                vshuff64x2  zmm14, zmm08, zmm08, $1b
                vshufpd     zmm09, zmm08, zmm08, $55
                vshufpd     zmm11, zmm10, zmm10, $55
                vshufpd     zmm13, zmm12, zmm12, $55
                vshufpd     zmm15, zmm14, zmm14, $55
                vmulpd      zmm08, zmm08, [smuld8.o0]
                vmulpd      zmm09, zmm09, [smuld8.o1]
                vmulpd      zmm10, zmm10, [smuld8.o2]
                vmulpd      zmm11, zmm11, [smuld8.o3]
                vmulpd      zmm12, zmm12, [smuld8.o4]
                vmulpd      zmm13, zmm13, [smuld8.o5]
                vmulpd      zmm14, zmm14, [smuld8.o6]
                vmulpd      zmm15, zmm15, [smuld8.o7]
                vmulpd      zmm07, zmm00, zmm15, {rn-sae}
                vmulpd      zmm06, zmm00, zmm14, {rn-sae}
                vmulpd      zmm05, zmm00, zmm13, {rn-sae}
                vmulpd      zmm04, zmm00, zmm12, {rn-sae}
                vmulpd      zmm03, zmm00, zmm11, {rn-sae}
                vmulpd      zmm02, zmm00, zmm10, {rn-sae}
                vmulpd      zmm01, zmm00, zmm09, {rn-sae}
                vmulpd      zmm00, zmm00, zmm08, {rn-sae}
                vextractf64x4 ymm08, zmm00, $01
                vextractf64x4 ymm09, zmm01, $01
                vextractf64x4 ymm10, zmm02, $01
                vextractf64x4 ymm11, zmm03, $01
                vextractf64x4 ymm12, zmm04, $01
                vextractf64x4 ymm13, zmm05, $01
                vextractf64x4 ymm14, zmm06, $01
                vextractf64x4 ymm15, zmm07, $01
                vinsertf64x4 zmm00, zmm00, ymm02, $01
                vinsertf64x4 zmm02, zmm04, ymm06, $01
                vinsertf64x4 zmm04, zmm01, ymm03, $01
                vinsertf64x4 zmm06, zmm05, ymm07, $01
                vinsertf64x4 zmm01, zmm08, ymm10, $01
                vinsertf64x4 zmm03, zmm12, ymm14, $01
                vinsertf64x4 zmm05, zmm09, ymm11, $01
                vinsertf64x4 zmm07, zmm13, ymm15, $01
                vaddpd      zmm00, zmm00, zmm01
                vaddpd      zmm01, zmm02, zmm03
                vaddpd      zmm02, zmm04, zmm05
                vaddpd      zmm03, zmm06, zmm07
                vshuff64x2  zmm04, zmm00, zmm01, $88
                vshuff64x2  zmm05, zmm00, zmm01, $dd
                vshuff64x2  zmm06, zmm02, zmm03, $88
                vshuff64x2  zmm07, zmm02, zmm03, $dd
                vaddpd      zmm00, zmm04, zmm05
                vaddpd      zmm01, zmm06, zmm07
                vshufpd     zmm02, zmm00, zmm01, $00
                vshufpd     zmm03, zmm00, zmm01, $ff
                vaddpd      zmm00, zmm02, zmm03
                vmovdqu64   zword  [res], zmm00
                leaveo
                ret

                function    ScalarMulFloat2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vshufps     xmm2, xmm1, xmm1, $e4
                vshufps     xmm3, xmm2, xmm2, $e1
                vmulps      xmm2, xmm2, [smulf2.c0]
                vmulps      xmm1, xmm0, xmm3
                vmulps      xmm0, xmm0, xmm2
                vhaddps     xmm0, xmm0, xmm1
                vshufps     xmm0, xmm0, xmm0, $d8
                vmovq       qword [res], xmm0
                ret

                function    ScalarMulFloat4
                enterq
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vshufps     xmm4, xmm1, xmm1, $e4
                vshufps     xmm5, xmm4, xmm4, $b1
                vshufps     xmm6, xmm4, xmm4, $4e
                vshufps     xmm7, xmm4, xmm4, $1b
                vmulps      xmm4, xmm4, [smulf4.q0]
                vmulps      xmm5, xmm5, [smulf4.q1]
                vmulps      xmm6, xmm6, [smulf4.q2]
                vmulps      xmm7, xmm7, [smulf4.q3]
                vmulps      xmm3, xmm0, xmm7
                vmulps      xmm2, xmm0, xmm6
                vmulps      xmm1, xmm0, xmm5
                vmulps      xmm0, xmm0, xmm4
                vhaddps     xmm0, xmm0, xmm1
                vhaddps     xmm1, xmm2, xmm3
                vhaddps     xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                leaveq
                ret

                function    ScalarMulFloat8
                entero
                vmovdqu     ymm00, [val1]
                vmovdqu     ymm01, [val2]
                vmovdqa     ymm08, ymm01
                vextractf128 xmm12, ymm08, $01
                vinsertf128 ymm12, ymm12, xmm08, $01
                vshufps     ymm09, ymm08, ymm08, $b1
                vshufps     ymm10, ymm08, ymm08, $4e
                vshufps     ymm11, ymm08, ymm08, $1b
                vshufps     ymm13, ymm12, ymm12, $b1
                vshufps     ymm14, ymm12, ymm12, $4e
                vshufps     ymm15, ymm12, ymm12, $1b
                vmulps      ymm08, ymm08, [smulf8.o0]
                vmulps      ymm09, ymm09, [smulf8.o1]
                vmulps      ymm10, ymm10, [smulf8.o2]
                vmulps      ymm11, ymm11, [smulf8.o3]
                vmulps      ymm12, ymm12, [smulf8.o4]
                vmulps      ymm13, ymm13, [smulf8.o5]
                vmulps      ymm14, ymm14, [smulf8.o6]
                vmulps      ymm15, ymm15, [smulf8.o7]
                vmulps      ymm07, ymm00, ymm15
                vmulps      ymm06, ymm00, ymm14
                vmulps      ymm05, ymm00, ymm13
                vmulps      ymm04, ymm00, ymm12
                vmulps      ymm03, ymm00, ymm11
                vmulps      ymm02, ymm00, ymm10
                vmulps      ymm01, ymm00, ymm09
                vmulps      ymm00, ymm00, ymm08
                vhaddps     ymm00, ymm00, ymm01
                vhaddps     ymm01, ymm02, ymm03
                vhaddps     ymm02, ymm04, ymm05
                vhaddps     ymm03, ymm06, ymm07
                vhaddps     ymm00, ymm00, ymm01
                vhaddps     ymm01, ymm02, ymm03
                vextractf128 xmm02, ymm00, $01
                vextractf128 xmm03, ymm01, $01
                vaddps      xmm00, xmm00, xmm02
                vaddps      xmm01, xmm01, xmm03
                vinsertf128 ymm00, ymm00, xmm01, $01
                vmovdqu     yword  [res], ymm00
                leaveo
                ret

                function    ScalarMulInt2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vshufps     xmm2, xmm1, xmm1, $e4
                vshufps     xmm3, xmm2, xmm2, $e1
                vpmulld     xmm2, xmm2, [smuli2.c0]
                vpmulld     xmm1, xmm0, xmm3
                vpmulld     xmm0, xmm0, xmm2
                vphaddd     xmm0, xmm0, xmm1
                vshufps     xmm0, xmm0, xmm0, $d8
                vmovq       qword [res], xmm0
                ret

                function    ScalarMulInt4
                enterq
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vshufps     xmm4, xmm1, xmm1, $e4
                vshufps     xmm5, xmm4, xmm4, $b1
                vshufps     xmm6, xmm4, xmm4, $4e
                vshufps     xmm7, xmm4, xmm4, $1b
                vpmulld     xmm4, xmm4, [smuli4.q0]
                vpmulld     xmm5, xmm5, [smuli4.q1]
                vpmulld     xmm6, xmm6, [smuli4.q2]
                vpmulld     xmm7, xmm7, [smuli4.q3]
                vpmulld     xmm3, xmm0, xmm7
                vpmulld     xmm2, xmm0, xmm6
                vpmulld     xmm1, xmm0, xmm5
                vpmulld     xmm0, xmm0, xmm4
                vphaddd     xmm0, xmm0, xmm1
                vphaddd     xmm1, xmm2, xmm3
                vphaddd     xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                leaveq
                ret

                function    ScalarMulInt8
                entero
                vmovdqu     ymm00, [val1]
                vmovdqu     ymm01, [val2]
                vmovdqa     ymm08, ymm01
                vextracti128 xmm12, ymm08, $01
                vinserti128 ymm12, ymm12, xmm08, $01
                vshufps     ymm09, ymm08, ymm08, $b1
                vshufps     ymm10, ymm08, ymm08, $4e
                vshufps     ymm11, ymm08, ymm08, $1b
                vshufps     ymm13, ymm12, ymm12, $b1
                vshufps     ymm14, ymm12, ymm12, $4e
                vshufps     ymm15, ymm12, ymm12, $1b
                vpmulld     ymm08, ymm08, [smuli8.o0]
                vpmulld     ymm09, ymm09, [smuli8.o1]
                vpmulld     ymm10, ymm10, [smuli8.o2]
                vpmulld     ymm11, ymm11, [smuli8.o3]
                vpmulld     ymm12, ymm12, [smuli8.o4]
                vpmulld     ymm13, ymm13, [smuli8.o5]
                vpmulld     ymm14, ymm14, [smuli8.o6]
                vpmulld     ymm15, ymm15, [smuli8.o7]
                vpmulld     ymm07, ymm00, ymm15
                vpmulld     ymm06, ymm00, ymm14
                vpmulld     ymm05, ymm00, ymm13
                vpmulld     ymm04, ymm00, ymm12
                vpmulld     ymm03, ymm00, ymm11
                vpmulld     ymm02, ymm00, ymm10
                vpmulld     ymm01, ymm00, ymm09
                vpmulld     ymm00, ymm00, ymm08
                vphaddd     ymm00, ymm00, ymm01
                vphaddd     ymm01, ymm02, ymm03
                vphaddd     ymm02, ymm04, ymm05
                vphaddd     ymm03, ymm06, ymm07
                vphaddd     ymm00, ymm00, ymm01
                vphaddd     ymm01, ymm02, ymm03
                vextracti128 xmm02, ymm00, $01
                vextracti128 xmm03, ymm01, $01
                vpaddd      xmm00, xmm00, xmm02
                vpaddd      xmm01, xmm01, xmm03
                vinserti128 ymm00, ymm00, xmm01, $01
                vmovdqu     yword  [res], ymm00
                leaveo
                ret

                function    ScalarMulLong2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vshufpd     xmm2, xmm1, xmm1, $02
                vshufpd     xmm3, xmm2, xmm2, $01
                vpmullq     xmm2, xmm2, [smull2.c0]
                vpmullq     xmm1, xmm0, xmm3
                vpmullq     xmm0, xmm0, xmm2
                vshufpd     xmm2, xmm0, xmm1, $00
                vshufpd     xmm3, xmm0, xmm1, $03
                vpaddq      xmm0, xmm2, xmm3
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarMulLong4
                enterq
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vshufi64x2  ymm4, ymm1, ymm1, $02
                vshufi64x2  ymm6, ymm4, ymm4, $01
                vshufpd     ymm5, ymm4, ymm4, $05
                vshufpd     ymm7, ymm6, ymm6, $05
                vpmullq     ymm4, ymm4, [smull4.q0]
                vpmullq     ymm5, ymm5, [smull4.q1]
                vpmullq     ymm6, ymm6, [smull4.q2]
                vpmullq     ymm7, ymm7, [smull4.q3]
                vpmullq     ymm3, ymm0, ymm7
                vpmullq     ymm2, ymm0, ymm6
                vpmullq     ymm1, ymm0, ymm5
                vpmullq     ymm0, ymm0, ymm4
                vextracti128 xmm4, ymm0, $01
                vextracti128 xmm5, ymm1, $01
                vextracti128 xmm6, ymm2, $01
                vextracti128 xmm7, ymm3, $01
                vinserti128 ymm0, ymm0, xmm2, $01
                vinserti128 ymm2, ymm1, xmm3, $01
                vinserti128 ymm1, ymm4, xmm6, $01
                vinserti128 ymm3, ymm5, xmm7, $01
                vpaddq      ymm0, ymm0, ymm1
                vpaddq      ymm1, ymm2, ymm3
                vshufpd     ymm2, ymm0, ymm1, $00
                vshufpd     ymm3, ymm0, ymm1, $0f
                vpaddq      ymm0, ymm2, ymm3
                vmovdqu     yword [res], ymm0
                leaveq
                ret

                function    ScalarMulLong8
                entero
                vmovdqu64   zmm00, [val1]
                vmovdqu64   zmm01, [val2]
                vshufi64x2  zmm08, zmm01, zmm01, $e4
                vshufi64x2  zmm10, zmm08, zmm08, $b1
                vshufi64x2  zmm12, zmm08, zmm08, $4e
                vshufi64x2  zmm14, zmm08, zmm08, $1b
                vshufpd     zmm09, zmm08, zmm08, $55
                vshufpd     zmm11, zmm10, zmm10, $55
                vshufpd     zmm13, zmm12, zmm12, $55
                vshufpd     zmm15, zmm14, zmm14, $55
                vpmullq     zmm08, zmm08, [smull8.o0]
                vpmullq     zmm09, zmm09, [smull8.o1]
                vpmullq     zmm10, zmm10, [smull8.o2]
                vpmullq     zmm11, zmm11, [smull8.o3]
                vpmullq     zmm12, zmm12, [smull8.o4]
                vpmullq     zmm13, zmm13, [smull8.o5]
                vpmullq     zmm14, zmm14, [smull8.o6]
                vpmullq     zmm15, zmm15, [smull8.o7]
                vpmullq     zmm07, zmm00, zmm15
                vpmullq     zmm06, zmm00, zmm14
                vpmullq     zmm05, zmm00, zmm13
                vpmullq     zmm04, zmm00, zmm12
                vpmullq     zmm03, zmm00, zmm11
                vpmullq     zmm02, zmm00, zmm10
                vpmullq     zmm01, zmm00, zmm09
                vpmullq     zmm00, zmm00, zmm08
                vextracti64x4 ymm08, zmm00, $01
                vextracti64x4 ymm09, zmm01, $01
                vextracti64x4 ymm10, zmm02, $01
                vextracti64x4 ymm11, zmm03, $01
                vextracti64x4 ymm12, zmm04, $01
                vextracti64x4 ymm13, zmm05, $01
                vextracti64x4 ymm14, zmm06, $01
                vextracti64x4 ymm15, zmm07, $01
                vinserti64x4 zmm00, zmm00, ymm02, $01
                vinserti64x4 zmm02, zmm04, ymm06, $01
                vinserti64x4 zmm04, zmm01, ymm03, $01
                vinserti64x4 zmm06, zmm05, ymm07, $01
                vinserti64x4 zmm01, zmm08, ymm10, $01
                vinserti64x4 zmm03, zmm12, ymm14, $01
                vinserti64x4 zmm05, zmm09, ymm11, $01
                vinserti64x4 zmm07, zmm13, ymm15, $01
                vpaddq      zmm00, zmm00, zmm01
                vpaddq      zmm01, zmm02, zmm03
                vpaddq      zmm02, zmm04, zmm05
                vpaddq      zmm03, zmm06, zmm07
                vshufi64x2  zmm04, zmm00, zmm01, $88
                vshufi64x2  zmm05, zmm00, zmm01, $dd
                vshufi64x2  zmm06, zmm02, zmm03, $88
                vshufi64x2  zmm07, zmm02, zmm03, $dd
                vpaddq      zmm00, zmm04, zmm05
                vpaddq      zmm01, zmm06, zmm07
                vshufpd     zmm02, zmm00, zmm01, $00
                vshufpd     zmm03, zmm00, zmm01, $ff
                vpaddq      zmm00, zmm02, zmm03
                vmovdqu64   zword  [res], zmm00
                leaveo
                ret
; </fold>

; <fold скалярное отрицание>
                function    ScalarNegDouble2
                vmovdqu     xmm0, [val]
                vpxor       xmm1, xmm0, xmm0
                vsubpd      xmm0, xmm1, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarNegDouble4
                vmovdqu     ymm0, [val]
                vpxor       ymm1, ymm0, ymm0
                vsubpd      ymm0, ymm1, ymm0
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarNegDouble8
                vmovdqu64   zmm0, [val]
                vpxorq      zmm1, zmm0, zmm0
                vsubpd      zmm0, zmm1, zmm0
                vmovdqu64   zword [res], zmm0
                ret

                function    ScalarNegFloat2
                vmovq       xmm0, [val]
                vpxor       xmm1, xmm0, xmm0
                vsubps      xmm0, xmm1, xmm0
                vmovq       qword [res], xmm0
                ret

                function    ScalarNegFloat4
                vmovdqu     xmm0, [val]
                vpxor       xmm1, xmm0, xmm0
                vsubps      xmm0, xmm1, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarNegFloat8
                vmovdqu     ymm0, [val]
                vpxor       ymm1, ymm0, ymm0
                vsubps      ymm0, ymm1, ymm0
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarNegInt2
                vmovq       xmm0, [val]
                vpxor       xmm1, xmm0, xmm0
                vpsubd      xmm0, xmm1, xmm0
                vmovq       qword [res], xmm0
                ret

                function    ScalarNegInt4
                vmovdqu     xmm0, [val]
                vpxor       xmm1, xmm0, xmm0
                vpsubd      xmm0, xmm1, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarNegInt8
                vmovdqu     ymm0, [val]
                vpxor       ymm1, ymm0, ymm0
                vpsubd      ymm0, ymm1, ymm0
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarNegLong2
                vmovdqu     xmm0, [val]
                vpxor       xmm1, xmm0, xmm0
                vpsubq      xmm0, xmm1, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarNegLong4
                vmovdqu     ymm0, [val]
                vpxor       ymm1, ymm0, ymm0
                vpsubq      ymm0, ymm1, ymm0
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarNegLong8
                vmovdqu64   zmm0, [val]
                vpxorq      zmm1, zmm0, zmm0
                vpsubq      zmm0, zmm1, zmm0
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold скалярный сдвиг влево>
                function    ScalarShlInt2
                and         iVal2, $1f
                vmovd       xmm1, iVal2
                vmovq       xmm0, [val1]
                vpslld      xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    ScalarShlInt4
                and         iVal2, $1f
                vmovd       xmm1, iVal2
                vmovdqu     xmm0, [val1]
                vpslld      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarShlInt8
                and         iVal2, $1f
                vmovd       xmm1, iVal2
                vmovdqu     ymm0, [val1]
                vpslld      ymm0, ymm0, xmm1
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarShlLong2
                and         iVal2, $3f
                vmovd       xmm1, iVal2
                vmovdqu     xmm0, [val1]
                vpsllq      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarShlLong4
                and         iVal2, $3f
                vmovd       xmm1, iVal2
                vmovdqu     ymm0, [val1]
                vpsllq      ymm0, ymm0, xmm1
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarShlLong8
                and         iVal2, $3f
                vmovd       xmm1, iVal2
                vmovdqu64   zmm0, [val1]
                vpsllq      zmm0, zmm0, xmm1
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold скалярный сдвиг вправо>
                function    ScalarShrInt2
                and         iVal2, $1f
                vmovd       xmm1, iVal2
                vmovq       xmm0, [val1]
                vpsrad      xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    ScalarShrInt4
                and         iVal2, $1f
                vmovd       xmm1, iVal2
                vmovdqu     xmm0, [val1]
                vpsrad      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarShrInt8
                and         iVal2, $1f
                vmovd       xmm1, iVal2
                vmovdqu     ymm0, [val1]
                vpsrad      ymm0, ymm0, xmm1
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarShrLong2
                and         iVal2, $3f
                vmovd       xmm1, iVal2
                vmovdqu     xmm0, [val1]
                vpsraq      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarShrLong4
                and         iVal2, $3f
                vmovd       xmm1, iVal2
                vmovdqu     ymm0, [val1]
                vpsraq      ymm0, ymm0, xmm1
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarShrLong8
                and         iVal2, $3f
                vmovd       xmm1, iVal2
                vmovdqu64   zmm0, [val1]
                vpsraq      zmm0, zmm0, xmm1
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold скалярный беззнаковый сдвиг вправо>
                function    ScalarShruInt2
                and         iVal2, $1f
                vmovd       xmm1, iVal2
                vmovq       xmm0, [val1]
                vpsrld      xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    ScalarShruInt4
                and         iVal2, $1f
                vmovd       xmm1, iVal2
                vmovdqu     xmm0, [val1]
                vpsrld      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarShruInt8
                and         iVal2, $1f
                vmovd       xmm1, iVal2
                vmovdqu     ymm0, [val1]
                vpsrld      ymm0, ymm0, xmm1
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarShruLong2
                and         iVal2, $3f
                vmovd       xmm1, iVal2
                vmovdqu     xmm0, [val1]
                vpsrlq      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarShruLong4
                and         iVal2, $3f
                vmovd       xmm1, iVal2
                vmovdqu     ymm0, [val1]
                vpsrlq      ymm0, ymm0, xmm1
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarShruLong8
                and         iVal2, $3f
                vmovd       xmm1, iVal2
                vmovdqu64   zmm0, [val1]
                vpsrlq      zmm0, zmm0, xmm1
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold скалярное вычитание>
                function    ScalarSubDouble2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vsubpd      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarSubDouble4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vsubpd      ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarSubDouble8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vsubpd      zmm0, zmm0, zmm1
                vmovdqu64   zword [res], zmm0
                ret

                function    ScalarSubFloat2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vsubps      xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    ScalarSubFloat4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vsubps      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarSubFloat8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vsubps      ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarSubInt2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpsubd      xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    ScalarSubInt4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpsubd      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarSubInt8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpsubd      ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarSubLong2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpsubq      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    ScalarSubLong4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpsubq      ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    ScalarSubLong8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vpsubq      zmm0, zmm0, zmm1
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold векторное сложение>
                function    VectorAddByte2
                movzx       iVal1, word  [val1]
                movzx       iVal2, word  [val2]
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpaddb      xmm0, xmm0, xmm1
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorAddByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpaddb      xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorAddByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpaddb      xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorAddShort2
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpaddw      xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorAddShort4
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpaddw      xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorAddShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpaddw      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold векторное деление>
                function    VectorDivDouble2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vdivpd      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    VectorDivDouble4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vdivpd      ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    VectorDivDouble8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vdivpd      zmm0, zmm0, zmm1
                vmovdqu64   zword [res], zmm0
                ret

                function    VectorDivFloat2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vdivps      xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorDivFloat4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vdivps      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    VectorDivFloat8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vdivps      ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret
; </fold>

; <fold векторное равно>
                function    VectorEqualsDouble
                vcmpsd      xmm0, xmm0, xmm1, $00
                vmovq       rax,  xmm0
                ret

                function    VectorEqualsDouble2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vcmppd      xmm0, xmm0, xmm1, $00
                vmovdqu     xword [res], xmm0
                ret

                function    VectorEqualsDouble4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vcmppd      ymm0, ymm0, ymm1, $00
                vmovdqu     yword [res], ymm0
                ret

                function    VectorEqualsDouble8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vcmppd      msk1, zmm0, zmm1, $00
                vmovdqa64   zmm0{k1}{z}, [long8.m1]
                vmovdqu64   zword [res], zmm0
                ret

                function    VectorEqualsFloat
                vcmpss      xmm0, xmm0, xmm1, $00
                vmovd       eax,  xmm0
                ret

                function    VectorEqualsFloat2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vcmpps      xmm0, xmm0, xmm1, $00
                vmovq       qword [res], xmm0
                ret

                function    VectorEqualsFloat4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vcmpps      xmm0, xmm0, xmm1, $00
                vmovdqu     xword [res], xmm0
                ret

                function    VectorEqualsFloat8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vcmpps      ymm0, ymm0, ymm1, $00
                vmovdqu     yword [res], ymm0
                ret

                function    VectorEqualsByte
                cmp         bRes, bVal
                setne       al
                dec         al
                movsx       eax,  al
                ret

                function    VectorEqualsByte2
                movzx       iVal1, word  [val1]
                movzx       iVal2, word  [val2]
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpcmpeqb    xmm0, xmm0, xmm1
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorEqualsByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpcmpeqb    xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorEqualsByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpeqb    xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorEqualsShort
                cmp         sRes, sVal
                setne       al
                dec         al
                movsx       eax,  al
                ret

                function    VectorEqualsShort2
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpcmpeqw    xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorEqualsShort4
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpeqw    xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorEqualsShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpeqw    xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    VectorEqualsInt
                cmp         iRes, iVal
                setne       al
                dec         al
                movsx       eax,  al
                ret

                function    VectorEqualsInt2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpeqd    xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorEqualsInt4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpeqd    xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    VectorEqualsInt8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpcmpeqd    ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    VectorEqualsLong
                cmp         lRes, lVal
                setne       al
                dec         al
                movsx       rax,  al
                ret

                function    VectorEqualsLong2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpeqq    xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    VectorEqualsLong4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpcmpeqq    ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    VectorEqualsLong8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vpcmpeqq    msk1, zmm0, zmm1
                vmovdqa64   zmm0{k1}{z}, [long8.m1]
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold векторное больше или равно>
                function    VectorGreaterOrEqualsDouble
                vcmpsd      xmm0, xmm1, xmm0, $02
                vmovq       rax,  xmm0
                ret

                function    VectorGreaterOrEqualsDouble2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vcmppd      xmm0, xmm1, xmm0, $02
                vmovdqu     xword [res], xmm0
                ret

                function    VectorGreaterOrEqualsDouble4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vcmppd      ymm0, ymm1, ymm0, $02
                vmovdqu     yword [res], ymm0
                ret

                function    VectorGreaterOrEqualsDouble8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vcmppd      msk1, zmm1, zmm0, $02
                vmovdqa64   zmm0{k1}{z}, [long8.m1]
                vmovdqu64   zword [res], zmm0
                ret

                function    VectorGreaterOrEqualsFloat
                vcmpss      xmm0, xmm1, xmm0, $02
                vmovd       eax,  xmm0
                ret

                function    VectorGreaterOrEqualsFloat2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vcmpps      xmm0, xmm1, xmm0, $02
                vmovq       qword [res], xmm0
                ret

                function    VectorGreaterOrEqualsFloat4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vcmpps      xmm0, xmm1, xmm0, $02
                vmovdqu     xword [res], xmm0
                ret

                function    VectorGreaterOrEqualsFloat8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vcmpps      ymm0, ymm1, ymm0, $02
                vmovdqu     yword [res], ymm0
                ret

                function    VectorGreaterOrEqualsByte
                cmp         bRes, bVal
                setnge      al
                dec         al
                movsx       eax,  al
                ret

                function    VectorGreaterOrEqualsByte2
                movzx       iVal1, word  [val1]
                movzx       iVal2, word  [val2]
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpcmpgtb    xmm0, xmm1, xmm0
                vpxor       xmm0, xmm0, [byte8.mask2]
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorGreaterOrEqualsByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpcmpgtb    xmm0, xmm1, xmm0
                vpxor       xmm0, xmm0, [byte8.mask4]
                vmovd       dword [res], xmm0
                ret

                function    VectorGreaterOrEqualsByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpgtb    xmm0, xmm1, xmm0
                vpxor       xmm0, xmm0, [byte8.mask8]
                vmovq       qword [res], xmm0
                ret

                function    VectorGreaterOrEqualsShort
                cmp         sRes, sVal
                setnge      al
                dec         al
                movsx       eax,  al
                ret

                function    VectorGreaterOrEqualsShort2
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpcmpgtw    xmm0, xmm1, xmm0
                vpxor       xmm0, xmm0, [short8.mask2]
                vmovd       dword [res], xmm0
                ret

                function    VectorGreaterOrEqualsShort4
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpgtw    xmm0, xmm1, xmm0
                vpxor       xmm0, xmm0, [short8.mask4]
                vmovq       qword [res], xmm0
                ret

                function    VectorGreaterOrEqualsShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpgtw    xmm0, xmm1, xmm0
                vpxor       xmm0, xmm0, [short8.mask8]
                vmovdqu     xword [res], xmm0
                ret

                function    VectorGreaterOrEqualsInt
                cmp         iRes, iVal
                setnge      al
                dec         al
                movsx       eax,  al
                ret

                function    VectorGreaterOrEqualsInt2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpgtd    xmm0, xmm1, xmm0
                vpxor       xmm0, xmm0, [int8.mask2]
                vmovq       qword [res], xmm0
                ret

                function    VectorGreaterOrEqualsInt4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpgtd    xmm0, xmm1, xmm0
                vpxor       xmm0, xmm0, [int8.mask4]
                vmovdqu     xword [res], xmm0
                ret

                function    VectorGreaterOrEqualsInt8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpcmpgtd    ymm0, ymm1, ymm0
                vpxor       ymm0, ymm0, [int8.mask8]
                vmovdqu     yword [res], ymm0
                ret

                function    VectorGreaterOrEqualsLong
                cmp         lRes, lVal
                setnge      al
                dec         al
                movsx       rax,  al
                ret

                function    VectorGreaterOrEqualsLong2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpgtq    xmm0, xmm1, xmm0
                vpxor       xmm0, xmm0, [long8.mask2]
                vmovdqu     xword [res], xmm0
                ret

                function    VectorGreaterOrEqualsLong4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpcmpgtq    ymm0, ymm1, ymm0
                vpxor       ymm0, ymm0, [long8.mask4]
                vmovdqu     yword [res], ymm0
                ret

                function    VectorGreaterOrEqualsLong8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vpcmpgtq    msk1, zmm1, zmm0
                knotw       msk1, msk1
                vmovdqa64   zmm0{k1}{z}, [long8.mask8]
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold векторное больше>
                function    VectorGreaterThanDouble
                vcmpsd      xmm0, xmm1, xmm0, $01
                vmovq       rax,  xmm0
                ret

                function    VectorGreaterThanDouble2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vcmppd      xmm0, xmm1, xmm0, $01
                vmovdqu     xword [res], xmm0
                ret

                function    VectorGreaterThanDouble4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vcmppd      ymm0, ymm1, ymm0, $01
                vmovdqu     yword [res], ymm0
                ret

                function    VectorGreaterThanDouble8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vcmppd      msk1, zmm1, zmm0, $01
                vmovdqa64   zmm0{k1}{z}, [long8.m1]
                vmovdqu64   zword [res], zmm0
                ret

                function    VectorGreaterThanFloat
                vcmpss      xmm0, xmm1, xmm0, $01
                vmovd       eax,  xmm0
                ret

                function    VectorGreaterThanFloat2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vcmpps      xmm0, xmm1, xmm0, $01
                vmovq       qword [res], xmm0
                ret

                function    VectorGreaterThanFloat4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vcmpps      xmm0, xmm1, xmm0, $01
                vmovdqu     xword [res], xmm0
                ret

                function    VectorGreaterThanFloat8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vcmpps      ymm0, ymm1, ymm0, $01
                vmovdqu     yword [res], ymm0
                ret

                function    VectorGreaterThanByte
                cmp         bRes, bVal
                setng       al
                dec         al
                movsx       eax,  al
                ret

                function    VectorGreaterThanByte2
                movzx       iVal1, word  [val1]
                movzx       iVal2, word  [val2]
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpcmpgtb    xmm0, xmm0, xmm1
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorGreaterThanByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpcmpgtb    xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorGreaterThanByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpgtb    xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorGreaterThanShort
                cmp         sRes, sVal
                setng       al
                dec         al
                movsx       eax,  al
                ret

                function    VectorGreaterThanShort2
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpcmpgtw    xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorGreaterThanShort4
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpgtw    xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorGreaterThanShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpgtw    xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    VectorGreaterThanInt
                cmp         iRes, iVal
                setng       al
                dec         al
                movsx       eax,  al
                ret

                function    VectorGreaterThanInt2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpgtd    xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorGreaterThanInt4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpgtd    xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    VectorGreaterThanInt8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpcmpgtd    ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    VectorGreaterThanLong
                cmp         lRes, lVal
                setng       al
                dec         al
                movsx       rax,  al
                ret

                function    VectorGreaterThanLong2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpgtq    xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    VectorGreaterThanLong4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpcmpgtq    ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    VectorGreaterThanLong8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vpcmpgtq    msk1, zmm0, zmm1
                vmovdqa64   zmm0{k1}{z}, [long8.m1]
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold векторное меньше или равно>
                function    VectorLessOrEqualsDouble
                vcmpsd      xmm0, xmm0, xmm1, $02
                vmovq       rax,  xmm0
                ret

                function    VectorLessOrEqualsDouble2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vcmppd      xmm0, xmm0, xmm1, $02
                vmovdqu     xword [res], xmm0
                ret

                function    VectorLessOrEqualsDouble4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vcmppd      ymm0, ymm0, ymm1, $02
                vmovdqu     yword [res], ymm0
                ret

                function    VectorLessOrEqualsDouble8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vcmppd      msk1, zmm0, zmm1, $02
                vmovdqa64   zmm0{k1}{z}, [long8.m1]
                vmovdqu64   zword [res], zmm0
                ret

                function    VectorLessOrEqualsFloat
                vcmpss      xmm0, xmm0, xmm1, $02
                vmovd       eax,  xmm0
                ret

                function    VectorLessOrEqualsFloat2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vcmpps      xmm0, xmm0, xmm1, $02
                vmovq       qword [res], xmm0
                ret

                function    VectorLessOrEqualsFloat4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vcmpps      xmm0, xmm0, xmm1, $02
                vmovdqu     xword [res], xmm0
                ret

                function    VectorLessOrEqualsFloat8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vcmpps      ymm0, ymm0, ymm1, $02
                vmovdqu     yword [res], ymm0
                ret

                function    VectorLessOrEqualsByte
                cmp         bRes, bVal
                setnle      al
                dec         al
                movsx       eax,  al
                ret

                function    VectorLessOrEqualsByte2
                movzx       iVal1, word  [val1]
                movzx       iVal2, word  [val2]
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpcmpgtb    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [byte8.mask2]
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorLessOrEqualsByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpcmpgtb    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [byte8.mask4]
                vmovd       dword [res], xmm0
                ret

                function    VectorLessOrEqualsByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpgtb    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [byte8.mask8]
                vmovq       qword [res], xmm0
                ret

                function    VectorLessOrEqualsShort
                cmp         sRes, sVal
                setnle      al
                dec         al
                movsx       eax,  al
                ret

                function    VectorLessOrEqualsShort2
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpcmpgtw    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [short8.mask2]
                vmovd       dword [res], xmm0
                ret

                function    VectorLessOrEqualsShort4
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpgtw    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [short8.mask4]
                vmovq       qword [res], xmm0
                ret

                function    VectorLessOrEqualsShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpgtw    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [short8.mask8]
                vmovdqu     xword [res], xmm0
                ret

                function    VectorLessOrEqualsInt
                cmp         iRes, iVal
                setnle      al
                dec         al
                movsx       eax,  al
                ret

                function    VectorLessOrEqualsInt2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpgtd    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [int8.mask2]
                vmovq       qword [res], xmm0
                ret

                function    VectorLessOrEqualsInt4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpgtd    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [int8.mask4]
                vmovdqu     xword [res], xmm0
                ret

                function    VectorLessOrEqualsInt8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpcmpgtd    ymm0, ymm0, ymm1
                vpxor       ymm0, ymm0, [int8.mask8]
                vmovdqu     yword [res], ymm0
                ret

                function    VectorLessOrEqualsLong
                cmp         lRes, lVal
                setnle      al
                dec         al
                movsx       rax,  al
                ret

                function    VectorLessOrEqualsLong2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpgtq    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [long8.mask2]
                vmovdqu     xword [res], xmm0
                ret

                function    VectorLessOrEqualsLong4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpcmpgtq    ymm0, ymm0, ymm1
                vpxor       ymm0, ymm0, [long8.mask4]
                vmovdqu     yword [res], ymm0
                ret

                function    VectorLessOrEqualsLong8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vpcmpgtq    msk1, zmm0, zmm1
                knotw       msk1, msk1
                vmovdqa64   zmm0{k1}{z}, [long8.mask8]
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold векторное меньше>
                function    VectorLessThanDouble
                vcmpsd      xmm0, xmm0, xmm1, $01
                vmovq       rax,  xmm0
                ret

                function    VectorLessThanDouble2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vcmppd      xmm0, xmm0, xmm1, $01
                vmovdqu     xword [res], xmm0
                ret

                function    VectorLessThanDouble4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vcmppd      ymm0, ymm0, ymm1, $01
                vmovdqu     yword [res], ymm0
                ret

                function    VectorLessThanDouble8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vcmppd      msk1, zmm0, zmm1, $01
                vmovdqa64   zmm0{k1}{z}, [long8.m1]
                vmovdqu64   zword [res], zmm0
                ret

                function    VectorLessThanFloat
                vcmpss      xmm0, xmm0, xmm1, $01
                vmovd       eax,  xmm0
                ret

                function    VectorLessThanFloat2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vcmpps      xmm0, xmm0, xmm1, $01
                vmovq       qword [res], xmm0
                ret

                function    VectorLessThanFloat4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vcmpps      xmm0, xmm0, xmm1, $01
                vmovdqu     xword [res], xmm0
                ret

                function    VectorLessThanFloat8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vcmpps      ymm0, ymm0, ymm1, $01
                vmovdqu     yword [res], ymm0
                ret

                function    VectorLessThanByte
                cmp         bRes, bVal
                setnl       al
                dec         al
                movsx       eax,  al
                ret

                function    VectorLessThanByte2
                movzx       iVal1, word  [val1]
                movzx       iVal2, word  [val2]
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpcmpgtb    xmm0, xmm1, xmm0
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorLessThanByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpcmpgtb    xmm0, xmm1, xmm0
                vmovd       dword [res], xmm0
                ret

                function    VectorLessThanByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpgtb    xmm0, xmm1, xmm0
                vmovq       qword [res], xmm0
                ret

                function    VectorLessThanShort
                cmp         sRes, sVal
                setnl       al
                dec         al
                movsx       eax,  al
                ret

                function    VectorLessThanShort2
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpcmpgtw    xmm0, xmm1, xmm0
                vmovd       dword [res], xmm0
                ret

                function    VectorLessThanShort4
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpgtw    xmm0, xmm1, xmm0
                vmovq       qword [res], xmm0
                ret

                function    VectorLessThanShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpgtw    xmm0, xmm1, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    VectorLessThanInt
                cmp         iRes, iVal
                setnl       al
                dec         al
                movsx       eax,  al
                ret

                function    VectorLessThanInt2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpgtd    xmm0, xmm1, xmm0
                vmovq       qword [res], xmm0
                ret

                function    VectorLessThanInt4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpgtd    xmm0, xmm1, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    VectorLessThanInt8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpcmpgtd    ymm0, ymm1, ymm0
                vmovdqu     yword [res], ymm0
                ret

                function    VectorLessThanLong
                cmp         lRes, lVal
                setnl       al
                dec         al
                movsx       rax,  al
                ret

                function    VectorLessThanLong2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpgtq    xmm0, xmm1, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    VectorLessThanLong4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpcmpgtq    ymm0, ymm1, ymm0
                vmovdqu     yword [res], ymm0
                ret

                function    VectorLessThanLong8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vpcmpgtq    msk1, zmm1, zmm0
                vmovdqa64   zmm0{k1}{z}, [long8.m1]
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold векторное не равно>
                function    VectorNotEqualsDouble
                vcmpsd      xmm0, xmm0, xmm1, $04
                vmovq       rax,  xmm0
                ret

                function    VectorNotEqualsDouble2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vcmppd      xmm0, xmm0, xmm1, $04
                vmovdqu     xword [res], xmm0
                ret

                function    VectorNotEqualsDouble4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vcmppd      ymm0, ymm0, ymm1, $04
                vmovdqu     yword [res], ymm0
                ret

                function    VectorNotEqualsDouble8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vcmppd      msk1, zmm0, zmm1, $04
                vmovdqa64   zmm0{k1}{z}, [long8.m1]
                vmovdqu64   zword [res], zmm0
                ret

                function    VectorNotEqualsFloat
                vcmpss      xmm0, xmm0, xmm1, $04
                vmovd       eax,  xmm0
                ret

                function    VectorNotEqualsFloat2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vcmpps      xmm0, xmm0, xmm1, $04
                vmovq       qword [res], xmm0
                ret

                function    VectorNotEqualsFloat4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vcmpps      xmm0, xmm0, xmm1, $04
                vmovdqu     xword [res], xmm0
                ret

                function    VectorNotEqualsFloat8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vcmpps      ymm0, ymm0, ymm1, $04
                vmovdqu     yword [res], ymm0
                ret

                function    VectorNotEqualsByte
                cmp         bRes, bVal
                sete        al
                dec         al
                movsx       eax,  al
                ret

                function    VectorNotEqualsByte2
                movzx       iVal1, word  [val1]
                movzx       iVal2, word  [val2]
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpcmpeqb    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [byte8.m1]
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorNotEqualsByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpcmpeqb    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [byte8.m1]
                vmovd       dword [res], xmm0
                ret

                function    VectorNotEqualsByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpeqb    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [byte8.m1]
                vmovq       qword [res], xmm0
                ret

                function    VectorNotEqualsShort
                cmp         sRes, sVal
                sete        al
                dec         al
                movsx       eax,  al
                ret

                function    VectorNotEqualsShort2
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpcmpeqw    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [short8.m1]
                vmovd       dword [res], xmm0
                ret

                function    VectorNotEqualsShort4
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpeqw    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [short8.m1]
                vmovq       qword [res], xmm0
                ret

                function    VectorNotEqualsShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpeqw    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [short8.m1]
                vmovdqu     xword [res], xmm0
                ret

                function    VectorNotEqualsInt
                cmp         iRes, iVal
                sete        al
                dec         al
                movsx       eax,  al
                ret

                function    VectorNotEqualsInt2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpcmpeqd    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [int8.m1]
                vmovq       qword [res], xmm0
                ret

                function    VectorNotEqualsInt4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpeqd    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [int8.m1]
                vmovdqu     xword [res], xmm0
                ret

                function    VectorNotEqualsInt8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpcmpeqd    ymm0, ymm0, ymm1
                vpxor       ymm0, ymm0, [int8.m1]
                vmovdqu     yword [res], ymm0
                ret

                function    VectorNotEqualsLong
                cmp         lRes, lVal
                sete        al
                dec         al
                movsx       rax,  al
                ret

                function    VectorNotEqualsLong2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpcmpeqq    xmm0, xmm0, xmm1
                vpxor       xmm0, xmm0, [long8.m1]
                vmovdqu     xword [res], xmm0
                ret

                function    VectorNotEqualsLong4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpcmpeqq    ymm0, ymm0, ymm1
                vpxor       ymm0, ymm0, [long8.m1]
                vmovdqu     yword [res], ymm0
                ret

                function    VectorNotEqualsLong8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vpcmpeqq    msk1, zmm0, zmm1
                knotw       msk1, msk1
                vmovdqa64   zmm0{k1}{z}, [long8.m1]
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold векторное верхнее умножение с насыщением>
                function    VectorHiMulByte
                movsx       eax,  bRes
                movsx       iVal, bVal
                imul        eax,  iVal
                add         eax,  $7f
                sar         eax,  $07
                cmp         eax,  $7f
                jle         .L.0000
                mov         eax,  $7f
    .L.0000:    ret

                function    VectorHiMulByte2
                movzx       iVal1, word  [val1]
                movzx       iVal2, word  [val2]
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpmovsxbw   xmm0, xmm0
                vpmovsxbw   xmm1, xmm1
                vpmullw     xmm0, xmm0, xmm1
                vpaddw      xmm0, xmm0, [short2.$007f]
                vpsraw      xmm0, xmm0, $07
                vpacksswb   xmm0, xmm0, [zero]
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorHiMulByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpmovsxbw   xmm0, xmm0
                vpmovsxbw   xmm1, xmm1
                vpmullw     xmm0, xmm0, xmm1
                vpaddw      xmm0, xmm0, [short4.$007f]
                vpsraw      xmm0, xmm0, $07
                vpacksswb   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    VectorHiMulByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpmovsxbw   xmm0, xmm0
                vpmovsxbw   xmm1, xmm1
                vpmullw     xmm0, xmm0, xmm1
                vpaddw      xmm0, xmm0, [short8.$007f]
                vpsraw      xmm0, xmm0, $07
                vpacksswb   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    VectorHiMulShort
                movsx       eax,  sRes
                movsx       iVal, sVal
                imul        eax,  iVal
                add         eax,  $7fff
                sar         eax,  $0f
                cmp         eax,  $7fff
                jle         .L.0000
                mov         eax,  $7fff
    .L.0000:    ret

                function    VectorHiMulShort2
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpmovsxwd   xmm0, xmm0
                vpmovsxwd   xmm1, xmm1
                vpmulld     xmm0, xmm0, xmm1
                vpaddd      xmm0, xmm0, [int2.$7fff]
                vpsrad      xmm0, xmm0, $0f
                vpackssdw   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    VectorHiMulShort4
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpmovsxwd   xmm0, xmm0
                vpmovsxwd   xmm1, xmm1
                vpmulld     xmm0, xmm0, xmm1
                vpaddd      xmm0, xmm0, [int4.$7fff]
                vpsrad      xmm0, xmm0, $0f
                vpackssdw   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    VectorHiMulShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpmovsxwd   ymm0, xmm0
                vpmovsxwd   ymm1, xmm1
                vpmulld     ymm0, ymm0, ymm1
                vpaddd      ymm0, ymm0, [int8.$7fff]
                vpsrad      ymm0, ymm0, $0f
                vextracti128 xmm1, ymm0, $01
                vpackssdw   xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold векторное беззнаковое верхнее умножение с насыщением>
                function    VectorHiMuluByte
                movzx       eax,  bRes
                movzx       iVal, bVal
                imul        eax,  iVal
                add         eax,  $ff
                movsx       eax,  ah
                ret

                function    VectorHiMuluByte2
                movzx       iVal1, word  [val1]
                movzx       iVal2, word  [val2]
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpmovzxbw   xmm0, xmm0
                vpmovzxbw   xmm1, xmm1
                vpmullw     xmm0, xmm0, xmm1
                vpaddw      xmm0, xmm0, [short2.$00ff]
                vpsrlw      xmm0, xmm0, $08
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorHiMuluByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpmovzxbw   xmm0, xmm0
                vpmovzxbw   xmm1, xmm1
                vpmullw     xmm0, xmm0, xmm1
                vpaddw      xmm0, xmm0, [short4.$00ff]
                vpsrlw      xmm0, xmm0, $08
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    VectorHiMuluByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpmovzxbw   xmm0, xmm0
                vpmovzxbw   xmm1, xmm1
                vpmullw     xmm0, xmm0, xmm1
                vpaddw      xmm0, xmm0, [short8.$00ff]
                vpsrlw      xmm0, xmm0, $08
                vpackuswb   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    VectorHiMuluShort
                movzx       eax,  sRes
                movzx       iVal, sVal
                imul        eax,  iVal
                add         eax,  $ffff
                sar         eax,  $10
                ret

                function    VectorHiMuluShort2
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpmovzxwd   xmm0, xmm0
                vpmovzxwd   xmm1, xmm1
                vpmulld     xmm0, xmm0, xmm1
                vpaddd      xmm0, xmm0, [int2.$ffff]
                vpsrld      xmm0, xmm0, $10
                vpackusdw   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    VectorHiMuluShort4
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpmovzxwd   xmm0, xmm0
                vpmovzxwd   xmm1, xmm1
                vpmulld     xmm0, xmm0, xmm1
                vpaddd      xmm0, xmm0, [int4.$ffff]
                vpsrld      xmm0, xmm0, $10
                vpackusdw   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    VectorHiMuluShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpmovzxwd   ymm0, xmm0
                vpmovzxwd   ymm1, xmm1
                vpmulld     ymm0, ymm0, ymm1
                vpaddd      ymm0, ymm0, [int8.$ffff]
                vpsrld      ymm0, ymm0, $10
                vextracti128 xmm1, ymm0, $01
                vpackusdw   xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold векторная нижняя распаковка>
                function    VectorLoUnpackByte
                movzx       eax,  bRes
                ret

                function    VectorLoUnpackByte2
                movzx       iVal, word  [val]
                vmovd       xmm0, iVal
                vpmovzxbw   xmm0, xmm0
                vmovd       dword [res], xmm0
                ret

                function    VectorLoUnpackByte4
                vmovd       xmm0, [val]
                vpmovzxbw   xmm0, xmm0
                vmovq       qword [res], xmm0
                ret

                function    VectorLoUnpackByte8
                vmovq       xmm0, [val]
                vpmovzxbw   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    VectorLoUnpackShort
                movzx       eax,  sRes
                ret

                function    VectorLoUnpackShort2
                vmovd       xmm0, [val]
                vpmovzxwd   xmm0, xmm0
                vmovq       qword [res], xmm0
                ret

                function    VectorLoUnpackShort4
                vmovq       xmm0, [val]
                vpmovzxwd   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    VectorLoUnpackShort8
                vmovdqu     xmm0, [val]
                vpmovzxwd   ymm0, xmm0
                vmovdqu     yword [res], ymm0
                ret

                function    VectorLoUnpackInt
                mov         eax,  iRes
                ret

                function    VectorLoUnpackInt2
                vmovq       xmm0, [val]
                vpmovzxdq   xmm0, xmm0
                vmovdqu     xword [res], xmm0
                ret

                function    VectorLoUnpackInt4
                vmovdqu     xmm0, [val]
                vpmovzxdq   ymm0, xmm0
                vmovdqu     yword [res], ymm0
                ret

                function    VectorLoUnpackInt8
                vmovdqu     ymm0, [val]
                vpmovzxdq   zmm0, ymm0
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold векторная верхняя распаковка>
                function    VectorUpUnpackByte
                movzx       eax,  bRes
                shl         eax,  $08
                movsx       eax,  ax
                ret

                function    VectorUpUnpackByte2
                movzx       iVal, word  [val]
                vmovd       xmm0, iVal
                vpmovzxbw   xmm0, xmm0
                vpsllw      xmm0, xmm0, $08
                vmovd       dword [res], xmm0
                ret

                function    VectorUpUnpackByte4
                vmovd       xmm0, [val]
                vpmovzxbw   xmm0, xmm0
                vpsllw      xmm0, xmm0, $08
                vmovq       qword [res], xmm0
                ret

                function    VectorUpUnpackByte8
                vmovq       xmm0, [val]
                vpmovzxbw   xmm0, xmm0
                vpsllw      xmm0, xmm0, $08
                vmovdqu     xword [res], xmm0
                ret

                function    VectorUpUnpackShort
                movzx       eax,  sRes
                shl         eax,  $10
                ret

                function    VectorUpUnpackShort2
                vmovd       xmm0, [val]
                vpmovzxwd   xmm0, xmm0
                vpslld      xmm0, xmm0, $10
                vmovq       qword [res], xmm0
                ret

                function    VectorUpUnpackShort4
                vmovq       xmm0, [val]
                vpmovzxwd   xmm0, xmm0
                vpslld      xmm0, xmm0, $10
                vmovdqu     xword [res], xmm0
                ret

                function    VectorUpUnpackShort8
                vmovdqu     xmm0, [val]
                vpmovzxwd   ymm0, xmm0
                vpslld      ymm0, ymm0, $10
                vmovdqu     yword [res], ymm0
                ret

                function    VectorUpUnpackInt
                mov         eax,  iRes
                shl         rax,  $20
                ret

                function    VectorUpUnpackInt2
                vmovq       xmm0, [val]
                vpmovzxdq   xmm0, xmm0
                vpsllq      xmm0, xmm0, $20
                vmovdqu     xword [res], xmm0
                ret

                function    VectorUpUnpackInt4
                vmovdqu     xmm0, [val]
                vpmovzxdq   ymm0, xmm0
                vpsllq      ymm0, ymm0, $20
                vmovdqu     yword [res], ymm0
                ret

                function    VectorUpUnpackInt8
                vmovdqu     ymm0, [val]
                vpmovzxdq   zmm0, ymm0
                vpsllq      zmm0, zmm0, $20
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold векторное умножение>
                function    VectorMulDouble2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vmulpd      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    VectorMulDouble4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vmulpd      ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    VectorMulDouble8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vmulpd      zmm0, zmm0, zmm1
                vmovdqu64   zword [res], zmm0
                ret

                function    VectorMulFloat2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vmulps      xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorMulFloat4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vmulps      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    VectorMulFloat8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vmulps      ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    VectorMulByte2
                movzx       iVal1, word  [val1]
                movzx       iVal2, word  [val2]
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpmovsxbw   xmm0, xmm0
                vpmovsxbw   xmm1, xmm1
                vpmullw     xmm0, xmm0, xmm1
                vpand       xmm0, xmm0, [short2.$00ff]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorMulByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpmovsxbw   xmm0, xmm0
                vpmovsxbw   xmm1, xmm1
                vpmullw     xmm0, xmm0, xmm1
                vpand       xmm0, xmm0, [short4.$00ff]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    VectorMulByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpmovsxbw   xmm0, xmm0
                vpmovsxbw   xmm1, xmm1
                vpmullw     xmm0, xmm0, xmm1
                vpand       xmm0, xmm0, [short8.$00ff]
                vpackuswb   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    VectorMulShort2
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpmullw     xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorMulShort4
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpmullw     xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorMulShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpmullw     xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    VectorMulInt2
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpmulld     xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorMulInt4
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpmulld     xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    VectorMulInt8
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpmulld     ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    VectorMulLong2
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpmullq     xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    VectorMulLong4
                vmovdqu     ymm0, [val1]
                vmovdqu     ymm1, [val2]
                vpmullq     ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret

                function    VectorMulLong8
                vmovdqu64   zmm0, [val1]
                vmovdqu64   zmm1, [val2]
                vpmullq     zmm0, zmm0, zmm1
                vmovdqu64   zword [res], zmm0
                ret
; </fold>

; <fold векторное отрицание>
                function    VectorNegByte2
                movzx       iVal, word  [val]
                vmovd       xmm0, iVal
                vpxor       xmm1, xmm0, xmm0
                vpsubb      xmm0, xmm1, xmm0
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorNegByte4
                vmovd       xmm0, [val]
                vpxor       xmm1, xmm0, xmm0
                vpsubb      xmm0, xmm1, xmm0
                vmovd       dword [res], xmm0
                ret

                function    VectorNegByte8
                vmovq       xmm0, [val]
                vpxor       xmm1, xmm0, xmm0
                vpsubb      xmm0, xmm1, xmm0
                vmovq       qword [res], xmm0
                ret

                function    VectorNegShort2
                vmovd       xmm0, [val]
                vpxor       xmm1, xmm0, xmm0
                vpsubw      xmm0, xmm1, xmm0
                vmovd       dword [res], xmm0
                ret

                function    VectorNegShort4
                vmovq       xmm0, [val]
                vpxor       xmm1, xmm0, xmm0
                vpsubw      xmm0, xmm1, xmm0
                vmovq       qword [res], xmm0
                ret

                function    VectorNegShort8
                vmovdqu     xmm0, [val]
                vpxor       xmm1, xmm0, xmm0
                vpsubw      xmm0, xmm1, xmm0
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold векторная упаковка>
                function    VectorPackShort
                movsx       eax,  sRes
                sar         eax,  $08
                cmp         eax,  $00
                je          .L.0001
                jg          .L.0000
                mov         eax,  $00000000
                ret
    .L.0000:    mov         eax,  $ffffffff
                ret
    .L.0001:    movsx       eax,  bRes
                ret

                function    VectorPackShort2
                vmovd       xmm0, [val]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorPackShort4
                vmovq       xmm0, [val]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    VectorPackShort8
                vmovdqu     xmm0, [val]
                vpackuswb   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    VectorPackInt
                mov         eax,  iRes
                sar         eax,  $10
                cmp         eax,  $00
                je          .L.0001
                jg          .L.0000
                mov         eax,  $00000000
                ret
    .L.0000:    mov         eax,  $ffffffff
                ret
    .L.0001:    movsx       eax,  sRes
                ret

                function    VectorPackInt2
                vmovq       xmm0, [val]
                vpackusdw   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    VectorPackInt4
                vmovdqu     xmm0, [val]
                vpackusdw   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    VectorPackInt8
                vmovdqu     ymm0, [val]
                vextracti128 xmm1, ymm0, $01
                vpackusdw   xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    VectorPackLong
                mov         rax,  lRes
                sar         rax,  $20
                cmp         eax,  $00
                je          .L.0001
                jg          .L.0000
                mov         eax,  $00000000
                ret
    .L.0000:    mov         eax,  $ffffffff
                ret
    .L.0001:    mov         eax,  iRes
                ret

                function    VectorPackLong2
                vmovdqu     xmm0, [val]
                vpxor       xmm1, xmm0, xmm0
                vpcmpgtq    xmm1, xmm1, xmm0
                vpcmpgtq    xmm2, xmm0, [long8.maskd]
                vpandn      xmm0, xmm1, xmm0
                vpor        xmm0, xmm2, xmm0
                vshufps     xmm0, xmm0, xmm0, $d8
                vmovq       qword [res], xmm0
                ret

                function    VectorPackLong4
                vmovdqu     ymm0, [val]
                vpxor       ymm1, ymm0, ymm0
                vpcmpgtq    ymm1, ymm1, ymm0
                vpcmpgtq    ymm2, ymm0, [long8.maskd]
                vpandn      ymm0, ymm1, ymm0
                vpor        ymm0, ymm2, ymm0
                vshufps     ymm0, ymm0, ymm0, $d8
                vextracti128 xmm1, ymm0, $01
                vpand       xmm0, xmm0, [int8.m1_0]
                vpslldq     xmm1, xmm1, $08
                vpor        xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret

                function    VectorPackLong8
                vmovdqu64   zmm0, [val]
                vpxorq      zmm1, zmm0, zmm0
                vpcmpgtq    msk1, zmm1, zmm0
                vpcmpgtq    msk2, zmm0, [long8.maskd]
                vmovdqa64   zmm2, [long8.m1]
                vmovdqa64   zmm1{k1}{z}, zmm2
                vmovdqa64   zmm2{k2}{z}, zmm2
                vpandnq     zmm0, zmm1, zmm0
                vporq       zmm0, zmm2, zmm0
                vshufps     zmm0, zmm0, zmm0, $d8
                vshufi64x2  zmm0, zmm0, zmm0, $d8
                vextracti64x4 ymm1, zmm0, $01
                vpand       ymm0, ymm0, [int8.m1_0]
                vpslldq     ymm1, ymm1, $08
                vpor        ymm0, ymm0, ymm1
                vmovdqu     yword [res], ymm0
                ret
; </fold>

; <fold векторное сложение с насыщением>
                function    VectorSaturatedAddByte
                movsx       eax,  bRes
                movsx       iVal, bVal
                add         eax,  iVal
                cmp         eax,  -$80
                jge         .L.0000
                mov         eax,  -$80
                ret
    .L.0000:    cmp         eax,  $7f
                jle         .L.0001
                mov         eax,  $7f
    .L.0001:    ret

                function    VectorSaturatedAddByte2
                movzx       iVal1, word  [val1]
                movzx       iVal2, word  [val2]
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpaddsb     xmm0, xmm0, xmm1
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorSaturatedAddByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpaddsb     xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorSaturatedAddByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpaddsb     xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorSaturatedAddShort
                movsx       eax,  sRes
                movsx       iVal, sVal
                add         eax,  iVal
                cmp         eax,  -$8000
                jge         .L.0000
                mov         eax,  -$8000
                ret
    .L.0000:    cmp         eax,  $7fff
                jle         .L.0001
                mov         eax,  $7fff
    .L.0001:    ret

                function    VectorSaturatedAddShort2
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpaddsw     xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorSaturatedAddShort4
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpaddsw     xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorSaturatedAddShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpaddsw     xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold векторное беззнаковое сложение с насыщением>
                function    VectorSaturatedAdduByte
                movzx       eax,  bRes
                movzx       iVal, bVal
                add         eax,  iVal
                cmp         eax,  $ff
                jbe         .L.0000
                mov         eax,  $ff
    .L.0000:    movsx       eax,  al
                ret

                function    VectorSaturatedAdduByte2
                movzx       iVal1, word  [val1]
                movzx       iVal2, word  [val2]
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpaddusb    xmm0, xmm0, xmm1
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorSaturatedAdduByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpaddusb    xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorSaturatedAdduByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpaddusb    xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorSaturatedAdduShort
                movzx       eax,  sRes
                movzx       iVal, sVal
                add         eax,  iVal
                cmp         eax,  $ffff
                jbe         .L.0000
                mov         eax,  $ffff
    .L.0000:    movsx       eax,  ax
                ret

                function    VectorSaturatedAdduShort2
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpaddusw    xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorSaturatedAdduShort4
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpaddusw    xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorSaturatedAdduShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpaddusw    xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold векторное вычитание с насыщением>
                function    VectorSaturatedSubByte
                movsx       eax,  bRes
                movsx       iVal, bVal
                sub         eax,  iVal
                cmp         eax,  -$80
                jge         .L.0000
                mov         eax,  -$80
                ret
    .L.0000:    cmp         eax,  $7f
                jle         .L.0001
                mov         eax,  $7f
    .L.0001:    ret

                function    VectorSaturatedSubByte2
                movzx       iVal1, word  [val1]
                movzx       iVal2, word  [val2]
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpsubsb     xmm0, xmm0, xmm1
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorSaturatedSubByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpsubsb     xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorSaturatedSubByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpsubsb     xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorSaturatedSubShort
                movsx       eax,  sRes
                movsx       iVal, sVal
                sub         eax,  iVal
                cmp         eax,  -$8000
                jge         .L.0000
                mov         eax,  -$8000
                ret
    .L.0000:    cmp         eax,  $7fff
                jle         .L.0001
                mov         eax,  $7fff
    .L.0001:    ret

                function    VectorSaturatedSubShort2
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpsubsw     xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorSaturatedSubShort4
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpsubsw     xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorSaturatedSubShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpsubsw     xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold векторное беззнаковое вычитание с насыщением>
                function    VectorSaturatedSubuByte
                movzx       eax,  bRes
                movzx       iVal, bVal
                sub         eax,  iVal
                cmp         eax,  $ff
                jbe         .L.0000
                mov         eax,  $00
    .L.0000:    movsx       eax,  al
                ret

                function    VectorSaturatedSubuByte2
                movzx       iVal1, word  [val1]
                movzx       iVal2, word  [val2]
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpsubusb    xmm0, xmm0, xmm1
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorSaturatedSubuByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpsubusb    xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorSaturatedSubuByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpsubusb    xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorSaturatedSubuShort
                movzx       eax,  sRes
                movzx       iVal, sVal
                sub         eax,  iVal
                cmp         eax,  $ffff
                jbe         .L.0000
                mov         eax,  $0000
    .L.0000:    movsx       eax,  ax
                ret

                function    VectorSaturatedSubuShort2
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpsubusw    xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorSaturatedSubuShort4
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpsubusw    xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorSaturatedSubuShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpsubusw    xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold векторный сдвиг влево>
                function    VectorShlByte2
                movzx       iVal1, word  [val1]
                and         iVal2, $1f
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpmovsxbd   xmm0, xmm0
                vpslld      xmm0, xmm0, xmm1
                vpand       xmm0, xmm0, [int8.maskb]
                vpackusdw   xmm0, xmm0, [zero]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorShlByte4
                and         iVal2, $1f
                vmovd       xmm0, [val1]
                vmovd       xmm1, iVal2
                vpmovsxbd   xmm0, xmm0
                vpslld      xmm0, xmm0, xmm1
                vpand       xmm0, xmm0, [int8.maskb]
                vpackusdw   xmm0, xmm0, [zero]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    VectorShlByte8
                and         iVal2, $1f
                vmovq       xmm0, [val1]
                vmovd       xmm1, iVal2
                vpmovsxbd   ymm0, xmm0
                vpslld      ymm0, ymm0, xmm1
                vpand       ymm0, ymm0, [int8.maskb]
                vextracti128 xmm1, ymm0, $01
                vpackusdw   xmm0, xmm0, xmm1
                vpackuswb   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    VectorShlShort2
                and         iVal2, $1f
                vmovd       xmm0, [val1]
                vmovd       xmm1, iVal2
                vpmovsxwd   xmm0, xmm0
                vpslld      xmm0, xmm0, xmm1
                vpand       xmm0, xmm0, [int8.maskw]
                vpackusdw   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    VectorShlShort4
                and         iVal2, $1f
                vmovq       xmm0, [val1]
                vmovd       xmm1, iVal2
                vpmovsxwd   xmm0, xmm0
                vpslld      xmm0, xmm0, xmm1
                vpand       xmm0, xmm0, [int8.maskw]
                vpackusdw   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    VectorShlShort8
                and         iVal2, $1f
                vmovdqu     xmm0, [val1]
                vmovd       xmm1, iVal2
                vpmovsxwd   ymm0, xmm0
                vpslld      ymm0, ymm0, xmm1
                vpand       ymm0, ymm0, [int8.maskw]
                vextracti128 xmm1, ymm0, $01
                vpackusdw   xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold векторный сдвиг вправо>
                function    VectorShrByte2
                movzx       iVal1, word  [val1]
                and         iVal2, $1f
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpmovsxbw   xmm0, xmm0
                vpsraw      xmm0, xmm0, xmm1
                vpand       xmm0, xmm0, [short2.$00ff]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorShrByte4
                and         iVal2, $1f
                vmovd       xmm0, [val1]
                vmovd       xmm1, iVal2
                vpmovsxbw   xmm0, xmm0
                vpsraw      xmm0, xmm0, xmm1
                vpand       xmm0, xmm0, [short4.$00ff]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    VectorShrByte8
                and         iVal2, $1f
                vmovq       xmm0, [val1]
                vmovd       xmm1, iVal2
                vpmovsxbw   xmm0, xmm0
                vpsraw      xmm0, xmm0, xmm1
                vpand       xmm0, xmm0, [short8.$00ff]
                vpackuswb   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    VectorShrShort2
                and         iVal2, $1f
                vmovd       xmm0, [val1]
                vmovd       xmm1, iVal2
                vpsraw      xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorShrShort4
                and         iVal2, $1f
                vmovq       xmm0, [val1]
                vmovd       xmm1, iVal2
                vpsraw      xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorShrShort8
                and         iVal2, $1f
                vmovdqu     xmm0, [val1]
                vmovd       xmm1, iVal2
                vpsraw      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold векторный беззнаковый сдвиг вправо>
                function    VectorShruByte2
                movzx       iVal1, word  [val1]
                and         iVal2, $1f
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpmovsxbd   xmm0, xmm0
                vpsrld      xmm0, xmm0, xmm1
                vpand       xmm0, xmm0, [int8.maskb]
                vpackusdw   xmm0, xmm0, [zero]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorShruByte4
                and         iVal2, $1f
                vmovd       xmm0, [val1]
                vmovd       xmm1, iVal2
                vpmovsxbd   xmm0, xmm0
                vpsrld      xmm0, xmm0, xmm1
                vpand       xmm0, xmm0, [int8.maskb]
                vpackusdw   xmm0, xmm0, [zero]
                vpackuswb   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    VectorShruByte8
                and         iVal2, $1f
                vmovq       xmm0, [val1]
                vmovd       xmm1, iVal2
                vpmovsxbd   ymm0, xmm0
                vpsrld      ymm0, ymm0, xmm1
                vpand       ymm0, ymm0, [int8.maskb]
                vextracti128 xmm1, ymm0, $01
                vpackusdw   xmm0, xmm0, xmm1
                vpackuswb   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    VectorShruShort2
                and         iVal2, $1f
                vmovd       xmm0, [val1]
                vmovd       xmm1, iVal2
                vpmovsxwd   xmm0, xmm0
                vpsrld      xmm0, xmm0, xmm1
                vpand       xmm0, xmm0, [int8.maskw]
                vpackusdw   xmm0, xmm0, [zero]
                vmovd       dword [res], xmm0
                ret

                function    VectorShruShort4
                and         iVal2, $1f
                vmovq       xmm0, [val1]
                vmovd       xmm1, iVal2
                vpmovsxwd   xmm0, xmm0
                vpsrld      xmm0, xmm0, xmm1
                vpand       xmm0, xmm0, [int8.maskw]
                vpackusdw   xmm0, xmm0, [zero]
                vmovq       qword [res], xmm0
                ret

                function    VectorShruShort8
                and         iVal2, $1f
                vmovdqu     xmm0, [val1]
                vmovd       xmm1, iVal2
                vpmovsxwd   ymm0, xmm0
                vpsrld      ymm0, ymm0, xmm1
                vpand       ymm0, ymm0, [int8.maskw]
                vextracti128 xmm1, ymm0, $01
                vpackusdw   xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret
; </fold>

; <fold векторное вычитание>
                function    VectorSubByte2
                movzx       iVal1, word  [val1]
                movzx       iVal2, word  [val2]
                vmovd       xmm0, iVal1
                vmovd       xmm1, iVal2
                vpsubb      xmm0, xmm0, xmm1
                vmovd       eax,  xmm0
                mov         word  [res], ax
                ret

                function    VectorSubByte4
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpsubb      xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorSubByte8
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpsubb      xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorSubShort2
                vmovd       xmm0, [val1]
                vmovd       xmm1, [val2]
                vpsubw      xmm0, xmm0, xmm1
                vmovd       dword [res], xmm0
                ret

                function    VectorSubShort4
                vmovq       xmm0, [val1]
                vmovq       xmm1, [val2]
                vpsubw      xmm0, xmm0, xmm1
                vmovq       qword [res], xmm0
                ret

                function    VectorSubShort8
                vmovdqu     xmm0, [val1]
                vmovdqu     xmm1, [val2]
                vpsubw      xmm0, xmm0, xmm1
                vmovdqu     xword [res], xmm0
                ret
; </fold>