ru.malik.elaborarer.avt.operation.asm

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

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

                format  pe64 gui dll at $00007ff000000000
                entry   DllEntryPoint

                include "win64a.inc"
                include "verinfex.inc"

                r0  equ rax
                r1  equ rcx
                r2  equ rdx
                r0d equ eax
                r1d equ ecx
                r2d equ edx
                r0w equ ax
                r1w equ cx
                r2w equ dx
                r0b equ al
                r1b equ cl
                r2b equ dl

section ".text" code readable executable

    AVT_BOOLEAN = 21
    AVT_REAL    = 23
    AVT_BYTE    = 24
    AVT_BYTE2   = 25
    AVT_BYTE4   = 26
    AVT_BYTE8   = 27
    AVT_SHORT   = 28
    AVT_SHORT2  = 29
    AVT_SHORT4  = 30
    AVT_SHORT8  = 31
    AVT_INT     = 32
    AVT_INT2    = 33
    AVT_INT4    = 34
    AVT_INT8    = 35
    AVT_LONG    = 36
    AVT_LONG2   = 37
    AVT_LONG4   = 38
    AVT_LONG8   = 39
    AVT_FLOAT   = 40
    AVT_FLOAT2  = 41
    AVT_FLOAT4  = 42
    AVT_FLOAT8  = 43
    AVT_DOUBLE  = 44
    AVT_DOUBLE2 = 45
    AVT_DOUBLE4 = 46
    AVT_DOUBLE8 = 47

    AVTConstant.asPrimitiveValueOffset = $40

    proc DllEntryPoint hinstDLL, fdwReason, lpvReserved
                mov     r0d, $01
                ret
    endp

                align   $08
    proc setPrimitiveAddress
                mov     [setPrimitive], r1
                ret
    endp

    ; =========================================================================================== ;
    ;   BYTE                                                                                      ;
    ; =========================================================================================== ;

                align   $08
    proc byteScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                neg     r0d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                imul    r0d, r10d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                mov     r11, r2
                cdq
                idiv    r10d
                mov     r2, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalDivu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                mov     r11, r2
                xor     r2d, r2d
                div     r10d
                mov     r2, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalRem ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                mov     r11, r2
                cdq
                idiv    r10d
                mov     r0d, r2d
                mov     r2, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalRemu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                mov     r11, r2
                xor     r2d, r2d
                div     r10d
                mov     r0d, r2d
                mov     r2, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                add     r0d, r10d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                sub     r0d, r10d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sar     r0d, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sal     r0d, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                shr     r0d, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setg    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setge   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setl    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setle   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteBitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                not     r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteBitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                and     r0b, r10b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteBitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                or      r0b, r10b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteBitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                xor     r0b, r10b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectUnpckl ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectUnpcku ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                shl     r0w, $08
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                neg     r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                imul    r10b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                add     r0b, r10b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                sub     r0b, r10b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sar     r0b, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sal     r0b, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                shr     r0b, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0b, r10b
                setng   r0b
                dec     r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0b, r10b
                setnge  r0b
                dec     r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0b, r10b
                setnl   r0b
                dec     r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0b, r10b
                setnle  r0b
                dec     r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0b, r10b
                setne   r0b
                dec     r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0b, r10b
                sete    r0b
                dec     r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectMuls ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpmovsxbw xmm0, xmm0
                vpmovsxbw xmm1, xmm1
                vpmullw xmm0, xmm0, xmm1
                vpaddw  xmm0, xmm0, [short8_02]
                vpsraw  xmm0, xmm0, $07
                vpacksswb xmm0, xmm0, xmm0
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectAdds ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpaddsb xmm0, xmm0, xmm1
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectSubs ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpsubsb xmm0, xmm0, xmm1
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectMulu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; vpmovsxbw xmm0, xmm0
                ; vpmovsxbw xmm1, xmm1
                vpmullw xmm0, xmm0, xmm1
                vpaddw  xmm0, xmm0, [short8_01]
                vpsrlw  xmm0, xmm0, $08
                ; vpackuswb xmm0, xmm0, xmm0
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectAddu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpaddusb xmm0, xmm0, xmm1
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byteVectSubu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, byte[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpsubusb xmm0, xmm0, xmm1
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   BYTE2                                                                                     ;
    ; =========================================================================================== ;

                align   $08
    proc byte2ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vpmovsxbd xmm0, xmm0
                ; выполнение операции ;
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vpmovsxbd xmm0, xmm0
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubd  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpmovsxbd xmm0, xmm0
                vpmovsxbd xmm1, xmm1
                ; выполнение операции ;
                vshufps xmm2, xmm1, xmm1, $e4
                vshufps xmm3, xmm2, xmm2, $e1
                vpmulld xmm2, xmm2, [int2_c0]
                vpmulld xmm1, xmm0, xmm3
                vpmulld xmm0, xmm0, xmm2
                vphaddd xmm0, xmm0, xmm1
                vshufps xmm0, xmm0, xmm0, $d8
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpmovsxbd xmm0, xmm0
                vpmovsxbd xmm1, xmm1
                ; выполнение операции ;
                vpaddd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpmovsxbd xmm0, xmm0
                vpmovsxbd xmm1, xmm1
                ; выполнение операции ;
                vpsubd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2ScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpmovsxbd xmm0, xmm0
                ; выполнение операции ;
                vpsrad  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2ScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpmovsxbd xmm0, xmm0
                ; выполнение операции ;
                vpslld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2ScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpmovsxbd xmm0, xmm0
                ; выполнение операции ;
                vpsrld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpmovsxbd xmm0, xmm0
                vpmovsxbd xmm1, xmm1
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                vmovmskps r0d, xmm0
                and     r0d, $03
                cmp     r0d, $03
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpmovsxbd xmm0, xmm0
                vpmovsxbd xmm1, xmm1
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                vmovmskps r0d, xmm0
                and     r0d, $03
                cmp     r0d, $03
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2BitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                ; выполнение операции ;
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2BitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpand   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2BitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpor    xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2BitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpxor   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectUnpckl ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpunpcklbw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectUnpcku ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpunpcklbw xmm0, xmm1, xmm0
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                ; выполнение операции ;
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubb  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpmovzxbw xmm0, xmm0
                vpmovzxbw xmm1, xmm1
                vpmullw xmm0, xmm0, xmm1
                vpand   xmm0, xmm0, [short8_01]
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpaddb  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsubb  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpmovsxbw xmm0, xmm0
                vpsraw  xmm0, xmm0, xmm1
                vpacksswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpmovsxbw xmm0, xmm0
                vpsllw  xmm0, xmm0, xmm1
                vpand   xmm0, xmm0, [short8_01]
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpmovzxbw xmm0, xmm0
                vpsrlw  xmm0, xmm0, xmm1
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpcmpgtb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpcmpgtb xmm0, xmm1, xmm0
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpcmpgtb xmm0, xmm1, xmm0
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpcmpgtb xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpcmpeqb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpcmpeqb xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectMuls ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpmovsxbw xmm0, xmm0
                vpmovsxbw xmm1, xmm1
                vpmullw xmm0, xmm0, xmm1
                vpaddw  xmm0, xmm0, [short8_02]
                vpsraw  xmm0, xmm0, $07
                vpacksswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectAdds ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpaddsb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectSubs ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsubsb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectMulu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpmovzxbw xmm0, xmm0
                vpmovzxbw xmm1, xmm1
                vpmullw xmm0, xmm0, xmm1
                vpaddw  xmm0, xmm0, [short8_01]
                vpsrlw  xmm0, xmm0, $08
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectAddu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpaddusb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte2VectSubu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsubusb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   BYTE4                                                                                     ;
    ; =========================================================================================== ;

                align   $08
    proc byte4ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vpmovsxbd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vpmovsxbd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubd  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$40]
                vpmovsxbd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxbd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$20], xmm6
                vmovdqu [rsp+$30], xmm7
                vshufps xmm4, xmm1, xmm1, $e4
                vshufps xmm5, xmm4, xmm4, $b1
                vshufps xmm6, xmm4, xmm4, $4e
                vshufps xmm7, xmm4, xmm4, $1b
                vpmulld xmm4, xmm4, [int4_q0]
                vpmulld xmm5, xmm5, [int4_q1]
                vpmulld xmm6, xmm6, [int4_q2]
                vpmulld xmm7, xmm7, [int4_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 xmm6, [rsp+$20]
                vmovdqu xmm7, [rsp+$30]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxbd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxbd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxbd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxbd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4ScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vpmovsxbd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrad  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4ScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vpmovsxbd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpslld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4ScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vpmovsxbd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxbd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxbd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                vmovmskps r0d, xmm0
                cmp     r0d, $0f
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxbd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxbd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                vmovmskps r0d, xmm0
                cmp     r0d, $0f
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4BitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4BitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpand   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4BitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpor    xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4BitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectUnpckl ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpunpcklbw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectUnpcku ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpunpcklbw xmm0, xmm1, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubb  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovzxbw xmm0, xmm0
                vpmovzxbw xmm1, xmm1
                vpmullw xmm0, xmm0, xmm1
                vpand   xmm0, xmm0, [short8_01]
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddb  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubb  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpmovsxbw xmm0, xmm0
                vpsraw  xmm0, xmm0, xmm1
                vpacksswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpmovsxbw xmm0, xmm0
                vpsllw  xmm0, xmm0, xmm1
                vpand   xmm0, xmm0, [short8_01]
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpmovzxbw xmm0, xmm0
                vpsrlw  xmm0, xmm0, xmm1
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtb xmm0, xmm1, xmm0
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtb xmm0, xmm1, xmm0
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtb xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqb xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectMuls ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovsxbw xmm0, xmm0
                vpmovsxbw xmm1, xmm1
                vpmullw xmm0, xmm0, xmm1
                vpaddw  xmm0, xmm0, [short8_02]
                vpsraw  xmm0, xmm0, $07
                vpacksswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectAdds ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddsb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectSubs ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubsb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectMulu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovzxbw xmm0, xmm0
                vpmovzxbw xmm1, xmm1
                vpmullw xmm0, xmm0, xmm1
                vpaddw  xmm0, xmm0, [short8_01]
                vpsrlw  xmm0, xmm0, $08
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectAddu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddusb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte4VectSubu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubusb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   BYTE8                                                                                     ;
    ; =========================================================================================== ;

                align   $08
    proc byte8ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vpmovsxbd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vpmovsxbd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   ymm1, ymm0, ymm0
                vpsubd  ymm0, ymm1, ymm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$0160]
                vpmovsxbd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxbd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$0020], ymm6
                vmovdqu [rsp+$0040], ymm7
                vmovdqu [rsp+$0060], ymm8
                vmovdqu [rsp+$0080], ymm9
                vmovdqu [rsp+$00a0], ymm10
                vmovdqu [rsp+$00c0], ymm11
                vmovdqu [rsp+$00e0], ymm12
                vmovdqu [rsp+$0100], ymm13
                vmovdqu [rsp+$0120], ymm14
                vmovdqu [rsp+$0140], ymm15
                vmovdqa ymm8, ymm1
                vextracti128 xmm12, ymm8, $01
                vinserti128 ymm12, ymm12, xmm8, $01
                vshufps ymm9, ymm8, ymm8, $b1
                vshufps ymm10, ymm8, ymm8, $4e
                vshufps ymm11, ymm8, ymm8, $1b
                vshufps ymm13, ymm12, ymm12, $b1
                vshufps ymm14, ymm12, ymm12, $4e
                vshufps ymm15, ymm12, ymm12, $1b
                vpmulld ymm8, ymm8, [int8_o0]
                vpmulld ymm9, ymm9, [int8_o1]
                vpmulld ymm10, ymm10, [int8_o2]
                vpmulld ymm11, ymm11, [int8_o3]
                vpmulld ymm12, ymm12, [int8_o4]
                vpmulld ymm13, ymm13, [int8_o5]
                vpmulld ymm14, ymm14, [int8_o6]
                vpmulld ymm15, ymm15, [int8_o7]
                vpmulld ymm7, ymm0, ymm15
                vpmulld ymm6, ymm0, ymm14
                vpmulld ymm5, ymm0, ymm13
                vpmulld ymm4, ymm0, ymm12
                vpmulld ymm3, ymm0, ymm11
                vpmulld ymm2, ymm0, ymm10
                vpmulld ymm1, ymm0, ymm9
                vpmulld ymm0, ymm0, ymm8
                vphaddd ymm0, ymm0, ymm1
                vphaddd ymm1, ymm2, ymm3
                vphaddd ymm2, ymm4, ymm5
                vphaddd ymm3, ymm6, ymm7
                vphaddd ymm0, ymm0, ymm1
                vphaddd ymm1, ymm2, ymm3
                vextracti128 xmm2, ymm0, $01
                vextracti128 xmm3, ymm1, $01
                vpaddd  xmm0, xmm0, xmm2
                vpaddd  xmm1, xmm1, xmm3
                vinserti128 ymm0, ymm0, xmm1, $01
                vmovdqu ymm6, [rsp+$0020]
                vmovdqu ymm7, [rsp+$0040]
                vmovdqu ymm8, [rsp+$0060]
                vmovdqu ymm9, [rsp+$0080]
                vmovdqu ymm10, [rsp+$00a0]
                vmovdqu ymm11, [rsp+$00c0]
                vmovdqu ymm12, [rsp+$00e0]
                vmovdqu ymm13, [rsp+$0100]
                vmovdqu ymm14, [rsp+$0120]
                vmovdqu ymm15, [rsp+$0140]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxbd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxbd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddd  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxbd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxbd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubd  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8ScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vpmovsxbd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrad  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8ScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vpmovsxbd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpslld  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8ScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vpmovsxbd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrld  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxbd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxbd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd ymm0, ymm0, ymm1
                vmovmskps r0d, ymm0
                cmp     r0d, $ff
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxbd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxbd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd ymm0, ymm0, ymm1
                vmovmskps r0d, ymm0
                cmp     r0d, $ff
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8BitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8BitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpand   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8BitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpor    xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8BitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectUnpckl ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpunpcklbw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectUnpcku ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpunpcklbw xmm0, xmm1, xmm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubb  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovzxbw xmm0, xmm0
                vpmovzxbw xmm1, xmm1
                vpmullw xmm0, xmm0, xmm1
                vpand   xmm0, xmm0, [short8_01]
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddb  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubb  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpmovsxbw xmm0, xmm0
                vpsraw  xmm0, xmm0, xmm1
                vpacksswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpmovsxbw xmm0, xmm0
                vpsllw  xmm0, xmm0, xmm1
                vpand   xmm0, xmm0, [short8_01]
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpmovzxbw xmm0, xmm0
                vpsrlw  xmm0, xmm0, xmm1
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtb xmm0, xmm1, xmm0
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtb xmm0, xmm1, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtb xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqb xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectMuls ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovsxbw xmm0, xmm0
                vpmovsxbw xmm1, xmm1
                vpmullw xmm0, xmm0, xmm1
                vpaddw  xmm0, xmm0, [short8_02]
                vpsraw  xmm0, xmm0, $07
                vpacksswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectAdds ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddsb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectSubs ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubsb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectMulu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovzxbw xmm0, xmm0
                vpmovzxbw xmm1, xmm1
                vpmullw xmm0, xmm0, xmm1
                vpaddw  xmm0, xmm0, [short8_01]
                vpsrlw  xmm0, xmm0, $08
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectAddu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddusb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc byte8VectSubu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubusb xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   SHORT                                                                                     ;
    ; =========================================================================================== ;

                align   $08
    proc shortScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                neg     r0d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                imul    r0d, r10d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                mov     r11, r2
                cdq
                idiv    r10d
                mov     r2, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalDivu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                mov     r11, r2
                xor     r2d, r2d
                div     r10d
                mov     r2, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalRem ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                mov     r11, r2
                cdq
                idiv    r10d
                mov     r0d, r2d
                mov     r2, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalRemu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                mov     r11, r2
                xor     r2d, r2d
                div     r10d
                mov     r0d, r2d
                mov     r2, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                add     r0d, r10d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                sub     r0d, r10d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sar     r0d, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sal     r0d, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                shr     r0d, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setg    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setge   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setl    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setle   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movsx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movsx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortBitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                not     r0w
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortBitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                and     r0w, r10w
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortBitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                or      r0w, r10w
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortBitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                xor     r0w, r10w
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectUnpckl ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectUnpcku ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                shl     r0d, $10
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectPack ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   xmm0, r0d
                vpackuswb xmm0, xmm0, xmm0
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BYTE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                neg     r0w
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                imul    r0w, r10w
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                add     r0w, r10w
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                sub     r0w, r10w
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sar     r0w, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sal     r0w, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                shr     r0w, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0w, r10w
                setng   r0b
                dec     r0b
                movsx   r0w, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0w, r10w
                setnge  r0b
                dec     r0b
                movsx   r0w, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0w, r10w
                setnl   r0b
                dec     r0b
                movsx   r0w, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0w, r10w
                setnle  r0b
                dec     r0b
                movsx   r0w, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0w, r10w
                setne   r0b
                dec     r0b
                movsx   r0w, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0w, r10w
                sete    r0b
                dec     r0b
                movsx   r0w, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectMuls ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpmovsxwd xmm0, xmm0
                vpmovsxwd xmm1, xmm1
                vpmulld xmm0, xmm0, xmm1
                vpaddd  xmm0, xmm0, [int4_02]
                vpsrad  xmm0, xmm0, $0f
                vpackssdw xmm0, xmm0, xmm0
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectAdds ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpaddsw xmm0, xmm0, xmm1
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectSubs ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpsubsw xmm0, xmm0, xmm1
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectMulu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                ; vpmovzxwd xmm0, xmm0
                ; vpmovzxwd xmm1, xmm1
                vpmulld xmm0, xmm0, xmm1
                vpaddd  xmm0, xmm0, [int4_01]
                vpsrld  xmm0, xmm0, $10
                ; vpackusdw xmm0, xmm0, xmm0
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectAddu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpaddusw xmm0, xmm0, xmm1
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc shortVectSubu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r0d, word[r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, word[r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   xmm0, r0d
                vmovd   xmm1, r10d
                vpsubusw xmm0, xmm0, xmm1
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   SHORT2                                                                                    ;
    ; =========================================================================================== ;

                align   $08
    proc short2ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd xmm0, xmm0
                ; выполнение операции ;
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd xmm0, xmm0
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubd  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd xmm0, xmm0
                vpmovsxwd xmm1, xmm1
                ; выполнение операции ;
                vshufps xmm2, xmm1, xmm1, $e4
                vshufps xmm3, xmm2, xmm2, $e1
                vpmulld xmm2, xmm2, [int2_c0]
                vpmulld xmm1, xmm0, xmm3
                vpmulld xmm0, xmm0, xmm2
                vphaddd xmm0, xmm0, xmm1
                vshufps xmm0, xmm0, xmm0, $d8
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd xmm0, xmm0
                vpmovsxwd xmm1, xmm1
                ; выполнение операции ;
                vpaddd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd xmm0, xmm0
                vpmovsxwd xmm1, xmm1
                ; выполнение операции ;
                vpsubd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2ScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                vpmovsxwd xmm0, xmm0
                ; выполнение операции ;
                vpsrad  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2ScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                vpmovsxwd xmm0, xmm0
                ; выполнение операции ;
                vpslld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2ScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                vpmovsxwd xmm0, xmm0
                ; выполнение операции ;
                vpsrld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd xmm0, xmm0
                vpmovsxwd xmm1, xmm1
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                vmovmskps r0d, xmm0
                and     r0d, $03
                cmp     r0d, $03
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd xmm0, xmm0
                vpmovsxwd xmm1, xmm1
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                vmovmskps r0d, xmm0
                and     r0d, $03
                cmp     r0d, $03
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2BitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2BitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpand   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2BitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpor    xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2BitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectUnpckl ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpunpcklwd xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectUnpcku ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpunpcklwd xmm0, xmm1, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectPack ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   r0d, xmm0
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_BYTE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubw  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmullw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddw  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubw  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsraw  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsllw  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrlw  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtw xmm0, xmm1, xmm0
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtw xmm0, xmm1, xmm0
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtw xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqw xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectMuls ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovsxwd xmm0, xmm0
                vpmovsxwd xmm1, xmm1
                vpmulld xmm0, xmm0, xmm1
                vpaddd  xmm0, xmm0, [int4_02]
                vpsrad  xmm0, xmm0, $0f
                vpackssdw xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectAdds ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddsw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectSubs ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubsw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectMulu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovzxwd xmm0, xmm0
                vpmovzxwd xmm1, xmm1
                vpmulld xmm0, xmm0, xmm1
                vpaddd  xmm0, xmm0, [int4_01]
                vpsrld  xmm0, xmm0, $10
                vpackusdw xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectAddu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddusw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short2VectSubu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovd   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubusw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   SHORT4                                                                                    ;
    ; =========================================================================================== ;

                align   $08
    proc short4ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vpmovsxwd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vpmovsxwd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubd  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$40]
                vpmovsxwd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$20], xmm6
                vmovdqu [rsp+$30], xmm7
                vshufps xmm4, xmm1, xmm1, $e4
                vshufps xmm5, xmm4, xmm4, $b1
                vshufps xmm6, xmm4, xmm4, $4e
                vshufps xmm7, xmm4, xmm4, $1b
                vpmulld xmm4, xmm4, [int4_q0]
                vpmulld xmm5, xmm5, [int4_q1]
                vpmulld xmm6, xmm6, [int4_q2]
                vpmulld xmm7, xmm7, [int4_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 xmm6, [rsp+$20]
                vmovdqu xmm7, [rsp+$30]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxwd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxwd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4ScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vpmovsxwd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrad  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4ScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vpmovsxwd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpslld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4ScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vpmovsxwd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxwd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                vmovmskps r0d, xmm0
                cmp     r0d, $0f
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxwd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                vmovmskps r0d, xmm0
                cmp     r0d, $0f
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4BitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4BitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpand   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4BitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpor    xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4BitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectUnpckl ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpunpcklwd xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectUnpcku ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpunpcklwd xmm0, xmm1, xmm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectPack ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubw  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmullw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddw  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubw  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsraw  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsllw  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrlw  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtw xmm0, xmm1, xmm0
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtw xmm0, xmm1, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtw xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqw xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectMuls ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovsxwd xmm0, xmm0
                vpmovsxwd xmm1, xmm1
                vpmulld xmm0, xmm0, xmm1
                vpaddd  xmm0, xmm0, [int4_02]
                vpsrad  xmm0, xmm0, $0f
                vpackssdw xmm0, xmm0, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectAdds ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddsw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectSubs ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubsw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectMulu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovzxwd xmm0, xmm0
                vpmovzxwd xmm1, xmm1
                vpmulld xmm0, xmm0, xmm1
                vpaddd  xmm0, xmm0, [int4_01]
                vpsrld  xmm0, xmm0, $10
                vpackusdw xmm0, xmm0, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectAddu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddusw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short4VectSubu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubusw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   SHORT8                                                                                    ;
    ; =========================================================================================== ;

                align   $08
    proc short8ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vpmovsxwd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vpmovsxwd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   ymm1, ymm0, ymm0
                vpsubd  ymm0, ymm1, ymm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$0160]
                vpmovsxwd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$0020], ymm6
                vmovdqu [rsp+$0040], ymm7
                vmovdqu [rsp+$0060], ymm8
                vmovdqu [rsp+$0080], ymm9
                vmovdqu [rsp+$00a0], ymm10
                vmovdqu [rsp+$00c0], ymm11
                vmovdqu [rsp+$00e0], ymm12
                vmovdqu [rsp+$0100], ymm13
                vmovdqu [rsp+$0120], ymm14
                vmovdqu [rsp+$0140], ymm15
                vmovdqa ymm8, ymm1
                vextracti128 xmm12, ymm8, $01
                vinserti128 ymm12, ymm12, xmm8, $01
                vshufps ymm9, ymm8, ymm8, $b1
                vshufps ymm10, ymm8, ymm8, $4e
                vshufps ymm11, ymm8, ymm8, $1b
                vshufps ymm13, ymm12, ymm12, $b1
                vshufps ymm14, ymm12, ymm12, $4e
                vshufps ymm15, ymm12, ymm12, $1b
                vpmulld ymm8, ymm8, [int8_o0]
                vpmulld ymm9, ymm9, [int8_o1]
                vpmulld ymm10, ymm10, [int8_o2]
                vpmulld ymm11, ymm11, [int8_o3]
                vpmulld ymm12, ymm12, [int8_o4]
                vpmulld ymm13, ymm13, [int8_o5]
                vpmulld ymm14, ymm14, [int8_o6]
                vpmulld ymm15, ymm15, [int8_o7]
                vpmulld ymm7, ymm0, ymm15
                vpmulld ymm6, ymm0, ymm14
                vpmulld ymm5, ymm0, ymm13
                vpmulld ymm4, ymm0, ymm12
                vpmulld ymm3, ymm0, ymm11
                vpmulld ymm2, ymm0, ymm10
                vpmulld ymm1, ymm0, ymm9
                vpmulld ymm0, ymm0, ymm8
                vphaddd ymm0, ymm0, ymm1
                vphaddd ymm1, ymm2, ymm3
                vphaddd ymm2, ymm4, ymm5
                vphaddd ymm3, ymm6, ymm7
                vphaddd ymm0, ymm0, ymm1
                vphaddd ymm1, ymm2, ymm3
                vextracti128 xmm2, ymm0, $01
                vextracti128 xmm3, ymm1, $01
                vpaddd  xmm0, xmm0, xmm2
                vpaddd  xmm1, xmm1, xmm3
                vinserti128 ymm0, ymm0, xmm1, $01
                vmovdqu ymm6, [rsp+$0020]
                vmovdqu ymm7, [rsp+$0040]
                vmovdqu ymm8, [rsp+$0060]
                vmovdqu ymm9, [rsp+$0080]
                vmovdqu ymm10, [rsp+$00a0]
                vmovdqu ymm11, [rsp+$00c0]
                vmovdqu ymm12, [rsp+$00e0]
                vmovdqu ymm13, [rsp+$0100]
                vmovdqu ymm14, [rsp+$0120]
                vmovdqu ymm15, [rsp+$0140]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxwd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddd  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxwd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubd  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8ScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vpmovsxwd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrad  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8ScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vpmovsxwd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpslld  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8ScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vpmovsxwd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrld  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxwd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd ymm0, ymm0, ymm1
                vmovmskps r0d, ymm0
                cmp     r0d, $ff
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vpmovsxwd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vpmovsxwd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd ymm0, ymm0, ymm1
                vmovmskps r0d, ymm0
                cmp     r0d, $ff
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8BitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8BitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpand   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8BitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpor    xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8BitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectUnpckl ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsrldq xmm1, xmm0, $08
                vpxor   xmm2, xmm0, xmm0
                vpunpcklwd xmm0, xmm0, xmm2
                vpunpcklwd xmm1, xmm1, xmm2
                vinserti128 ymm0, ymm0, xmm1, $01
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectUnpcku ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsrldq xmm1, xmm0, $08
                vpxor   xmm2, xmm0, xmm0
                vpunpcklwd xmm0, xmm2, xmm0
                vpunpcklwd xmm1, xmm2, xmm1
                vinserti128 ymm0, ymm0, xmm1, $01
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectPack ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_BYTE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubw  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmullw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddw  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubw  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsraw  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsllw  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrlw  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtw xmm0, xmm1, xmm0
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtw xmm0, xmm1, xmm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtw xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqw xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [short8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectMuls ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovsxwd ymm0, xmm0
                vpmovsxwd ymm1, xmm1
                vpmulld ymm0, ymm0, ymm1
                vpaddd  ymm0, ymm0, [int8_02]
                vpsrad  ymm0, ymm0, $0f
                vextracti128 xmm1, ymm0, $01
                vpackssdw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectAdds ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddsw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectSubs ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubsw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectMulu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovzxwd ymm0, xmm0
                vpmovzxwd ymm1, xmm1
                vpmulld ymm0, ymm0, ymm1
                vpaddd  ymm0, ymm0, [int8_01]
                vpsrld  ymm0, ymm0, $10
                vextracti128 xmm1, ymm0, $01
                vpackusdw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectAddu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddusw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc short8VectSubu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubusw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   INT                                                                                       ;
    ; =========================================================================================== ;

                align   $08
    proc intScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                neg     r0d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                imul    r0d, r10d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, $80000000
                jne     .L0
                cmp     r10d, $ffffffff
                je      .L1
        .L0:    mov     r11, r2
                cdq
                idiv    r10d
                mov     r2, r11
        .L1:    ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalDivu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                mov     r11, r2
                xor     r2d, r2d
                div     r10d
                mov     r2, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalRem ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, $80000000
                jne     .L0
                cmp     r10d, $ffffffff
                jne     .L0
                xor     r0d, r0d
                jmp     .L1
        .L0:    mov     r11, r2
                cdq
                idiv    r10d
                mov     r0d, r2d
                mov     r2, r11
        .L1:    ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalRemu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                mov     r11, r2
                xor     r2d, r2d
                div     r10d
                mov     r0d, r2d
                mov     r2, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                add     r0d, r10d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                sub     r0d, r10d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sar     r0d, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sal     r0d, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                shr     r0d, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setg    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setge   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setl    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setle   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intBitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                not     r0d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intBitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                and     r0d, r10d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intBitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                or      r0d, r10d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intBitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                xor     r0d, r10d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectUnpckl ; this, dst, op0
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectUnpcku ; this, dst, op0
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                shl     r0, $20
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectPack ; this, dst, op0
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   xmm0, r0d
                vpackusdw xmm0, xmm0, xmm0
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0w
                mov     r8d, AVT_SHORT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                neg     r0d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                imul    r0d, r10d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                add     r0d, r10d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                sub     r0d, r10d
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sar     r0d, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sal     r0d, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                shr     r0d, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setng   r0b
                dec     r0b
                movsx   r0d, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setnge  r0b
                dec     r0b
                movsx   r0d, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setnl   r0b
                dec     r0b
                movsx   r0d, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setnle  r0b
                dec     r0b
                movsx   r0d, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                setne   r0b
                dec     r0b
                movsx   r0d, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc intVectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0d, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10d, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0d, r10d
                sete    r0b
                dec     r0b
                movsx   r0d, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   INT2                                                                                      ;
    ; =========================================================================================== ;

                align   $08
    proc int2ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubd  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vshufps xmm2, xmm1, xmm1, $e4
                vshufps xmm3, xmm2, xmm2, $e1
                vpmulld xmm2, xmm2, [int2_c0]
                vpmulld xmm1, xmm0, xmm3
                vpmulld xmm0, xmm0, xmm2
                vphaddd xmm0, xmm0, xmm1
                vshufps xmm0, xmm0, xmm0, $d8
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2ScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrad  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2ScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpslld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2ScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                vmovmskps r0d, xmm0
                and     r0d, $03
                cmp     r0d, $03
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                vmovmskps r0d, xmm0
                and     r0d, $03
                cmp     r0d, $03
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2BitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, [int4_00]
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2BitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpand   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2BitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpor    xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2BitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectUnpckl ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vshufps xmm0, xmm0, xmm0, $d8
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectUnpcku ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vshufps xmm0, xmm0, xmm0, $72
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectPack ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpackusdw xmm0, xmm0, xmm0
                ; запись результата ;
                vmovd   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubd  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmulld xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrad  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpslld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtd xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtd xmm0, xmm1, xmm0
                vpxor   xmm0, xmm0, [int4_00]
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtd xmm0, xmm1, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtd xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [int4_00]
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int2VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [int4_00]
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   INT4                                                                                      ;
    ; =========================================================================================== ;

                align   $08
    proc int4ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubd  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$40]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$20], xmm6
                vmovdqu [rsp+$30], xmm7
                vshufps xmm4, xmm1, xmm1, $e4
                vshufps xmm5, xmm4, xmm4, $b1
                vshufps xmm6, xmm4, xmm4, $4e
                vshufps xmm7, xmm4, xmm4, $1b
                vpmulld xmm4, xmm4, [int4_q0]
                vpmulld xmm5, xmm5, [int4_q1]
                vpmulld xmm6, xmm6, [int4_q2]
                vpmulld xmm7, xmm7, [int4_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 xmm6, [rsp+$20]
                vmovdqu xmm7, [rsp+$30]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4ScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrad  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4ScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpslld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4ScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                vmovmskps r0d, xmm0
                cmp     r0d, $0f
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                vmovmskps r0d, xmm0
                cmp     r0d, $0f
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4BitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, [int4_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4BitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpand   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4BitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpor    xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4BitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectUnpckl ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm2, xmm0, xmm0
                vpunpckhdq xmm1, xmm0, xmm2
                vpunpckldq xmm0, xmm0, xmm2
                vinserti128 ymm0, ymm0, xmm1, $01
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectUnpcku ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm2, xmm0, xmm0
                vpunpckhdq xmm1, xmm2, xmm0
                vpunpckldq xmm0, xmm2, xmm0
                vinserti128 ymm0, ymm0, xmm1, $01
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectPack ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpackusdw xmm0, xmm0, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubd  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmulld xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrad  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpslld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrld  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtd xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtd xmm0, xmm1, xmm0
                vpxor   xmm0, xmm0, [int4_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtd xmm0, xmm1, xmm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtd xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [int4_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int4VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [int4_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   INT8                                                                                      ;
    ; =========================================================================================== ;

                align   $08
    proc int8ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   ymm1, ymm0, ymm0
                vpsubd  ymm0, ymm1, ymm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$0160]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$0020], ymm6
                vmovdqu [rsp+$0040], ymm7
                vmovdqu [rsp+$0060], ymm8
                vmovdqu [rsp+$0080], ymm9
                vmovdqu [rsp+$00a0], ymm10
                vmovdqu [rsp+$00c0], ymm11
                vmovdqu [rsp+$00e0], ymm12
                vmovdqu [rsp+$0100], ymm13
                vmovdqu [rsp+$0120], ymm14
                vmovdqu [rsp+$0140], ymm15
                vmovdqa ymm8, ymm1
                vextracti128 xmm12, ymm8, $01
                vinserti128 ymm12, ymm12, xmm8, $01
                vshufps ymm9, ymm8, ymm8, $b1
                vshufps ymm10, ymm8, ymm8, $4e
                vshufps ymm11, ymm8, ymm8, $1b
                vshufps ymm13, ymm12, ymm12, $b1
                vshufps ymm14, ymm12, ymm12, $4e
                vshufps ymm15, ymm12, ymm12, $1b
                vpmulld ymm8, ymm8, [int8_o0]
                vpmulld ymm9, ymm9, [int8_o1]
                vpmulld ymm10, ymm10, [int8_o2]
                vpmulld ymm11, ymm11, [int8_o3]
                vpmulld ymm12, ymm12, [int8_o4]
                vpmulld ymm13, ymm13, [int8_o5]
                vpmulld ymm14, ymm14, [int8_o6]
                vpmulld ymm15, ymm15, [int8_o7]
                vpmulld ymm7, ymm0, ymm15
                vpmulld ymm6, ymm0, ymm14
                vpmulld ymm5, ymm0, ymm13
                vpmulld ymm4, ymm0, ymm12
                vpmulld ymm3, ymm0, ymm11
                vpmulld ymm2, ymm0, ymm10
                vpmulld ymm1, ymm0, ymm9
                vpmulld ymm0, ymm0, ymm8
                vphaddd ymm0, ymm0, ymm1
                vphaddd ymm1, ymm2, ymm3
                vphaddd ymm2, ymm4, ymm5
                vphaddd ymm3, ymm6, ymm7
                vphaddd ymm0, ymm0, ymm1
                vphaddd ymm1, ymm2, ymm3
                vextracti128 xmm2, ymm0, $01
                vextracti128 xmm3, ymm1, $01
                vpaddd  xmm0, xmm0, xmm2
                vpaddd  xmm1, xmm1, xmm3
                vinserti128 ymm0, ymm0, xmm1, $01
                vmovdqu ymm6, [rsp+$0020]
                vmovdqu ymm7, [rsp+$0040]
                vmovdqu ymm8, [rsp+$0060]
                vmovdqu ymm9, [rsp+$0080]
                vmovdqu ymm10, [rsp+$00a0]
                vmovdqu ymm11, [rsp+$00c0]
                vmovdqu ymm12, [rsp+$00e0]
                vmovdqu ymm13, [rsp+$0100]
                vmovdqu ymm14, [rsp+$0120]
                vmovdqu ymm15, [rsp+$0140]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddd  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubd  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8ScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrad  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8ScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpslld  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8ScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrld  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd ymm0, ymm0, ymm1
                vmovmskps r0d, ymm0
                cmp     r0d, $ff
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd ymm0, ymm0, ymm1
                vmovmskps r0d, ymm0
                cmp     r0d, $ff
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8BitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   ymm0, ymm0, [int8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8BitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpand   ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8BitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpor    ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8BitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectUnpckl ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm4, xmm0, xmm0
                vextracti128 xmm2, ymm0, $01
                vpunpckhdq xmm3, xmm2, xmm4
                vpunpckhdq xmm1, xmm0, xmm4
                vpunpckldq xmm2, xmm2, xmm4
                vpunpckldq xmm0, xmm0, xmm4
                vinserti64x2 zmm0, zmm0, xmm1, $01
                vinserti64x2 zmm0, zmm0, xmm2, $02
                vinserti64x2 zmm0, zmm0, xmm3, $03
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectUnpcku ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm4, xmm0, xmm0
                vextracti128 xmm2, ymm0, $01
                vpunpckhdq xmm3, xmm4, xmm2
                vpunpckhdq xmm1, xmm4, xmm0
                vpunpckldq xmm2, xmm4, xmm2
                vpunpckldq xmm0, xmm4, xmm0
                vinserti64x2 zmm0, zmm0, xmm1, $01
                vinserti64x2 zmm0, zmm0, xmm2, $02
                vinserti64x2 zmm0, zmm0, xmm3, $03
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectPack ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vextracti128 xmm1, ymm0, $01
                vpackusdw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_SHORT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   ymm1, ymm0, ymm0
                vpsubd  ymm0, ymm1, ymm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmulld ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddd  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubd  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrad  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpslld  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $1f
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrld  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtd ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtd ymm0, ymm1, ymm0
                vpxor   ymm0, ymm0, [int8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtd ymm0, ymm1, ymm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtd ymm0, ymm0, ymm1
                vpxor   ymm0, ymm0, [int8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc int8VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqd ymm0, ymm0, ymm1
                vpxor   ymm0, ymm0, [int8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   LONG                                                                                      ;
    ; =========================================================================================== ;

                align   $08
    proc longScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                neg     r0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                imul    r0, r10
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0, [long_01]
                jne     .L0
                cmp     r10, [long_00]
                je      .L1
        .L0:    mov     r11, r2
                cqo
                idiv    r10
                mov     r2, r11
        .L1:    ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalDivu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                mov     r11, r2
                xor     r2, r2
                div     r10
                mov     r2, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalRem ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0, [long_01]
                jne     .L0
                cmp     r10, [long_00]
                jne     .L0
                xor     r0, r0
                jmp     .L1
        .L0:    mov     r11, r2
                cqo
                idiv    r10
                mov     r0, r2
                mov     r2, r11
        .L1:    ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalRemu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                mov     r11, r2
                xor     r2, r2
                div     r10
                mov     r0, r2
                mov     r2, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                add     r0, r10
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                sub     r0, r10
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sar     r0, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sal     r0, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                shr     r0, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0, r10
                setg    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0, r10
                setge   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0, r10
                setl    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0, r10
                setle   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0, r10
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0, r10
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longBitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                not     r0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longBitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                and     r0, r10
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longBitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                or      r0, r10
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longBitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                xor     r0, r10
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longVectPack ; this, dst, op0
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                mov     r10, r0
                shr     r10, $20
                cmp     r10d, $00000000
                je      .L1
                jg      .L0
                xor     r0d, r0d
                jmp     .L1
        .L0:    mov     r0d, $ffffffff
        .L1:    ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longVectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longVectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                neg     r0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longVectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                imul    r0, r10
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longVectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                add     r0, r10
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longVectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                sub     r0, r10
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longVectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sar     r0, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longVectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                sal     r0, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longVectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                ; выполнение операции ;
                mov     r11, r1
                mov     r1d, r10d
                shr     r0, r1b
                mov     r1, r11
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longVectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0, r10
                setng   r0b
                dec     r0b
                movsx   r0, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longVectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0, r10
                setnge  r0b
                dec     r0b
                movsx   r0, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longVectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0, r10
                setnl   r0b
                dec     r0b
                movsx   r0, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longVectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0, r10
                setnle  r0b
                dec     r0b
                movsx   r0, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longVectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0, r10
                setne   r0b
                dec     r0b
                movsx   r0, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc longVectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                mov     r0, [r8+AVTConstant.asPrimitiveValueOffset]
                mov     r10, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                cmp     r0, r10
                sete    r0b
                dec     r0b
                movsx   r0, r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   LONG2                                                                                     ;
    ; =========================================================================================== ;

                align   $08
    proc long2ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubq  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vshufpd xmm2, xmm1, xmm1, $02
                vshufpd xmm3, xmm2, xmm2, $01
                vpmullq xmm2, xmm2, [long2_c0]
                vpmullq xmm1, xmm0, xmm3
                vpmullq xmm0, xmm0, xmm2
                vshufpd xmm2, xmm0, xmm1, $00
                vshufpd xmm3, xmm0, xmm1, $03
                vpaddq  xmm0, xmm2, xmm3
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddq  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubq  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2ScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsraq  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2ScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsllq  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2ScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrlq  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqq xmm0, xmm0, xmm1
                vmovmskpd r0d, xmm0
                cmp     r0d, $03
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqq xmm0, xmm0, xmm1
                vmovmskpd r0d, xmm0
                cmp     r0d, $03
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2BitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, [long8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2BitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpand   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2BitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpor    xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2BitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2VectPack ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpcmpgtq xmm1, xmm1, xmm0
                vpcmpgtq xmm2, xmm0, [long8_01]
                vpandn  xmm0, xmm1, xmm0
                vpor    xmm0, xmm2, xmm0
                vshufps xmm0, xmm0, xmm0, $d8
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vpsubq  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmullq xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddq  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubq  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2VectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsraq  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2VectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsllq  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2VectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrlq  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtq xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtq xmm0, xmm1, xmm0
                vpxor   xmm0, xmm0, [long8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtq xmm0, xmm1, xmm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtq xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [long8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqq xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long2VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqq xmm0, xmm0, xmm1
                vpxor   xmm0, xmm0, [long8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   LONG4                                                                                     ;
    ; =========================================================================================== ;

                align   $08
    proc long4ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   ymm1, ymm0, ymm0
                vpsubq  ymm0, ymm1, ymm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$60]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$20], ymm6
                vmovdqu [rsp+$40], ymm7
                vshufi64x2 ymm4, ymm1, ymm1, $02
                vshufi64x2 ymm6, ymm4, ymm4, $01
                vshufpd ymm5, ymm4, ymm4, $05
                vshufpd ymm7, ymm6, ymm6, $05
                vpmullq ymm4, ymm4, [long4_q0]
                vpmullq ymm5, ymm5, [long4_q1]
                vpmullq ymm6, ymm6, [long4_q2]
                vpmullq ymm7, ymm7, [long4_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 ymm6, [rsp+$20]
                vmovdqu ymm7, [rsp+$40]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddq  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubq  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4ScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsraq  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4ScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsllq  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4ScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrlq  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqq ymm0, ymm0, ymm1
                vmovmskpd r0d, ymm0
                cmp     r0d, $0f
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqq ymm0, ymm0, ymm1
                vmovmskpd r0d, ymm0
                cmp     r0d, $0f
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4BitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   ymm0, ymm0, [long8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4BitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpand   ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4BitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpor    ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4BitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4VectPack ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   ymm1, ymm0, ymm0
                vpcmpgtq ymm1, ymm1, ymm0
                vpcmpgtq ymm2, ymm0, [long8_01]
                vpandn  ymm0, ymm1, ymm0
                vpor    ymm0, ymm2, ymm0
                vshufps ymm0, ymm0, ymm0, $d8
                vextracti128 xmm1, ymm0, $01
                vpslldq xmm0, xmm0, $08
                vpslldq xmm1, xmm1, $08
                vpsrldq xmm0, xmm0, $08
                vpor    xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   ymm1, ymm0, ymm0
                vpsubq  ymm0, ymm1, ymm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmullq ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddq  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubq  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4VectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsraq  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4VectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsllq  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4VectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrlq  ymm0, ymm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtq ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtq ymm0, ymm1, ymm0
                vpxor   ymm0, ymm0, [long8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtq ymm0, ymm1, ymm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtq ymm0, ymm0, ymm1
                vpxor   ymm0, ymm0, [long8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqq ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long4VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqq ymm0, ymm0, ymm1
                vpxor   ymm0, ymm0, [long8_00]
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   LONG8                                                                                     ;
    ; =========================================================================================== ;

                align   $08
    proc long8ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxorq  zmm1, zmm0, zmm0
                vpsubq  zmm0, zmm1, zmm0
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$02a0]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu64 [rsp+$0020], zmm6
                vmovdqu64 [rsp+$0060], zmm7
                vmovdqu64 [rsp+$00a0], zmm8
                vmovdqu64 [rsp+$00e0], zmm9
                vmovdqu64 [rsp+$0120], zmm10
                vmovdqu64 [rsp+$0160], zmm11
                vmovdqu64 [rsp+$01a0], zmm12
                vmovdqu64 [rsp+$01e0], zmm13
                vmovdqu64 [rsp+$0220], zmm14
                vmovdqu64 [rsp+$0260], zmm15
                vshufi64x2 zmm8, zmm1, zmm1, $e4
                vshufi64x2 zmm10, zmm8, zmm8, $b1
                vshufi64x2 zmm12, zmm8, zmm8, $4e
                vshufi64x2 zmm14, zmm8, zmm8, $1b
                vshufpd zmm9, zmm8, zmm8, $55
                vshufpd zmm11, zmm10, zmm10, $55
                vshufpd zmm13, zmm12, zmm12, $55
                vshufpd zmm15, zmm14, zmm14, $55
                vpmullq zmm8, zmm8, [long8_o0]
                vpmullq zmm9, zmm9, [long8_o1]
                vpmullq zmm10, zmm10, [long8_o2]
                vpmullq zmm11, zmm11, [long8_o3]
                vpmullq zmm12, zmm12, [long8_o4]
                vpmullq zmm13, zmm13, [long8_o5]
                vpmullq zmm14, zmm14, [long8_o6]
                vpmullq zmm15, zmm15, [long8_o7]
                vpmullq zmm7, zmm0, zmm15
                vpmullq zmm6, zmm0, zmm14
                vpmullq zmm5, zmm0, zmm13
                vpmullq zmm4, zmm0, zmm12
                vpmullq zmm3, zmm0, zmm11
                vpmullq zmm2, zmm0, zmm10
                vpmullq zmm1, zmm0, zmm9
                vpmullq zmm0, zmm0, zmm8
                vextracti64x4 ymm8, zmm0, $01
                vextracti64x4 ymm9, zmm1, $01
                vextracti64x4 ymm10, zmm2, $01
                vextracti64x4 ymm11, zmm3, $01
                vextracti64x4 ymm12, zmm4, $01
                vextracti64x4 ymm13, zmm5, $01
                vextracti64x4 ymm14, zmm6, $01
                vextracti64x4 ymm15, zmm7, $01
                vinserti64x4 zmm0, zmm0, ymm2, $01
                vinserti64x4 zmm2, zmm4, ymm6, $01
                vinserti64x4 zmm4, zmm1, ymm3, $01
                vinserti64x4 zmm6, zmm5, ymm7, $01
                vinserti64x4 zmm1, zmm8, ymm10, $01
                vinserti64x4 zmm3, zmm12, ymm14, $01
                vinserti64x4 zmm5, zmm9, ymm11, $01
                vinserti64x4 zmm7, zmm13, ymm15, $01
                vpaddq  zmm0, zmm0, zmm1
                vpaddq  zmm1, zmm2, zmm3
                vpaddq  zmm2, zmm4, zmm5
                vpaddq  zmm3, zmm6, zmm7
                vshufi64x2 zmm4, zmm0, zmm1, $88
                vshufi64x2 zmm5, zmm0, zmm1, $dd
                vshufi64x2 zmm6, zmm2, zmm3, $88
                vshufi64x2 zmm7, zmm2, zmm3, $dd
                vpaddq  zmm0, zmm4, zmm5
                vpaddq  zmm1, zmm6, zmm7
                vshufpd zmm2, zmm0, zmm1, $00
                vshufpd zmm3, zmm0, zmm1, $ff
                vpaddq  zmm0, zmm2, zmm3
                vmovdqu64 zmm6, [rsp+$0020]
                vmovdqu64 zmm7, [rsp+$0060]
                vmovdqu64 zmm8, [rsp+$00a0]
                vmovdqu64 zmm9, [rsp+$00e0]
                vmovdqu64 zmm10, [rsp+$0120]
                vmovdqu64 zmm11, [rsp+$0160]
                vmovdqu64 zmm12, [rsp+$01a0]
                vmovdqu64 zmm13, [rsp+$01e0]
                vmovdqu64 zmm14, [rsp+$0220]
                vmovdqu64 zmm15, [rsp+$0260]
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddq  zmm0, zmm0, zmm1
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubq  zmm0, zmm0, zmm1
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8ScalSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsraq  zmm0, zmm0, xmm1
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8ScalSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsllq  zmm0, zmm0, xmm1
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8ScalShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrlq  zmm0, zmm0, xmm1
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqq k0, zmm0, zmm1
                kmovw   r0d, k0
                cmp     r0d, $ff
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqq k0, zmm0, zmm1
                kmovw   r0d, k0
                cmp     r0d, $ff
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8BitNot ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxorq  zmm0, zmm0, [long8_00]
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8BitAnd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpandq  zmm0, zmm0, zmm1
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8BitOr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vporq   zmm0, zmm0, zmm1
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8BitXor ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxorq  zmm0, zmm0, zmm1
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8VectPack ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxorq  zmm1, zmm0, zmm0
                vpcmpgtq k1, zmm1, zmm0
                vpcmpgtq k2, zmm0, [long8_01]
                vmovdqa64 zmm1{k1}{z}, [long8_00]
                vmovdqa64 zmm2{k2}{z}, [long8_00]
                vpandnq zmm0, zmm1, zmm0
                vporq   zmm0, zmm2, zmm0
                vshufps zmm0, zmm0, zmm0, $d8
                vshufi64x2 zmm0, zmm0, zmm0, $d8
                vextracti64x4 ymm1, zmm0, $01
                vpslldq ymm0, ymm0, $08
                vpslldq ymm1, ymm1, $08
                vpsrldq ymm0, ymm0, $08
                vpor    ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxorq  zmm1, zmm0, zmm0
                vpsubq  zmm0, zmm1, zmm0
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmullq zmm0, zmm0, zmm1
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpaddq  zmm0, zmm0, zmm1
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpsubq  zmm0, zmm0, zmm1
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8VectSar ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsraq  zmm0, zmm0, xmm1
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8VectSal ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsllq  zmm0, zmm0, xmm1
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8VectShr ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                movzx   r10d, byte[r9+AVTConstant.asPrimitiveValueOffset]
                and     r10d, $3f
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovd   xmm1, r10d
                ; выполнение операции ;
                vpsrlq  zmm0, zmm0, xmm1
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtq k1, zmm0, zmm1
                vmovdqa64 zmm0{k1}{z}, [long8_00]
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtq k1, zmm1, zmm0
                knotw   k1, k1
                vmovdqa64 zmm0{k1}{z}, [long8_00]
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtq k1, zmm1, zmm0
                vmovdqa64 zmm0{k1}{z}, [long8_00]
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpgtq k1, zmm0, zmm1
                knotw   k1, k1
                vmovdqa64 zmm0{k1}{z}, [long8_00]
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqq k1, zmm0, zmm1
                vmovdqa64 zmm0{k1}{z}, [long8_00]
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc long8VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovdqu64 zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpcmpeqq k1, zmm0, zmm1
                knotw   k1, k1
                vmovdqa64 zmm0{k1}{z}, [long8_00]
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   FLOAT                                                                                     ;
    ; =========================================================================================== ;

                align   $08
    proc floatScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovss  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vsubss  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovss  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmulss  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovss  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatScalDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vdivss  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovss  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatScalDivu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vdivss  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovss  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatScalRem ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovss  [rsp+$00], xmm0
                vmovss  [rsp+$08], xmm1
                fld     dword[rsp+$08]
                fld     dword[rsp+$00]
        @@:     fprem
                fnstsw  r0w
                test    r0w, $0400
                jnz     @B
                fstp    st1
                fstp    dword[rsp+$00]
                vmovss  xmm0, [rsp+$00]
                ; запись результата ;
                vmovss  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatScalRemu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovss  [rsp+$00], xmm0
                vmovss  [rsp+$08], xmm1
                fld     dword[rsp+$08]
                fld     dword[rsp+$00]
        @@:     fprem
                fnstsw  r0w
                test    r0w, $0400
                jnz     @B
                fstp    st1
                fstp    dword[rsp+$00]
                vmovss  xmm0, [rsp+$00]
                ; запись результата ;
                vmovss  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddss  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovss  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubss  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovss  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatScalG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpss  xmm0, xmm1, xmm0, $01
                vmovmskps r0d, xmm0
                and     r0d, $01
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatScalGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpss  xmm0, xmm1, xmm0, $02
                vmovmskps r0d, xmm0
                and     r0d, $01
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatScalL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpss  xmm0, xmm0, xmm1, $01
                vmovmskps r0d, xmm0
                and     r0d, $01
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatScalLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpss  xmm0, xmm0, xmm1, $02
                vmovmskps r0d, xmm0
                and     r0d, $01
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpss  xmm0, xmm0, xmm1, $00
                vmovmskps r0d, xmm0
                and     r0d, $01
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpss  xmm0, xmm0, xmm1, $04
                vmovmskps r0d, xmm0
                and     r0d, $01
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatVectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovss  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatVectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vsubss  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovss  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatVectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmulss  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovss  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatVectDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vdivss  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovss  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatVectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddss  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovss  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatVectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubss  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovss  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatVectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpss  xmm0, xmm1, xmm0, $01
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatVectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpss  xmm0, xmm1, xmm0, $02
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatVectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpss  xmm0, xmm0, xmm1, $01
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatVectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpss  xmm0, xmm0, xmm1, $02
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatVectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpss  xmm0, xmm0, xmm1, $00
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc floatVectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovss  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovss  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpss  xmm0, xmm0, xmm1, $04
                vmovd   r0d, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0d
                mov     r8d, AVT_INT
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   FLOAT2                                                                                    ;
    ; =========================================================================================== ;

                align   $08
    proc float2ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vsubps  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vshufps xmm2, xmm1, xmm1, $e4
                vshufps xmm3, xmm2, xmm2, $e1
                vmulps  xmm2, xmm2, [float2_c0]
                vmulps  xmm1, xmm0, xmm3
                vmulps  xmm0, xmm0, xmm2
                vhaddps xmm0, xmm0, xmm1
                vshufps xmm0, xmm0, xmm0, $d8
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2ScalDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmulps  xmm1, xmm1, [float2_c0]
                vmulps  xmm2, xmm1, xmm1
                vhaddps xmm2, xmm2, xmm2
                vshufps xmm2, xmm2, xmm2, $d8
                vdivps  xmm1, xmm1, xmm2
                vshufps xmm2, xmm1, xmm1, $e4
                vshufps xmm3, xmm2, xmm2, $e1
                vmulps  xmm2, xmm2, [float2_c0]
                vmulps  xmm1, xmm0, xmm3
                vmulps  xmm0, xmm0, xmm2
                vhaddps xmm0, xmm0, xmm1
                vshufps xmm0, xmm0, xmm0, $d8
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2ScalDivu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmulps  xmm1, xmm1, [float2_c0]
                vmulps  xmm2, xmm1, xmm1
                vhaddps xmm2, xmm2, xmm2
                vshufps xmm2, xmm2, xmm2, $d8
                vdivps  xmm1, xmm1, xmm2
                vmovaps xmm2, xmm1
                vmovaps xmm1, xmm0
                vmovaps xmm0, xmm2
                vshufps xmm2, xmm1, xmm1, $e4
                vshufps xmm3, xmm2, xmm2, $e1
                vmulps  xmm2, xmm2, [float2_c0]
                vmulps  xmm1, xmm0, xmm3
                vmulps  xmm0, xmm0, xmm2
                vhaddps xmm0, xmm0, xmm1
                vshufps xmm0, xmm0, xmm0, $d8
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddps  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubps  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm0, xmm1, $00
                vmovmskps r0d, xmm0
                and     r0d, $03
                cmp     r0d, $03
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm0, xmm1, $00
                vmovmskps r0d, xmm0
                and     r0d, $03
                cmp     r0d, $03
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vsubps  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmulps  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2VectDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vdivps  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddps  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubps  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm1, xmm0, $01
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm1, xmm0, $02
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm0, xmm1, $01
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm0, xmm1, $02
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm0, xmm1, $00
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float2VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovq   xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm0, xmm1, $04
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT2
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   FLOAT4                                                                                    ;
    ; =========================================================================================== ;

                align   $08
    proc float4ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vsubps  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$40]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$20], xmm6
                vmovdqu [rsp+$30], xmm7
                vshufps xmm4, xmm1, xmm1, $e4
                vshufps xmm5, xmm4, xmm4, $b1
                vshufps xmm6, xmm4, xmm4, $4e
                vshufps xmm7, xmm4, xmm4, $1b
                vmulps  xmm4, xmm4, [float4_q0]
                vmulps  xmm5, xmm5, [float4_q1]
                vmulps  xmm6, xmm6, [float4_q2]
                vmulps  xmm7, xmm7, [float4_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 xmm6, [rsp+$20]
                vmovdqu xmm7, [rsp+$30]
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4ScalDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$40]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$20], xmm6
                vmovdqu [rsp+$30], xmm7
                vmulps  xmm1, xmm1, [float4_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, [float4_q0]
                vmulps  xmm5, xmm5, [float4_q1]
                vmulps  xmm6, xmm6, [float4_q2]
                vmulps  xmm7, xmm7, [float4_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 xmm6, [rsp+$20]
                vmovdqu xmm7, [rsp+$30]
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4ScalDivu ; this, dst, op0, op1
                lea     rsp, [rsp-$40]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$20], xmm6
                vmovdqu [rsp+$30], xmm7
                vmulps  xmm1, xmm1, [float4_q0]
                vmulps  xmm2, xmm1, xmm1
                vhaddps xmm2, xmm2, xmm2
                vhaddps xmm2, xmm2, xmm2
                vdivps  xmm1, xmm1, xmm2
                vmovaps xmm2, xmm1
                vmovaps xmm1, xmm0
                vmovaps xmm0, xmm2
                vshufps xmm4, xmm1, xmm1, $e4
                vshufps xmm5, xmm4, xmm4, $b1
                vshufps xmm6, xmm4, xmm4, $4e
                vshufps xmm7, xmm4, xmm4, $1b
                vmulps  xmm4, xmm4, [float4_q0]
                vmulps  xmm5, xmm5, [float4_q1]
                vmulps  xmm6, xmm6, [float4_q2]
                vmulps  xmm7, xmm7, [float4_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 xmm6, [rsp+$20]
                vmovdqu xmm7, [rsp+$30]
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddps  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubps  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm0, xmm1, $00
                vmovmskps r0d, xmm0
                cmp     r0d, $0f
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm0, xmm1, $00
                vmovmskps r0d, xmm0
                cmp     r0d, $0f
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vsubps  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmulps  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4VectDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vdivps  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddps  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubps  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_FLOAT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm1, xmm0, $01
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm1, xmm0, $02
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm0, xmm1, $01
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm0, xmm1, $02
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm0, xmm1, $00
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float4VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  xmm0, xmm0, xmm1, $04
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_INT4
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   FLOAT8                                                                                    ;
    ; =========================================================================================== ;

                align   $08
    proc float8ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_FLOAT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   ymm1, ymm0, ymm0
                vsubps  ymm0, ymm1, ymm0
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_FLOAT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$0160]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$0020], ymm6
                vmovdqu [rsp+$0040], ymm7
                vmovdqu [rsp+$0060], ymm8
                vmovdqu [rsp+$0080], ymm9
                vmovdqu [rsp+$00a0], ymm10
                vmovdqu [rsp+$00c0], ymm11
                vmovdqu [rsp+$00e0], ymm12
                vmovdqu [rsp+$0100], ymm13
                vmovdqu [rsp+$0120], ymm14
                vmovdqu [rsp+$0140], ymm15
                vmovaps ymm8, ymm1
                vextractf128 xmm12, ymm8, $01
                vinsertf128 ymm12, ymm12, xmm8, $01
                vshufps ymm9, ymm8, ymm8, $b1
                vshufps ymm10, ymm8, ymm8, $4e
                vshufps ymm11, ymm8, ymm8, $1b
                vshufps ymm13, ymm12, ymm12, $b1
                vshufps ymm14, ymm12, ymm12, $4e
                vshufps ymm15, ymm12, ymm12, $1b
                vmulps  ymm8, ymm8, [float8_o0]
                vmulps  ymm9, ymm9, [float8_o1]
                vmulps  ymm10, ymm10, [float8_o2]
                vmulps  ymm11, ymm11, [float8_o3]
                vmulps  ymm12, ymm12, [float8_o4]
                vmulps  ymm13, ymm13, [float8_o5]
                vmulps  ymm14, ymm14, [float8_o6]
                vmulps  ymm15, ymm15, [float8_o7]
                vmulps  ymm7, ymm0, ymm15
                vmulps  ymm6, ymm0, ymm14
                vmulps  ymm5, ymm0, ymm13
                vmulps  ymm4, ymm0, ymm12
                vmulps  ymm3, ymm0, ymm11
                vmulps  ymm2, ymm0, ymm10
                vmulps  ymm1, ymm0, ymm9
                vmulps  ymm0, ymm0, ymm8
                vhaddps ymm0, ymm0, ymm1
                vhaddps ymm1, ymm2, ymm3
                vhaddps ymm2, ymm4, ymm5
                vhaddps ymm3, ymm6, ymm7
                vhaddps ymm0, ymm0, ymm1
                vhaddps ymm1, ymm2, ymm3
                vextractf128 xmm2, ymm0, $01
                vextractf128 xmm3, ymm1, $01
                vaddps  xmm0, xmm0, xmm2
                vaddps  xmm1, xmm1, xmm3
                vinsertf128 ymm0, ymm0, xmm1, $01
                vmovdqu ymm6, [rsp+$0020]
                vmovdqu ymm7, [rsp+$0040]
                vmovdqu ymm8, [rsp+$0060]
                vmovdqu ymm9, [rsp+$0080]
                vmovdqu ymm10, [rsp+$00a0]
                vmovdqu ymm11, [rsp+$00c0]
                vmovdqu ymm12, [rsp+$00e0]
                vmovdqu ymm13, [rsp+$0100]
                vmovdqu ymm14, [rsp+$0120]
                vmovdqu ymm15, [rsp+$0140]
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_FLOAT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8ScalDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$0160]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$0020], ymm6
                vmovdqu [rsp+$0040], ymm7
                vmovdqu [rsp+$0060], ymm8
                vmovdqu [rsp+$0080], ymm9
                vmovdqu [rsp+$00a0], ymm10
                vmovdqu [rsp+$00c0], ymm11
                vmovdqu [rsp+$00e0], ymm12
                vmovdqu [rsp+$0100], ymm13
                vmovdqu [rsp+$0120], ymm14
                vmovdqu [rsp+$0140], ymm15
                vmulps  ymm1, ymm1, [float8_o0]
                vmulps  ymm2, ymm1, ymm1
                vextractf128 xmm3, ymm2, $01
                vhaddps xmm2, xmm2, xmm3
                vhaddps xmm2, xmm2, xmm2
                vhaddps xmm2, xmm2, xmm2
                vinsertf128 ymm2, ymm2, xmm2, $01
                vdivps  ymm1, ymm1, ymm2
                vmovaps ymm8, ymm1
                vextractf128 xmm12, ymm8, $01
                vinsertf128 ymm12, ymm12, xmm8, $01
                vshufps ymm9, ymm8, ymm8, $b1
                vshufps ymm10, ymm8, ymm8, $4e
                vshufps ymm11, ymm8, ymm8, $1b
                vshufps ymm13, ymm12, ymm12, $b1
                vshufps ymm14, ymm12, ymm12, $4e
                vshufps ymm15, ymm12, ymm12, $1b
                vmulps  ymm8, ymm8, [float8_o0]
                vmulps  ymm9, ymm9, [float8_o1]
                vmulps  ymm10, ymm10, [float8_o2]
                vmulps  ymm11, ymm11, [float8_o3]
                vmulps  ymm12, ymm12, [float8_o4]
                vmulps  ymm13, ymm13, [float8_o5]
                vmulps  ymm14, ymm14, [float8_o6]
                vmulps  ymm15, ymm15, [float8_o7]
                vmulps  ymm7, ymm0, ymm15
                vmulps  ymm6, ymm0, ymm14
                vmulps  ymm5, ymm0, ymm13
                vmulps  ymm4, ymm0, ymm12
                vmulps  ymm3, ymm0, ymm11
                vmulps  ymm2, ymm0, ymm10
                vmulps  ymm1, ymm0, ymm9
                vmulps  ymm0, ymm0, ymm8
                vhaddps ymm0, ymm0, ymm1
                vhaddps ymm1, ymm2, ymm3
                vhaddps ymm2, ymm4, ymm5
                vhaddps ymm3, ymm6, ymm7
                vhaddps ymm0, ymm0, ymm1
                vhaddps ymm1, ymm2, ymm3
                vextractf128 xmm2, ymm0, $01
                vextractf128 xmm3, ymm1, $01
                vaddps  xmm0, xmm0, xmm2
                vaddps  xmm1, xmm1, xmm3
                vinsertf128 ymm0, ymm0, xmm1, $01
                vmovdqu ymm6, [rsp+$0020]
                vmovdqu ymm7, [rsp+$0040]
                vmovdqu ymm8, [rsp+$0060]
                vmovdqu ymm9, [rsp+$0080]
                vmovdqu ymm10, [rsp+$00a0]
                vmovdqu ymm11, [rsp+$00c0]
                vmovdqu ymm12, [rsp+$00e0]
                vmovdqu ymm13, [rsp+$0100]
                vmovdqu ymm14, [rsp+$0120]
                vmovdqu ymm15, [rsp+$0140]
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_FLOAT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8ScalDivu ; this, dst, op0, op1
                lea     rsp, [rsp-$0160]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$0020], ymm6
                vmovdqu [rsp+$0040], ymm7
                vmovdqu [rsp+$0060], ymm8
                vmovdqu [rsp+$0080], ymm9
                vmovdqu [rsp+$00a0], ymm10
                vmovdqu [rsp+$00c0], ymm11
                vmovdqu [rsp+$00e0], ymm12
                vmovdqu [rsp+$0100], ymm13
                vmovdqu [rsp+$0120], ymm14
                vmovdqu [rsp+$0140], ymm15
                vmulps  ymm1, ymm1, [float8_o0]
                vmulps  ymm2, ymm1, ymm1
                vextractf128 xmm3, ymm2, $01
                vhaddps xmm2, xmm2, xmm3
                vhaddps xmm2, xmm2, xmm2
                vhaddps xmm2, xmm2, xmm2
                vinsertf128 ymm2, ymm2, xmm2, $01
                vdivps  ymm1, ymm1, ymm2
                vmovaps ymm2, ymm1
                vmovaps ymm1, ymm0
                vmovaps ymm0, ymm2
                vmovaps ymm8, ymm1
                vextractf128 xmm12, ymm8, $01
                vinsertf128 ymm12, ymm12, xmm8, $01
                vshufps ymm9, ymm8, ymm8, $b1
                vshufps ymm10, ymm8, ymm8, $4e
                vshufps ymm11, ymm8, ymm8, $1b
                vshufps ymm13, ymm12, ymm12, $b1
                vshufps ymm14, ymm12, ymm12, $4e
                vshufps ymm15, ymm12, ymm12, $1b
                vmulps  ymm8, ymm8, [float8_o0]
                vmulps  ymm9, ymm9, [float8_o1]
                vmulps  ymm10, ymm10, [float8_o2]
                vmulps  ymm11, ymm11, [float8_o3]
                vmulps  ymm12, ymm12, [float8_o4]
                vmulps  ymm13, ymm13, [float8_o5]
                vmulps  ymm14, ymm14, [float8_o6]
                vmulps  ymm15, ymm15, [float8_o7]
                vmulps  ymm7, ymm0, ymm15
                vmulps  ymm6, ymm0, ymm14
                vmulps  ymm5, ymm0, ymm13
                vmulps  ymm4, ymm0, ymm12
                vmulps  ymm3, ymm0, ymm11
                vmulps  ymm2, ymm0, ymm10
                vmulps  ymm1, ymm0, ymm9
                vmulps  ymm0, ymm0, ymm8
                vhaddps ymm0, ymm0, ymm1
                vhaddps ymm1, ymm2, ymm3
                vhaddps ymm2, ymm4, ymm5
                vhaddps ymm3, ymm6, ymm7
                vhaddps ymm0, ymm0, ymm1
                vhaddps ymm1, ymm2, ymm3
                vextractf128 xmm2, ymm0, $01
                vextractf128 xmm3, ymm1, $01
                vaddps  xmm0, xmm0, xmm2
                vaddps  xmm1, xmm1, xmm3
                vinsertf128 ymm0, ymm0, xmm1, $01
                vmovdqu ymm6, [rsp+$0020]
                vmovdqu ymm7, [rsp+$0040]
                vmovdqu ymm8, [rsp+$0060]
                vmovdqu ymm9, [rsp+$0080]
                vmovdqu ymm10, [rsp+$00a0]
                vmovdqu ymm11, [rsp+$00c0]
                vmovdqu ymm12, [rsp+$00e0]
                vmovdqu ymm13, [rsp+$0100]
                vmovdqu ymm14, [rsp+$0120]
                vmovdqu ymm15, [rsp+$0140]
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_FLOAT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddps  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_FLOAT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubps  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_FLOAT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  ymm0, ymm0, ymm1, $00
                vmovmskps r0d, ymm0
                cmp     r0d, $ff
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  ymm0, ymm0, ymm1, $00
                vmovmskps r0d, ymm0
                cmp     r0d, $ff
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_FLOAT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   ymm1, ymm0, ymm0
                vsubps  ymm0, ymm1, ymm0
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_FLOAT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmulps  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_FLOAT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8VectDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vdivps  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_FLOAT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddps  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_FLOAT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubps  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_FLOAT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  ymm0, ymm1, ymm0, $01
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  ymm0, ymm1, ymm0, $02
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  ymm0, ymm0, ymm1, $01
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  ymm0, ymm0, ymm1, $02
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  ymm0, ymm0, ymm1, $00
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc float8VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovups ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpps  ymm0, ymm0, ymm1, $04
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_INT8
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   DOUBLE                                                                                    ;
    ; =========================================================================================== ;

                align   $08
    proc doubleScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovsd  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vsubsd  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovsd  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmulsd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovsd  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleScalDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vdivsd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovsd  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleScalDivu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vdivsd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovsd  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleScalRem ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovsd  [rsp+$00], xmm0
                vmovsd  [rsp+$08], xmm1
                fld     qword[rsp+$08]
                fld     qword[rsp+$00]
        @@:     fprem
                fnstsw  r0w
                test    r0w, $0400
                jnz     @B
                fstp    st1
                fstp    qword[rsp+$00]
                vmovsd  xmm0, [rsp+$00]
                ; запись результата ;
                vmovsd  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleScalRemu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovsd  [rsp+$00], xmm0
                vmovsd  [rsp+$08], xmm1
                fld     qword[rsp+$08]
                fld     qword[rsp+$00]
        @@:     fprem
                fnstsw  r0w
                test    r0w, $0400
                jnz     @B
                fstp    st1
                fstp    qword[rsp+$00]
                vmovsd  xmm0, [rsp+$00]
                ; запись результата ;
                vmovsd  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddsd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovsd  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubsd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovsd  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleScalG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpsd  xmm0, xmm1, xmm0, $01
                vmovmskpd r0d, xmm0
                and     r0d, $01
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleScalGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpsd  xmm0, xmm1, xmm0, $02
                vmovmskpd r0d, xmm0
                and     r0d, $01
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleScalL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpsd  xmm0, xmm0, xmm1, $01
                vmovmskpd r0d, xmm0
                and     r0d, $01
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleScalLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpsd  xmm0, xmm0, xmm1, $02
                vmovmskpd r0d, xmm0
                and     r0d, $01
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpsd  xmm0, xmm0, xmm1, $00
                vmovmskpd r0d, xmm0
                and     r0d, $01
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpsd  xmm0, xmm0, xmm1, $04
                vmovmskpd r0d, xmm0
                and     r0d, $01
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleVectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovsd  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleVectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vsubsd  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovsd  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleVectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmulsd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovsd  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleVectDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vdivsd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovsd  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleVectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddsd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovsd  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleVectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubsd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovsd  [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleVectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpsd  xmm0, xmm1, xmm0, $01
                vmovq   r0, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleVectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpsd  xmm0, xmm1, xmm0, $02
                vmovq   r0, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleVectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpsd  xmm0, xmm0, xmm1, $01
                vmovq   r0, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleVectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpsd  xmm0, xmm0, xmm1, $02
                vmovq   r0, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleVectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpsd  xmm0, xmm0, xmm1, $00
                vmovq   r0, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc doubleVectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovsd  xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovsd  xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmpsd  xmm0, xmm0, xmm1, $04
                vmovq   r0, xmm0
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0
                mov     r8d, AVT_LONG
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   DOUBLE2                                                                                   ;
    ; =========================================================================================== ;

                align   $08
    proc double2ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vsubpd  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vshufpd xmm2, xmm1, xmm1, $02
                vshufpd xmm3, xmm2, xmm2, $01
                vmulpd  xmm2, xmm2, [double2_c0]
                vmulpd  xmm1, xmm0, xmm3
                vmulpd  xmm0, xmm0, xmm2
                vhaddpd xmm0, xmm0, xmm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2ScalDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmulpd  xmm1, xmm1, [double2_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, [double2_c0]
                vmulpd  xmm1, xmm0, xmm3
                vmulpd  xmm0, xmm0, xmm2
                vhaddpd xmm0, xmm0, xmm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2ScalDivu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmulpd  xmm1, xmm1, [double2_c0]
                vmulpd  xmm2, xmm1, xmm1
                vhaddpd xmm2, xmm2, xmm2
                vdivpd  xmm1, xmm1, xmm2
                vmovapd xmm2, xmm1
                vmovapd xmm1, xmm0
                vmovapd xmm0, xmm2
                vshufpd xmm2, xmm1, xmm1, $02
                vshufpd xmm3, xmm2, xmm2, $01
                vmulpd  xmm2, xmm2, [double2_c0]
                vmulpd  xmm1, xmm0, xmm3
                vmulpd  xmm0, xmm0, xmm2
                vhaddpd xmm0, xmm0, xmm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddpd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubpd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  xmm0, xmm0, xmm1, $00
                vmovmskpd r0d, xmm0
                cmp     r0d, $03
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  xmm0, xmm0, xmm1, $00
                vmovmskpd r0d, xmm0
                cmp     r0d, $03
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   xmm1, xmm0, xmm0
                vsubpd  xmm0, xmm1, xmm0
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmulpd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2VectDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vdivpd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddpd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubpd  xmm0, xmm0, xmm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_DOUBLE2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  xmm0, xmm1, xmm0, $01
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  xmm0, xmm1, xmm0, $02
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  xmm0, xmm0, xmm1, $01
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  xmm0, xmm0, xmm1, $02
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  xmm0, xmm0, xmm1, $00
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double2VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd xmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  xmm0, xmm0, xmm1, $04
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, AVT_LONG2
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   DOUBLE4                                                                                   ;
    ; =========================================================================================== ;

                align   $08
    proc double4ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_DOUBLE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   ymm1, ymm0, ymm0
                vsubpd  ymm0, ymm1, ymm0
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_DOUBLE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$60]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$20], ymm6
                vmovdqu [rsp+$40], ymm7
                vshuff64x2 ymm4, ymm1, ymm1, $02
                vshuff64x2 ymm6, ymm4, ymm4, $01
                vshufpd ymm5, ymm4, ymm4, $05
                vshufpd ymm7, ymm6, ymm6, $05
                vmulpd  ymm4, ymm4, [double4_q0]
                vmulpd  ymm5, ymm5, [double4_q1]
                vmulpd  ymm6, ymm6, [double4_q2]
                vmulpd  ymm7, ymm7, [double4_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 ymm6, [rsp+$20]
                vmovdqu ymm7, [rsp+$40]
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_DOUBLE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4ScalDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$60]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$20], ymm6
                vmovdqu [rsp+$40], ymm7
                vmulpd  ymm1, ymm1, [double4_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, [double4_q0]
                vmulpd  ymm5, ymm5, [double4_q1]
                vmulpd  ymm6, ymm6, [double4_q2]
                vmulpd  ymm7, ymm7, [double4_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 ymm6, [rsp+$20]
                vmovdqu ymm7, [rsp+$40]
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_DOUBLE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4ScalDivu ; this, dst, op0, op1
                lea     rsp, [rsp-$60]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu [rsp+$20], ymm6
                vmovdqu [rsp+$40], ymm7
                vmulpd  ymm1, ymm1, [double4_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
                vmovapd ymm2, ymm1
                vmovapd ymm1, ymm0
                vmovapd ymm0, ymm2
                vshuff64x2 ymm4, ymm1, ymm1, $02
                vshuff64x2 ymm6, ymm4, ymm4, $01
                vshufpd ymm5, ymm4, ymm4, $05
                vshufpd ymm7, ymm6, ymm6, $05
                vmulpd  ymm4, ymm4, [double4_q0]
                vmulpd  ymm5, ymm5, [double4_q1]
                vmulpd  ymm6, ymm6, [double4_q2]
                vmulpd  ymm7, ymm7, [double4_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 ymm6, [rsp+$20]
                vmovdqu ymm7, [rsp+$40]
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_DOUBLE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddpd  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_DOUBLE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubpd  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_DOUBLE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  ymm0, ymm0, ymm1, $00
                vmovmskpd r0d, ymm0
                cmp     r0d, $0f
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  ymm0, ymm0, ymm1, $00
                vmovmskpd r0d, ymm0
                cmp     r0d, $0f
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_DOUBLE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxor   ymm1, ymm0, ymm0
                vsubpd  ymm0, ymm1, ymm0
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_DOUBLE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmulpd  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_DOUBLE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4VectDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vdivpd  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_DOUBLE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddpd  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_DOUBLE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubpd  ymm0, ymm0, ymm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_DOUBLE4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  ymm0, ymm1, ymm0, $01
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  ymm0, ymm1, ymm0, $02
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  ymm0, ymm0, ymm1, $01
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  ymm0, ymm0, ymm1, $02
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  ymm0, ymm0, ymm1, $00
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double4VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd ymm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  ymm0, ymm0, ymm1, $04
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, AVT_LONG4
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   DOUBLE8                                                                                   ;
    ; =========================================================================================== ;

                align   $08
    proc double8ScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_DOUBLE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8ScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxorq  zmm1, zmm0, zmm0
                vsubpd  zmm0, zmm1, zmm0, {rn-sae}
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_DOUBLE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8ScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$02a0]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu64 [rsp+$0020], zmm6
                vmovdqu64 [rsp+$0060], zmm7
                vmovdqu64 [rsp+$00a0], zmm8
                vmovdqu64 [rsp+$00e0], zmm9
                vmovdqu64 [rsp+$0120], zmm10
                vmovdqu64 [rsp+$0160], zmm11
                vmovdqu64 [rsp+$01a0], zmm12
                vmovdqu64 [rsp+$01e0], zmm13
                vmovdqu64 [rsp+$0220], zmm14
                vmovdqu64 [rsp+$0260], zmm15
                vshuff64x2 zmm8, zmm1, zmm1, $e4
                vshuff64x2 zmm10, zmm8, zmm8, $b1
                vshuff64x2 zmm12, zmm8, zmm8, $4e
                vshuff64x2 zmm14, zmm8, zmm8, $1b
                vshufpd zmm9, zmm8, zmm8, $55
                vshufpd zmm11, zmm10, zmm10, $55
                vshufpd zmm13, zmm12, zmm12, $55
                vshufpd zmm15, zmm14, zmm14, $55
                vmulpd  zmm8, zmm8, [double8_o0]
                vmulpd  zmm9, zmm9, [double8_o1]
                vmulpd  zmm10, zmm10, [double8_o2]
                vmulpd  zmm11, zmm11, [double8_o3]
                vmulpd  zmm12, zmm12, [double8_o4]
                vmulpd  zmm13, zmm13, [double8_o5]
                vmulpd  zmm14, zmm14, [double8_o6]
                vmulpd  zmm15, zmm15, [double8_o7]
                vmulpd  zmm7, zmm0, zmm15, {rn-sae}
                vmulpd  zmm6, zmm0, zmm14, {rn-sae}
                vmulpd  zmm5, zmm0, zmm13, {rn-sae}
                vmulpd  zmm4, zmm0, zmm12, {rn-sae}
                vmulpd  zmm3, zmm0, zmm11, {rn-sae}
                vmulpd  zmm2, zmm0, zmm10, {rn-sae}
                vmulpd  zmm1, zmm0, zmm9, {rn-sae}
                vmulpd  zmm0, zmm0, zmm8, {rn-sae}
                vextractf64x4 ymm8, zmm0, $01
                vextractf64x4 ymm9, zmm1, $01
                vextractf64x4 ymm10, zmm2, $01
                vextractf64x4 ymm11, zmm3, $01
                vextractf64x4 ymm12, zmm4, $01
                vextractf64x4 ymm13, zmm5, $01
                vextractf64x4 ymm14, zmm6, $01
                vextractf64x4 ymm15, zmm7, $01
                vinsertf64x4 zmm0, zmm0, ymm2, $01
                vinsertf64x4 zmm2, zmm4, ymm6, $01
                vinsertf64x4 zmm4, zmm1, ymm3, $01
                vinsertf64x4 zmm6, zmm5, ymm7, $01
                vinsertf64x4 zmm1, zmm8, ymm10, $01
                vinsertf64x4 zmm3, zmm12, ymm14, $01
                vinsertf64x4 zmm5, zmm9, ymm11, $01
                vinsertf64x4 zmm7, zmm13, ymm15, $01
                vaddpd  zmm0, zmm0, zmm1
                vaddpd  zmm1, zmm2, zmm3
                vaddpd  zmm2, zmm4, zmm5
                vaddpd  zmm3, zmm6, zmm7
                vshuff64x2 zmm4, zmm0, zmm1, $88
                vshuff64x2 zmm5, zmm0, zmm1, $dd
                vshuff64x2 zmm6, zmm2, zmm3, $88
                vshuff64x2 zmm7, zmm2, zmm3, $dd
                vaddpd  zmm0, zmm4, zmm5
                vaddpd  zmm1, zmm6, zmm7
                vshufpd zmm2, zmm0, zmm1, $00
                vshufpd zmm3, zmm0, zmm1, $ff
                vaddpd  zmm0, zmm2, zmm3
                vmovdqu64 zmm6, [rsp+$0020]
                vmovdqu64 zmm7, [rsp+$0060]
                vmovdqu64 zmm8, [rsp+$00a0]
                vmovdqu64 zmm9, [rsp+$00e0]
                vmovdqu64 zmm10, [rsp+$0120]
                vmovdqu64 zmm11, [rsp+$0160]
                vmovdqu64 zmm12, [rsp+$01a0]
                vmovdqu64 zmm13, [rsp+$01e0]
                vmovdqu64 zmm14, [rsp+$0220]
                vmovdqu64 zmm15, [rsp+$0260]
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_DOUBLE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8ScalDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$02a0]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu64 [rsp+$0020], zmm6
                vmovdqu64 [rsp+$0060], zmm7
                vmovdqu64 [rsp+$00a0], zmm8
                vmovdqu64 [rsp+$00e0], zmm9
                vmovdqu64 [rsp+$0120], zmm10
                vmovdqu64 [rsp+$0160], zmm11
                vmovdqu64 [rsp+$01a0], zmm12
                vmovdqu64 [rsp+$01e0], zmm13
                vmovdqu64 [rsp+$0220], zmm14
                vmovdqu64 [rsp+$0260], zmm15
                vmulpd  zmm1, zmm1, [double8_o0]
                vmulpd  zmm2, zmm1, zmm1, {rn-sae}
                vextractf64x2 xmm3, zmm2, $01
                vextractf64x2 xmm4, zmm2, $02
                vextractf64x2 xmm5, zmm2, $03
                vhaddpd xmm2, xmm2, xmm3
                vhaddpd xmm3, xmm4, xmm5
                vhaddpd xmm2, xmm2, xmm3
                vhaddpd xmm2, xmm2, xmm2
                vbroadcastsd zmm2, xmm2
                vdivpd  zmm1, zmm1, zmm2
                vshuff64x2 zmm8, zmm1, zmm1, $e4
                vshuff64x2 zmm10, zmm8, zmm8, $b1
                vshuff64x2 zmm12, zmm8, zmm8, $4e
                vshuff64x2 zmm14, zmm8, zmm8, $1b
                vshufpd zmm9, zmm8, zmm8, $55
                vshufpd zmm11, zmm10, zmm10, $55
                vshufpd zmm13, zmm12, zmm12, $55
                vshufpd zmm15, zmm14, zmm14, $55
                vmulpd  zmm8, zmm8, [double8_o0]
                vmulpd  zmm9, zmm9, [double8_o1]
                vmulpd  zmm10, zmm10, [double8_o2]
                vmulpd  zmm11, zmm11, [double8_o3]
                vmulpd  zmm12, zmm12, [double8_o4]
                vmulpd  zmm13, zmm13, [double8_o5]
                vmulpd  zmm14, zmm14, [double8_o6]
                vmulpd  zmm15, zmm15, [double8_o7]
                vmulpd  zmm7, zmm0, zmm15, {rn-sae}
                vmulpd  zmm6, zmm0, zmm14, {rn-sae}
                vmulpd  zmm5, zmm0, zmm13, {rn-sae}
                vmulpd  zmm4, zmm0, zmm12, {rn-sae}
                vmulpd  zmm3, zmm0, zmm11, {rn-sae}
                vmulpd  zmm2, zmm0, zmm10, {rn-sae}
                vmulpd  zmm1, zmm0, zmm9, {rn-sae}
                vmulpd  zmm0, zmm0, zmm8, {rn-sae}
                vextractf64x4 ymm8, zmm0, $01
                vextractf64x4 ymm9, zmm1, $01
                vextractf64x4 ymm10, zmm2, $01
                vextractf64x4 ymm11, zmm3, $01
                vextractf64x4 ymm12, zmm4, $01
                vextractf64x4 ymm13, zmm5, $01
                vextractf64x4 ymm14, zmm6, $01
                vextractf64x4 ymm15, zmm7, $01
                vinsertf64x4 zmm0, zmm0, ymm2, $01
                vinsertf64x4 zmm2, zmm4, ymm6, $01
                vinsertf64x4 zmm4, zmm1, ymm3, $01
                vinsertf64x4 zmm6, zmm5, ymm7, $01
                vinsertf64x4 zmm1, zmm8, ymm10, $01
                vinsertf64x4 zmm3, zmm12, ymm14, $01
                vinsertf64x4 zmm5, zmm9, ymm11, $01
                vinsertf64x4 zmm7, zmm13, ymm15, $01
                vaddpd  zmm0, zmm0, zmm1
                vaddpd  zmm1, zmm2, zmm3
                vaddpd  zmm2, zmm4, zmm5
                vaddpd  zmm3, zmm6, zmm7
                vshuff64x2 zmm4, zmm0, zmm1, $88
                vshuff64x2 zmm5, zmm0, zmm1, $dd
                vshuff64x2 zmm6, zmm2, zmm3, $88
                vshuff64x2 zmm7, zmm2, zmm3, $dd
                vaddpd  zmm0, zmm4, zmm5
                vaddpd  zmm1, zmm6, zmm7
                vshufpd zmm2, zmm0, zmm1, $00
                vshufpd zmm3, zmm0, zmm1, $ff
                vaddpd  zmm0, zmm2, zmm3
                vmovdqu64 zmm6, [rsp+$0020]
                vmovdqu64 zmm7, [rsp+$0060]
                vmovdqu64 zmm8, [rsp+$00a0]
                vmovdqu64 zmm9, [rsp+$00e0]
                vmovdqu64 zmm10, [rsp+$0120]
                vmovdqu64 zmm11, [rsp+$0160]
                vmovdqu64 zmm12, [rsp+$01a0]
                vmovdqu64 zmm13, [rsp+$01e0]
                vmovdqu64 zmm14, [rsp+$0220]
                vmovdqu64 zmm15, [rsp+$0260]
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_DOUBLE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8ScalDivu ; this, dst, op0, op1
                lea     rsp, [rsp-$02a0]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovdqu64 [rsp+$0020], zmm6
                vmovdqu64 [rsp+$0060], zmm7
                vmovdqu64 [rsp+$00a0], zmm8
                vmovdqu64 [rsp+$00e0], zmm9
                vmovdqu64 [rsp+$0120], zmm10
                vmovdqu64 [rsp+$0160], zmm11
                vmovdqu64 [rsp+$01a0], zmm12
                vmovdqu64 [rsp+$01e0], zmm13
                vmovdqu64 [rsp+$0220], zmm14
                vmovdqu64 [rsp+$0260], zmm15
                vmulpd  zmm1, zmm1, [double8_o0]
                vmulpd  zmm2, zmm1, zmm1, {rn-sae}
                vextractf64x2 xmm3, zmm2, $01
                vextractf64x2 xmm4, zmm2, $02
                vextractf64x2 xmm5, zmm2, $03
                vhaddpd xmm2, xmm2, xmm3
                vhaddpd xmm3, xmm4, xmm5
                vhaddpd xmm2, xmm2, xmm3
                vhaddpd xmm2, xmm2, xmm2
                vbroadcastsd zmm2, xmm2
                vdivpd  zmm1, zmm1, zmm2
                vmovapd zmm2, zmm1
                vmovapd zmm1, zmm0
                vmovapd zmm0, zmm2
                vshuff64x2 zmm8, zmm1, zmm1, $e4
                vshuff64x2 zmm10, zmm8, zmm8, $b1
                vshuff64x2 zmm12, zmm8, zmm8, $4e
                vshuff64x2 zmm14, zmm8, zmm8, $1b
                vshufpd zmm9, zmm8, zmm8, $55
                vshufpd zmm11, zmm10, zmm10, $55
                vshufpd zmm13, zmm12, zmm12, $55
                vshufpd zmm15, zmm14, zmm14, $55
                vmulpd  zmm8, zmm8, [double8_o0]
                vmulpd  zmm9, zmm9, [double8_o1]
                vmulpd  zmm10, zmm10, [double8_o2]
                vmulpd  zmm11, zmm11, [double8_o3]
                vmulpd  zmm12, zmm12, [double8_o4]
                vmulpd  zmm13, zmm13, [double8_o5]
                vmulpd  zmm14, zmm14, [double8_o6]
                vmulpd  zmm15, zmm15, [double8_o7]
                vmulpd  zmm7, zmm0, zmm15, {rn-sae}
                vmulpd  zmm6, zmm0, zmm14, {rn-sae}
                vmulpd  zmm5, zmm0, zmm13, {rn-sae}
                vmulpd  zmm4, zmm0, zmm12, {rn-sae}
                vmulpd  zmm3, zmm0, zmm11, {rn-sae}
                vmulpd  zmm2, zmm0, zmm10, {rn-sae}
                vmulpd  zmm1, zmm0, zmm9, {rn-sae}
                vmulpd  zmm0, zmm0, zmm8, {rn-sae}
                vextractf64x4 ymm8, zmm0, $01
                vextractf64x4 ymm9, zmm1, $01
                vextractf64x4 ymm10, zmm2, $01
                vextractf64x4 ymm11, zmm3, $01
                vextractf64x4 ymm12, zmm4, $01
                vextractf64x4 ymm13, zmm5, $01
                vextractf64x4 ymm14, zmm6, $01
                vextractf64x4 ymm15, zmm7, $01
                vinsertf64x4 zmm0, zmm0, ymm2, $01
                vinsertf64x4 zmm2, zmm4, ymm6, $01
                vinsertf64x4 zmm4, zmm1, ymm3, $01
                vinsertf64x4 zmm6, zmm5, ymm7, $01
                vinsertf64x4 zmm1, zmm8, ymm10, $01
                vinsertf64x4 zmm3, zmm12, ymm14, $01
                vinsertf64x4 zmm5, zmm9, ymm11, $01
                vinsertf64x4 zmm7, zmm13, ymm15, $01
                vaddpd  zmm0, zmm0, zmm1
                vaddpd  zmm1, zmm2, zmm3
                vaddpd  zmm2, zmm4, zmm5
                vaddpd  zmm3, zmm6, zmm7
                vshuff64x2 zmm4, zmm0, zmm1, $88
                vshuff64x2 zmm5, zmm0, zmm1, $dd
                vshuff64x2 zmm6, zmm2, zmm3, $88
                vshuff64x2 zmm7, zmm2, zmm3, $dd
                vaddpd  zmm0, zmm4, zmm5
                vaddpd  zmm1, zmm6, zmm7
                vshufpd zmm2, zmm0, zmm1, $00
                vshufpd zmm3, zmm0, zmm1, $ff
                vaddpd  zmm0, zmm2, zmm3
                vmovdqu64 zmm6, [rsp+$0020]
                vmovdqu64 zmm7, [rsp+$0060]
                vmovdqu64 zmm8, [rsp+$00a0]
                vmovdqu64 zmm9, [rsp+$00e0]
                vmovdqu64 zmm10, [rsp+$0120]
                vmovdqu64 zmm11, [rsp+$0160]
                vmovdqu64 zmm12, [rsp+$01a0]
                vmovdqu64 zmm13, [rsp+$01e0]
                vmovdqu64 zmm14, [rsp+$0220]
                vmovdqu64 zmm15, [rsp+$0260]
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_DOUBLE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8ScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddpd  zmm0, zmm0, zmm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_DOUBLE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8ScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubpd  zmm0, zmm0, zmm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_DOUBLE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8ScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  k0, zmm0, zmm1, $00
                kmovw   r0d, k0
                cmp     r0d, $ff
                sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8ScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  k0, zmm0, zmm1, $00
                kmovw   r0d, k0
                cmp     r0d, $ff
                setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8VectPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_DOUBLE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8VectMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpxorq  zmm1, zmm0, zmm0
                vsubpd  zmm0, zmm1, zmm0
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_DOUBLE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8VectMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmulpd  zmm0, zmm0, zmm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_DOUBLE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8VectDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vdivpd  zmm0, zmm0, zmm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_DOUBLE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8VectAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vaddpd  zmm0, zmm0, zmm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_DOUBLE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8VectSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vsubpd  zmm0, zmm0, zmm1
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_DOUBLE8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8VectG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  k1, zmm1, zmm0, $01
                vmovdqu64 zmm0{k1}{z}, [long8_00]
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8VectGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  k1, zmm1, zmm0, $02
                vmovdqu64 zmm0{k1}{z}, [long8_00]
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8VectL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  k1, zmm0, zmm1, $01
                vmovdqu64 zmm0{k1}{z}, [long8_00]
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8VectLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  k1, zmm0, zmm1, $02
                vmovdqu64 zmm0{k1}{z}, [long8_00]
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8VectE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  k1, zmm0, zmm1, $00
                vmovdqu64 zmm0{k1}{z}, [long8_00]
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc double8VectNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                vmovupd zmm1, [r9+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcmppd  k1, zmm0, zmm1, $04
                vmovdqu64 zmm0{k1}{z}, [long8_00]
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, AVT_LONG8
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   REAL                                                                                      ;
    ; =========================================================================================== ;

                align   $08
    proc realScalPlus ; this, dst, op0
                lea     rsp, [rsp-$20]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ; запись результата ;
                fstp    tbyte[r2+AVTConstant.asPrimitiveValueOffset]
                mov     r8d, AVT_REAL
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc realScalMinus ; this, dst, op0
                lea     rsp, [rsp-$20]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                fchs
                ; запись результата ;
                fstp    tbyte[r2+AVTConstant.asPrimitiveValueOffset]
                mov     r8d, AVT_REAL
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc realScalMul ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                fld     tbyte[r9+AVTConstant.asPrimitiveValueOffset]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                fmulp   st1, st0
                ; запись результата ;
                fstp    tbyte[r2+AVTConstant.asPrimitiveValueOffset]
                mov     r8d, AVT_REAL
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc realScalDiv ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                fld     tbyte[r9+AVTConstant.asPrimitiveValueOffset]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                fdivrp  st1, st0
                ; запись результата ;
                fstp    tbyte[r2+AVTConstant.asPrimitiveValueOffset]
                mov     r8d, AVT_REAL
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc realScalDivu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                fld     tbyte[r9+AVTConstant.asPrimitiveValueOffset]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                fdivrp  st1, st0
                ; запись результата ;
                fstp    tbyte[r2+AVTConstant.asPrimitiveValueOffset]
                mov     r8d, AVT_REAL
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc realScalRem ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                fld     tbyte[r9+AVTConstant.asPrimitiveValueOffset]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
        @@:     fprem
                fnstsw  r0w
                test    r0w, $0400
                jnz     @B
                fstp    st1
                ; запись результата ;
                fstp    tbyte[r2+AVTConstant.asPrimitiveValueOffset]
                mov     r8d, AVT_REAL
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc realScalRemu ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                fld     tbyte[r9+AVTConstant.asPrimitiveValueOffset]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
        @@:     fprem
                fnstsw  r0w
                test    r0w, $0400
                jnz     @B
                fstp    st1
                ; запись результата ;
                fstp    tbyte[r2+AVTConstant.asPrimitiveValueOffset]
                mov     r8d, AVT_REAL
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc realScalAdd ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                fld     tbyte[r9+AVTConstant.asPrimitiveValueOffset]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                faddp   st1, st0
                ; запись результата ;
                fstp    tbyte[r2+AVTConstant.asPrimitiveValueOffset]
                mov     r8d, AVT_REAL
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc realScalSub ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                fld     tbyte[r9+AVTConstant.asPrimitiveValueOffset]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                fsubrp  st1, st0
                ; запись результата ;
                fstp    tbyte[r2+AVTConstant.asPrimitiveValueOffset]
                mov     r8d, AVT_REAL
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc realScalG ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                fld     tbyte[r9+AVTConstant.asPrimitiveValueOffset]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                fcomip  st0, st1
                ffree   st0
                fincstp
                jnp     @F
                mov     r0b, $ba
                or      r0d, r0d
                stc
        @@:     seta    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc realScalGE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                fld     tbyte[r9+AVTConstant.asPrimitiveValueOffset]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                fcomip  st0, st1
                ffree   st0
                fincstp
                jnp     @F
                mov     r0b, $ba
                or      r0d, r0d
                stc
        @@:     setae   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc realScalL ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                fld     tbyte[r9+AVTConstant.asPrimitiveValueOffset]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                fcomip  st0, st1
                ffree   st0
                fincstp
                jnp     @F
                mov     r0b, $ba
                or      r0d, r0d
        @@:     setb    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc realScalLE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                fld     tbyte[r9+AVTConstant.asPrimitiveValueOffset]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                fcomip  st0, st1
                ffree   st0
                fincstp
                jnp     @F
                mov     r0b, $ba
                or      r0d, r0d
        @@:     setbe   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc realScalE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                fld     tbyte[r9+AVTConstant.asPrimitiveValueOffset]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                fcomip  st0, st1
                ffree   st0
                fincstp
                jnp     @F
                mov     r0b, $ba
                or      r0d, r0d
                stc
        @@:     sete    r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc realScalNE ; this, dst, op0, op1
                lea     rsp, [rsp-$20]
                fld     tbyte[r9+AVTConstant.asPrimitiveValueOffset]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                fcomip  st0, st1
                ffree   st0
                fincstp
                jnp     @F
                mov     r0b, $ba
                or      r0d, r0d
                stc
        @@:     setne   r0b
                ; запись результата ;
                mov     [r2+AVTConstant.asPrimitiveValueOffset], r0b
                mov     r8d, AVT_BOOLEAN
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   CAST                                                                                      ;
    ; =========================================================================================== ;

                align   $08
    proc castByte8ToShort8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovsxbw xmm0, xmm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castByte8ToInt8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovsxbd ymm0, xmm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castByte8ToLong8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovsxbq zmm0, xmm0
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castByte8ToFloat8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovsxbd ymm0, xmm0
                vcvtdq2ps ymm0, ymm0
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castByte8ToDouble8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovsxbd ymm0, xmm0
                vcvtdq2pd zmm0, ymm0
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castByte8ToReal ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovq   xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   r0d, xmm0
                movsx   r0d, r0b
                mov     [rsp], r0d
                fild    dword[rsp]
                ; запись результата ;
                fstp    tbyte[r2+AVTConstant.asPrimitiveValueOffset]
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castShort8ToByte8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpand   xmm0, xmm0, [short8_01]
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castShort8ToInt8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovsxwd ymm0, xmm0
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castShort8ToLong8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovsxwq zmm0, xmm0
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castShort8ToFloat8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovsxwd ymm0, xmm0
                vcvtdq2ps ymm0, ymm0
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castShort8ToDouble8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovsxwd ymm0, xmm0
                vcvtdq2pd zmm0, ymm0
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castShort8ToReal ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu xmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   r0d, xmm0
                movsx   r0d, r0w
                mov     [rsp], r0d
                fild    dword[rsp]
                ; запись результата ;
                fstp    tbyte[r2+AVTConstant.asPrimitiveValueOffset]
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castInt8ToByte8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpand   ymm0, ymm0, [int8_03]
                vextracti128 xmm1, ymm0, $01
                vpackusdw xmm0, xmm0, xmm1
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castInt8ToShort8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpand   ymm0, ymm0, [int8_01]
                vextracti128 xmm1, ymm0, $01
                vpackusdw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castInt8ToLong8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpmovsxdq zmm0, ymm0
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castInt8ToFloat8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcvtdq2ps ymm0, ymm0
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castInt8ToDouble8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcvtdq2pd zmm0, ymm0
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castInt8ToReal ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovd   [rsp], xmm0
                fild    dword[rsp]
                ; запись результата ;
                fstp    tbyte[r2+AVTConstant.asPrimitiveValueOffset]
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castLong8ToByte8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpandq  zmm0, zmm0, [long8_03]
                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, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castLong8ToShort8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpandq  zmm0, zmm0, [long8_02]
                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 [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castLong8ToInt8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vpandq  zmm0, zmm0, [long8_01]
                vshufps zmm0, zmm0, zmm0, $d8
                vshufi64x2 zmm0, zmm0, zmm0, $d8
                vextracti64x4 ymm1, zmm0, $01
                vpslldq ymm1, ymm1, $08
                vpor    ymm0, ymm0, ymm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castLong8ToFloat8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcvtqq2ps ymm0, zmm0
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castLong8ToDouble8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcvtqq2pd zmm0, zmm0
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castLong8ToReal ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovdqu64 zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovq   [rsp], xmm0
                fild    qword[rsp]
                ; запись результата ;
                fstp    tbyte[r2+AVTConstant.asPrimitiveValueOffset]
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castFloat8ToByte8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovaps ymm3, [float8_00]
                vcvttps2dq ymm1, ymm0
                vcmpps  ymm2, ymm0, ymm0, $07
                vcmpps  ymm3, ymm3, ymm0, $02
                vpaddd  ymm0, ymm1, ymm3
                vpand   ymm0, ymm0, ymm2
                vpand   ymm0, ymm0, [int8_03]
                vextracti128 xmm1, ymm0, $01
                vpackusdw xmm0, xmm0, xmm1
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castFloat8ToShort8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovaps ymm3, [float8_00]
                vcvttps2dq ymm1, ymm0
                vcmpps  ymm2, ymm0, ymm0, $07
                vcmpps  ymm3, ymm3, ymm0, $02
                vpaddd  ymm0, ymm1, ymm3
                vpand   ymm0, ymm0, ymm2
                vpand   ymm0, ymm0, [int8_01]
                vextracti128 xmm1, ymm0, $01
                vpackusdw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castFloat8ToInt8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovaps ymm3, [float8_00]
                vcvttps2dq ymm1, ymm0
                vcmpps  ymm2, ymm0, ymm0, $07
                vcmpps  ymm3, ymm3, ymm0, $02
                vpaddd  ymm0, ymm1, ymm3
                vpand   ymm0, ymm0, ymm2
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castFloat8ToLong8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovapd zmm3, [double8_01]
                vcvtps2pd zmm0, ymm0
                vcvttpd2qq zmm1, zmm0
                vcmppd  k1, zmm0, zmm0, $07
                vcmppd  k2, zmm3, zmm0, $02
                vmovdqa64 zmm2{k1}{z}, [long8_00]
                vmovdqa64 zmm3{k2}{z}, [long8_00]
                vpaddq  zmm0, zmm1, zmm3
                vpandq  zmm0, zmm0, zmm2
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castFloat8ToDouble8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcvtps2pd zmm0, ymm0
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castFloat8ToReal ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovups ymm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovss  [rsp], xmm0
                fld     dword[rsp]
                ; запись результата ;
                fstp    tbyte[r2+AVTConstant.asPrimitiveValueOffset]
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castDouble8ToByte8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovapd zmm3, [double8_00]
                vcvttpd2dq ymm1, zmm0
                vcmppd  k1, zmm0, zmm0, $07
                vcmppd  k2, zmm3, zmm0, $02
                vmovdqa32 ymm2{k1}{z}, [int8_00]
                vmovdqa32 ymm3{k2}{z}, [int8_00]
                vpaddd  ymm0, ymm1, ymm3
                vpand   ymm0, ymm0, ymm2
                vpand   ymm0, ymm0, [int8_03]
                vextracti128 xmm1, ymm0, $01
                vpackusdw xmm0, xmm0, xmm1
                vpackuswb xmm0, xmm0, xmm0
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castDouble8ToShort8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovapd zmm3, [double8_00]
                vcvttpd2dq ymm1, zmm0
                vcmppd  k1, zmm0, zmm0, $07
                vcmppd  k2, zmm3, zmm0, $02
                vmovdqa32 ymm2{k1}{z}, [int8_00]
                vmovdqa32 ymm3{k2}{z}, [int8_00]
                vpaddd  ymm0, ymm1, ymm3
                vpand   ymm0, ymm0, ymm2
                vpand   ymm0, ymm0, [int8_01]
                vextracti128 xmm1, ymm0, $01
                vpackusdw xmm0, xmm0, xmm1
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castDouble8ToInt8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovapd zmm3, [double8_00]
                vcvttpd2dq ymm1, zmm0
                vcmppd  k1, zmm0, zmm0, $07
                vcmppd  k2, zmm3, zmm0, $02
                vmovdqa32 ymm2{k1}{z}, [int8_00]
                vmovdqa32 ymm3{k2}{z}, [int8_00]
                vpaddd  ymm0, ymm1, ymm3
                vpand   ymm0, ymm0, ymm2
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castDouble8ToLong8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovapd zmm3, [double8_01]
                vcvttpd2qq zmm1, zmm0
                vcmppd  k1, zmm0, zmm0, $07
                vcmppd  k2, zmm3, zmm0, $02
                vmovdqa64 zmm2{k1}{z}, [long8_00]
                vmovdqa64 zmm3{k2}{z}, [long8_00]
                vpaddq  zmm0, zmm1, zmm3
                vpandq  zmm0, zmm0, zmm2
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castDouble8ToFloat8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vcvtpd2ps ymm0, zmm0
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castDouble8ToReal ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                vmovupd zmm0, [r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                vmovq   [rsp], xmm0
                fld     qword[rsp]
                ; запись результата ;
                fstp    tbyte[r2+AVTConstant.asPrimitiveValueOffset]
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castRealToByte8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ficom   dword[int_00]
                fnstsw  r0w
                shr     r0d, $08
                pushfq
                mov     [rsp], r0b
                popfq
                jnp     @F
                ffree   st0
                fincstp
                xor     r0d, r0d
                jmp     .L0
        @@:     jbe     @F
                ffree   st0
                fincstp
                mov     r0d, [int_00]
                jmp     .L0
        @@:     fisttp  dword[rsp]
                mov     r0d, [rsp]
        .L0:    and     r0d, $000000ff
                vmovd   xmm0, r0d
                ; запись результата ;
                vmovq   [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castRealToShort8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ficom   dword[int_00]
                fnstsw  r0w
                shr     r0d, $08
                pushfq
                mov     [rsp], r0b
                popfq
                jnp     @F
                ffree   st0
                fincstp
                xor     r0d, r0d
                jmp     .L0
        @@:     jbe     @F
                ffree   st0
                fincstp
                mov     r0d, [int_00]
                jmp     .L0
        @@:     fisttp  dword[rsp]
                mov     r0d, [rsp]
        .L0:    and     r0d, $0000ffff
                vmovd   xmm0, r0d
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], xmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castRealToInt8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                ficom   dword[int_00]
                fnstsw  r0w
                shr     r0d, $08
                pushfq
                mov     [rsp], r0b
                popfq
                jnp     @F
                ffree   st0
                fincstp
                xor     r0d, r0d
                jmp     .L0
        @@:     jbe     @F
                ffree   st0
                fincstp
                mov     r0d, [int_00]
                jmp     .L0
        @@:     fisttp  dword[rsp]
                mov     r0d, [rsp]
        .L0:    vmovd   xmm0, r0d
                ; запись результата ;
                vmovdqu [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castRealToLong8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                fild    qword[long_02]
                fcomp
                fnstsw  r0w
                shr     r0d, $08
                pushfq
                mov     [rsp], r0b
                popfq
                jnp     @F
                ffree   st0
                fincstp
                xor     r0, r0
                jmp     .L0
        @@:     ja      @F
                ffree   st0
                fincstp
                mov     r0, [long_02]
                jmp     .L0
        @@:     fisttp  qword[rsp]
                mov     r0, [rsp]
        .L0:    vmovq   xmm0, r0
                ; запись результата ;
                vmovdqu64 [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castRealToFloat8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                fstp    dword[rsp]
                mov     r0d, [rsp]
                vmovd   xmm0, r0d
                ; запись результата ;
                vmovups [r2+AVTConstant.asPrimitiveValueOffset], ymm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

                align   $08
    proc castRealToDouble8 ; this, dst, op0, kind
                lea     rsp, [rsp-$20]
                fld     tbyte[r8+AVTConstant.asPrimitiveValueOffset]
                ; выполнение операции ;
                fstp    qword[rsp]
                mov     r0, [rsp]
                vmovq   xmm0, r0
                ; запись результата ;
                vmovupd [r2+AVTConstant.asPrimitiveValueOffset], zmm0
                mov     r8d, r9d
                call    [setPrimitive]
                ret
    endp

    ; =========================================================================================== ;
    ;   END                                                                                       ;
    ; =========================================================================================== ;

section ".data" data readable writeable

    setPrimitive\
                dq      0

section ".rsrc" resource data readable

                directory \
                        RT_VERSION, versions

                resource versions, \
                        1, LANG_NEUTRAL, version

                versioninfoex version, VOS__WINDOWS32, VFT_APP, VFT2_UNKNOWN, LANG_RUSSIAN+SUBLANG_DEFAULT, 0, \
                        "OriginalFilename", "avtops.dll", \
                        "FileDescription", \
                        $0420, $0435, $0430, $043b, $0438, $0437, $0430, $0446, $0438, $044f, $0020, $043e, $043f, $0435, $0440, $0430, \
                        $0446, $0438, $0439, $0020, $041f, $0412, $0422, $002d, $041e, $041e, \ ; Реализация операций ПВТ-ОО
                        "FileVersion", "0.4", \
                        "ProductName", \
                        $041f, $0440, $043e, $0434, $0432, $0438, $043d, $0443, $0442, $044b, $0439, $0020, $0432, $0435, $043a, $0442, \
                        $043e, $0440, $043d, $044b, $0439, $0020, $0442, $0440, $0430, $043d, $0441, $043b, $044f, $0442, $043e, $0440, \
                        $0020, $0028, $043e, $0431, $044a, $0435, $043a, $0442, $043d, $043e, $002d, $043e, $0440, $0438, $0435, $043d, \
                        $0442, $0438, $0440, $043e, $0432, $0430, $043d, $043d, $044b, $0439, $0029, \ ; Продвинутый векторный транслятор (объектно-ориентированный)
                        "ProductVersion", "0.4", \
                        "LegalCopyright", \
                        $0043, $006f, $0070, $0079, $0072, $0069, $0067, $0068, $0074, $0020, $00a9, $0020, $0032, $0030, $0032, $0031, \
                        $0020, $041c, $0430, $043b, $0438, $043a, $0020, $0420, $0430, $0437, $0440, $0430, $0431, $043e, $0442, $0447, \
                        $0438, $043a    ; Copyright © 2021 Малик Разработчик

section ".rdata" data readable

                align   $10
    int2_c0:    dd      1, -1,  0,  0
                align   $10
    int4_q0:    dd      1, -1, -1, -1
    int4_q1:    dd      1,  1,  1, -1
    int4_q2:    dd      1, -1,  1,  1
    int4_q3:    dd      1,  1, -1,  1
                align   $20
    int8_o0:    dd      1, -1, -1, -1, -1, -1, -1, -1
    int8_o1:    dd      1,  1,  1, -1,  1, -1, -1,  1
    int8_o2:    dd      1, -1,  1,  1,  1,  1, -1, -1
    int8_o3:    dd      1,  1, -1,  1,  1, -1,  1, -1
    int8_o4:    dd      1, -1, -1, -1,  1,  1,  1,  1
    int8_o5:    dd      1,  1, -1,  1, -1,  1, -1,  1
    int8_o6:    dd      1,  1,  1, -1, -1,  1,  1, -1
    int8_o7:    dd      1, -1,  1,  1, -1, -1,  1,  1
                align   $10
    long2_c0:   dq      1, -1
                align   $20
    long4_q0:   dq      1, -1, -1, -1
    long4_q1:   dq      1,  1,  1, -1
    long4_q2:   dq      1, -1,  1,  1
    long4_q3:   dq      1,  1, -1,  1
                align   $40
    long8_o0:   dq      1, -1, -1, -1, -1, -1, -1, -1
    long8_o1:   dq      1,  1,  1, -1,  1, -1, -1,  1
    long8_o2:   dq      1, -1,  1,  1,  1,  1, -1, -1
    long8_o3:   dq      1,  1, -1,  1,  1, -1,  1, -1
    long8_o4:   dq      1, -1, -1, -1,  1,  1,  1,  1
    long8_o5:   dq      1,  1, -1,  1, -1,  1, -1,  1
    long8_o6:   dq      1,  1,  1, -1, -1,  1,  1, -1
    long8_o7:   dq      1, -1,  1,  1, -1, -1,  1,  1
                align   $10
    float2_c0:  dd      $3f800000, $bf800000, 0, 0
                align   $10
    float4_q0:  dd      $3f800000, $bf800000, $bf800000, $bf800000
    float4_q1:  dd      $3f800000, $3f800000, $3f800000, $bf800000
    float4_q2:  dd      $3f800000, $bf800000, $3f800000, $3f800000
    float4_q3:  dd      $3f800000, $3f800000, $bf800000, $3f800000
                align   $20
    float8_o0:  dd      $3f800000, $bf800000, $bf800000, $bf800000, $bf800000, $bf800000, $bf800000, $bf800000
    float8_o1:  dd      $3f800000, $3f800000, $3f800000, $bf800000, $3f800000, $bf800000, $bf800000, $3f800000
    float8_o2:  dd      $3f800000, $bf800000, $3f800000, $3f800000, $3f800000, $3f800000, $bf800000, $bf800000
    float8_o3:  dd      $3f800000, $3f800000, $bf800000, $3f800000, $3f800000, $bf800000, $3f800000, $bf800000
    float8_o4:  dd      $3f800000, $bf800000, $bf800000, $bf800000, $3f800000, $3f800000, $3f800000, $3f800000
    float8_o5:  dd      $3f800000, $3f800000, $bf800000, $3f800000, $bf800000, $3f800000, $bf800000, $3f800000
    float8_o6:  dd      $3f800000, $3f800000, $3f800000, $bf800000, $bf800000, $3f800000, $3f800000, $bf800000
    float8_o7:  dd      $3f800000, $bf800000, $3f800000, $3f800000, $bf800000, $bf800000, $3f800000, $3f800000
                align   $10
    double2_c0: dq      $3ff0000000000000, $bff0000000000000
                align   $20
    double4_q0: dq      $3ff0000000000000, $bff0000000000000, $bff0000000000000, $bff0000000000000
    double4_q1: dq      $3ff0000000000000, $3ff0000000000000, $3ff0000000000000, $bff0000000000000
    double4_q2: dq      $3ff0000000000000, $bff0000000000000, $3ff0000000000000, $3ff0000000000000
    double4_q3: dq      $3ff0000000000000, $3ff0000000000000, $bff0000000000000, $3ff0000000000000
                align   $40
    double8_o0: dq      $3ff0000000000000, $bff0000000000000, $bff0000000000000, $bff0000000000000, $bff0000000000000, $bff0000000000000, $bff0000000000000, $bff0000000000000
    double8_o1: dq      $3ff0000000000000, $3ff0000000000000, $3ff0000000000000, $bff0000000000000, $3ff0000000000000, $bff0000000000000, $bff0000000000000, $3ff0000000000000
    double8_o2: dq      $3ff0000000000000, $bff0000000000000, $3ff0000000000000, $3ff0000000000000, $3ff0000000000000, $3ff0000000000000, $bff0000000000000, $bff0000000000000
    double8_o3: dq      $3ff0000000000000, $3ff0000000000000, $bff0000000000000, $3ff0000000000000, $3ff0000000000000, $bff0000000000000, $3ff0000000000000, $bff0000000000000
    double8_o4: dq      $3ff0000000000000, $bff0000000000000, $bff0000000000000, $bff0000000000000, $3ff0000000000000, $3ff0000000000000, $3ff0000000000000, $3ff0000000000000
    double8_o5: dq      $3ff0000000000000, $3ff0000000000000, $bff0000000000000, $3ff0000000000000, $bff0000000000000, $3ff0000000000000, $bff0000000000000, $3ff0000000000000
    double8_o6: dq      $3ff0000000000000, $3ff0000000000000, $3ff0000000000000, $bff0000000000000, $bff0000000000000, $3ff0000000000000, $3ff0000000000000, $bff0000000000000
    double8_o7: dq      $3ff0000000000000, $bff0000000000000, $3ff0000000000000, $3ff0000000000000, $bff0000000000000, $bff0000000000000, $3ff0000000000000, $3ff0000000000000
                align   $10
    short8_00:  dw      $ffff, $ffff, $ffff, $ffff, $ffff, $ffff, $ffff, $ffff
    short8_01:  dw      $00ff, $00ff, $00ff, $00ff, $00ff, $00ff, $00ff, $00ff
    short8_02:  dw      $007f, $007f, $007f, $007f, $007f, $007f, $007f, $007f
                align   $10
    int_00:     dd      $7fffffff
                align   $10
    int4_00:    dd      $ffffffff, $ffffffff, $ffffffff, $ffffffff
    int4_01:    dd      $0000ffff, $0000ffff, $0000ffff, $0000ffff
    int4_02:    dd      $00007fff, $00007fff, $00007fff, $00007fff
                align   $20
    int8_00:    dd      $ffffffff, $ffffffff, $ffffffff, $ffffffff, $ffffffff, $ffffffff, $ffffffff, $ffffffff
    int8_01:    dd      $0000ffff, $0000ffff, $0000ffff, $0000ffff, $0000ffff, $0000ffff, $0000ffff, $0000ffff
    int8_02:    dd      $00007fff, $00007fff, $00007fff, $00007fff, $00007fff, $00007fff, $00007fff, $00007fff
    int8_03:    dd      $000000ff, $000000ff, $000000ff, $000000ff, $000000ff, $000000ff, $000000ff, $000000ff
                align   $10
    long_00:    dq      $ffffffffffffffff
    long_01:    dq      $8000000000000000
    long_02:    dq      $7fffffffffffffff
                align   $40
    long8_00:   dq      $ffffffffffffffff, $ffffffffffffffff, $ffffffffffffffff, $ffffffffffffffff, $ffffffffffffffff, $ffffffffffffffff, $ffffffffffffffff, $ffffffffffffffff
    long8_01:   dq      $00000000ffffffff, $00000000ffffffff, $00000000ffffffff, $00000000ffffffff, $00000000ffffffff, $00000000ffffffff, $00000000ffffffff, $00000000ffffffff
    long8_02:   dq      $000000000000ffff, $000000000000ffff, $000000000000ffff, $000000000000ffff, $000000000000ffff, $000000000000ffff, $000000000000ffff, $000000000000ffff
    long8_03:   dq      $00000000000000ff, $00000000000000ff, $00000000000000ff, $00000000000000ff, $00000000000000ff, $00000000000000ff, $00000000000000ff, $00000000000000ff
                align   $20
    float8_00:  dd      $4f000000, $4f000000, $4f000000, $4f000000, $4f000000, $4f000000, $4f000000, $4f000000
                align   $40
    double8_00: dq      $41e0000000000000, $41e0000000000000, $41e0000000000000, $41e0000000000000, $41e0000000000000, $41e0000000000000, $41e0000000000000, $41e0000000000000
    double8_01: dq      $43e0000000000000, $43e0000000000000, $43e0000000000000, $43e0000000000000, $43e0000000000000, $43e0000000000000, $43e0000000000000, $43e0000000000000

section ".edata" export data readable

                export  "AVTOPS.DLL",\
                        byteScalPlus, "byteScalPlus",\
                        byteScalMinus, "byteScalMinus",\
                        byteScalMul, "byteScalMul",\
                        byteScalDiv, "byteScalDiv",\
                        byteScalDivu, "byteScalDivu",\
                        byteScalRem, "byteScalRem",\
                        byteScalRemu, "byteScalRemu",\
                        byteScalAdd, "byteScalAdd",\
                        byteScalSub, "byteScalSub",\
                        byteScalSar, "byteScalSar",\
                        byteScalSal, "byteScalSal",\
                        byteScalShr, "byteScalShr",\
                        byteScalG, "byteScalG",\
                        byteScalGE, "byteScalGE",\
                        byteScalL, "byteScalL",\
                        byteScalLE, "byteScalLE",\
                        byteScalE, "byteScalE",\
                        byteScalNE, "byteScalNE",\
                        byteBitNot, "byteBitNot",\
                        byteBitAnd, "byteBitAnd",\
                        byteBitOr, "byteBitOr",\
                        byteBitXor, "byteBitXor",\
                        byteVectUnpckl, "byteVectUnpckl",\
                        byteVectUnpcku, "byteVectUnpcku",\
                        byteVectPlus, "byteVectPlus",\
                        byteVectMinus, "byteVectMinus",\
                        byteVectMul, "byteVectMul",\
                        byteVectAdd, "byteVectAdd",\
                        byteVectSub, "byteVectSub",\
                        byteVectSar, "byteVectSar",\
                        byteVectSal, "byteVectSal",\
                        byteVectShr, "byteVectShr",\
                        byteVectG, "byteVectG",\
                        byteVectGE, "byteVectGE",\
                        byteVectL, "byteVectL",\
                        byteVectLE, "byteVectLE",\
                        byteVectE, "byteVectE",\
                        byteVectNE, "byteVectNE",\
                        byteVectMuls, "byteVectMuls",\
                        byteVectAdds, "byteVectAdds",\
                        byteVectSubs, "byteVectSubs",\
                        byteVectMulu, "byteVectMulu",\
                        byteVectAddu, "byteVectAddu",\
                        byteVectSubu, "byteVectSubu",\
                        byte2ScalPlus, "byte2ScalPlus",\
                        byte2ScalMinus, "byte2ScalMinus",\
                        byte2ScalMul, "byte2ScalMul",\
                        byte2ScalAdd, "byte2ScalAdd",\
                        byte2ScalSub, "byte2ScalSub",\
                        byte2ScalSar, "byte2ScalSar",\
                        byte2ScalSal, "byte2ScalSal",\
                        byte2ScalShr, "byte2ScalShr",\
                        byte2ScalE, "byte2ScalE",\
                        byte2ScalNE, "byte2ScalNE",\
                        byte2BitNot, "byte2BitNot",\
                        byte2BitAnd, "byte2BitAnd",\
                        byte2BitOr, "byte2BitOr",\
                        byte2BitXor, "byte2BitXor",\
                        byte2VectUnpckl, "byte2VectUnpckl",\
                        byte2VectUnpcku, "byte2VectUnpcku",\
                        byte2VectPlus, "byte2VectPlus",\
                        byte2VectMinus, "byte2VectMinus",\
                        byte2VectMul, "byte2VectMul",\
                        byte2VectAdd, "byte2VectAdd",\
                        byte2VectSub, "byte2VectSub",\
                        byte2VectSar, "byte2VectSar",\
                        byte2VectSal, "byte2VectSal",\
                        byte2VectShr, "byte2VectShr",\
                        byte2VectG, "byte2VectG",\
                        byte2VectGE, "byte2VectGE",\
                        byte2VectL, "byte2VectL",\
                        byte2VectLE, "byte2VectLE",\
                        byte2VectE, "byte2VectE",\
                        byte2VectNE, "byte2VectNE",\
                        byte2VectMuls, "byte2VectMuls",\
                        byte2VectAdds, "byte2VectAdds",\
                        byte2VectSubs, "byte2VectSubs",\
                        byte2VectMulu, "byte2VectMulu",\
                        byte2VectAddu, "byte2VectAddu",\
                        byte2VectSubu, "byte2VectSubu",\
                        byte4ScalPlus, "byte4ScalPlus",\
                        byte4ScalMinus, "byte4ScalMinus",\
                        byte4ScalMul, "byte4ScalMul",\
                        byte4ScalAdd, "byte4ScalAdd",\
                        byte4ScalSub, "byte4ScalSub",\
                        byte4ScalSar, "byte4ScalSar",\
                        byte4ScalSal, "byte4ScalSal",\
                        byte4ScalShr, "byte4ScalShr",\
                        byte4ScalE, "byte4ScalE",\
                        byte4ScalNE, "byte4ScalNE",\
                        byte4BitNot, "byte4BitNot",\
                        byte4BitAnd, "byte4BitAnd",\
                        byte4BitOr, "byte4BitOr",\
                        byte4BitXor, "byte4BitXor",\
                        byte4VectUnpckl, "byte4VectUnpckl",\
                        byte4VectUnpcku, "byte4VectUnpcku",\
                        byte4VectPlus, "byte4VectPlus",\
                        byte4VectMinus, "byte4VectMinus",\
                        byte4VectMul, "byte4VectMul",\
                        byte4VectAdd, "byte4VectAdd",\
                        byte4VectSub, "byte4VectSub",\
                        byte4VectSar, "byte4VectSar",\
                        byte4VectSal, "byte4VectSal",\
                        byte4VectShr, "byte4VectShr",\
                        byte4VectG, "byte4VectG",\
                        byte4VectGE, "byte4VectGE",\
                        byte4VectL, "byte4VectL",\
                        byte4VectLE, "byte4VectLE",\
                        byte4VectE, "byte4VectE",\
                        byte4VectNE, "byte4VectNE",\
                        byte4VectMuls, "byte4VectMuls",\
                        byte4VectAdds, "byte4VectAdds",\
                        byte4VectSubs, "byte4VectSubs",\
                        byte4VectMulu, "byte4VectMulu",\
                        byte4VectAddu, "byte4VectAddu",\
                        byte4VectSubu, "byte4VectSubu",\
                        byte8ScalPlus, "byte8ScalPlus",\
                        byte8ScalMinus, "byte8ScalMinus",\
                        byte8ScalMul, "byte8ScalMul",\
                        byte8ScalAdd, "byte8ScalAdd",\
                        byte8ScalSub, "byte8ScalSub",\
                        byte8ScalSar, "byte8ScalSar",\
                        byte8ScalSal, "byte8ScalSal",\
                        byte8ScalShr, "byte8ScalShr",\
                        byte8ScalE, "byte8ScalE",\
                        byte8ScalNE, "byte8ScalNE",\
                        byte8BitNot, "byte8BitNot",\
                        byte8BitAnd, "byte8BitAnd",\
                        byte8BitOr, "byte8BitOr",\
                        byte8BitXor, "byte8BitXor",\
                        byte8VectUnpckl, "byte8VectUnpckl",\
                        byte8VectUnpcku, "byte8VectUnpcku",\
                        byte8VectPlus, "byte8VectPlus",\
                        byte8VectMinus, "byte8VectMinus",\
                        byte8VectMul, "byte8VectMul",\
                        byte8VectAdd, "byte8VectAdd",\
                        byte8VectSub, "byte8VectSub",\
                        byte8VectSar, "byte8VectSar",\
                        byte8VectSal, "byte8VectSal",\
                        byte8VectShr, "byte8VectShr",\
                        byte8VectG, "byte8VectG",\
                        byte8VectGE, "byte8VectGE",\
                        byte8VectL, "byte8VectL",\
                        byte8VectLE, "byte8VectLE",\
                        byte8VectE, "byte8VectE",\
                        byte8VectNE, "byte8VectNE",\
                        byte8VectMuls, "byte8VectMuls",\
                        byte8VectAdds, "byte8VectAdds",\
                        byte8VectSubs, "byte8VectSubs",\
                        byte8VectMulu, "byte8VectMulu",\
                        byte8VectAddu, "byte8VectAddu",\
                        byte8VectSubu, "byte8VectSubu",\
                        shortScalPlus, "shortScalPlus",\
                        shortScalMinus, "shortScalMinus",\
                        shortScalMul, "shortScalMul",\
                        shortScalDiv, "shortScalDiv",\
                        shortScalDivu, "shortScalDivu",\
                        shortScalRem, "shortScalRem",\
                        shortScalRemu, "shortScalRemu",\
                        shortScalAdd, "shortScalAdd",\
                        shortScalSub, "shortScalSub",\
                        shortScalSar, "shortScalSar",\
                        shortScalSal, "shortScalSal",\
                        shortScalShr, "shortScalShr",\
                        shortScalG, "shortScalG",\
                        shortScalGE, "shortScalGE",\
                        shortScalL, "shortScalL",\
                        shortScalLE, "shortScalLE",\
                        shortScalE, "shortScalE",\
                        shortScalNE, "shortScalNE",\
                        shortBitNot, "shortBitNot",\
                        shortBitAnd, "shortBitAnd",\
                        shortBitOr, "shortBitOr",\
                        shortBitXor, "shortBitXor",\
                        shortVectUnpckl, "shortVectUnpckl",\
                        shortVectUnpcku, "shortVectUnpcku",\
                        shortVectPack, "shortVectPack",\
                        shortVectPlus, "shortVectPlus",\
                        shortVectMinus, "shortVectMinus",\
                        shortVectMul, "shortVectMul",\
                        shortVectAdd, "shortVectAdd",\
                        shortVectSub, "shortVectSub",\
                        shortVectSar, "shortVectSar",\
                        shortVectSal, "shortVectSal",\
                        shortVectShr, "shortVectShr",\
                        shortVectG, "shortVectG",\
                        shortVectGE, "shortVectGE",\
                        shortVectL, "shortVectL",\
                        shortVectLE, "shortVectLE",\
                        shortVectE, "shortVectE",\
                        shortVectNE, "shortVectNE",\
                        shortVectMuls, "shortVectMuls",\
                        shortVectAdds, "shortVectAdds",\
                        shortVectSubs, "shortVectSubs",\
                        shortVectMulu, "shortVectMulu",\
                        shortVectAddu, "shortVectAddu",\
                        shortVectSubu, "shortVectSubu",\
                        short2ScalPlus, "short2ScalPlus",\
                        short2ScalMinus, "short2ScalMinus",\
                        short2ScalMul, "short2ScalMul",\
                        short2ScalAdd, "short2ScalAdd",\
                        short2ScalSub, "short2ScalSub",\
                        short2ScalSar, "short2ScalSar",\
                        short2ScalSal, "short2ScalSal",\
                        short2ScalShr, "short2ScalShr",\
                        short2ScalE, "short2ScalE",\
                        short2ScalNE, "short2ScalNE",\
                        short2BitNot, "short2BitNot",\
                        short2BitAnd, "short2BitAnd",\
                        short2BitOr, "short2BitOr",\
                        short2BitXor, "short2BitXor",\
                        short2VectUnpckl, "short2VectUnpckl",\
                        short2VectUnpcku, "short2VectUnpcku",\
                        short2VectPack, "short2VectPack",\
                        short2VectPlus, "short2VectPlus",\
                        short2VectMinus, "short2VectMinus",\
                        short2VectMul, "short2VectMul",\
                        short2VectAdd, "short2VectAdd",\
                        short2VectSub, "short2VectSub",\
                        short2VectSar, "short2VectSar",\
                        short2VectSal, "short2VectSal",\
                        short2VectShr, "short2VectShr",\
                        short2VectG, "short2VectG",\
                        short2VectGE, "short2VectGE",\
                        short2VectL, "short2VectL",\
                        short2VectLE, "short2VectLE",\
                        short2VectE, "short2VectE",\
                        short2VectNE, "short2VectNE",\
                        short2VectMuls, "short2VectMuls",\
                        short2VectAdds, "short2VectAdds",\
                        short2VectSubs, "short2VectSubs",\
                        short2VectMulu, "short2VectMulu",\
                        short2VectAddu, "short2VectAddu",\
                        short2VectSubu, "short2VectSubu",\
                        short4ScalPlus, "short4ScalPlus",\
                        short4ScalMinus, "short4ScalMinus",\
                        short4ScalMul, "short4ScalMul",\
                        short4ScalAdd, "short4ScalAdd",\
                        short4ScalSub, "short4ScalSub",\
                        short4ScalSar, "short4ScalSar",\
                        short4ScalSal, "short4ScalSal",\
                        short4ScalShr, "short4ScalShr",\
                        short4ScalE, "short4ScalE",\
                        short4ScalNE, "short4ScalNE",\
                        short4BitNot, "short4BitNot",\
                        short4BitAnd, "short4BitAnd",\
                        short4BitOr, "short4BitOr",\
                        short4BitXor, "short4BitXor",\
                        short4VectUnpckl, "short4VectUnpckl",\
                        short4VectUnpcku, "short4VectUnpcku",\
                        short4VectPack, "short4VectPack",\
                        short4VectPlus, "short4VectPlus",\
                        short4VectMinus, "short4VectMinus",\
                        short4VectMul, "short4VectMul",\
                        short4VectAdd, "short4VectAdd",\
                        short4VectSub, "short4VectSub",\
                        short4VectSar, "short4VectSar",\
                        short4VectSal, "short4VectSal",\
                        short4VectShr, "short4VectShr",\
                        short4VectG, "short4VectG",\
                        short4VectGE, "short4VectGE",\
                        short4VectL, "short4VectL",\
                        short4VectLE, "short4VectLE",\
                        short4VectE, "short4VectE",\
                        short4VectNE, "short4VectNE",\
                        short4VectMuls, "short4VectMuls",\
                        short4VectAdds, "short4VectAdds",\
                        short4VectSubs, "short4VectSubs",\
                        short4VectMulu, "short4VectMulu",\
                        short4VectAddu, "short4VectAddu",\
                        short4VectSubu, "short4VectSubu",\
                        short8ScalPlus, "short8ScalPlus",\
                        short8ScalMinus, "short8ScalMinus",\
                        short8ScalMul, "short8ScalMul",\
                        short8ScalAdd, "short8ScalAdd",\
                        short8ScalSub, "short8ScalSub",\
                        short8ScalSar, "short8ScalSar",\
                        short8ScalSal, "short8ScalSal",\
                        short8ScalShr, "short8ScalShr",\
                        short8ScalE, "short8ScalE",\
                        short8ScalNE, "short8ScalNE",\
                        short8BitNot, "short8BitNot",\
                        short8BitAnd, "short8BitAnd",\
                        short8BitOr, "short8BitOr",\
                        short8BitXor, "short8BitXor",\
                        short8VectUnpckl, "short8VectUnpckl",\
                        short8VectUnpcku, "short8VectUnpcku",\
                        short8VectPack, "short8VectPack",\
                        short8VectPlus, "short8VectPlus",\
                        short8VectMinus, "short8VectMinus",\
                        short8VectMul, "short8VectMul",\
                        short8VectAdd, "short8VectAdd",\
                        short8VectSub, "short8VectSub",\
                        short8VectSar, "short8VectSar",\
                        short8VectSal, "short8VectSal",\
                        short8VectShr, "short8VectShr",\
                        short8VectG, "short8VectG",\
                        short8VectGE, "short8VectGE",\
                        short8VectL, "short8VectL",\
                        short8VectLE, "short8VectLE",\
                        short8VectE, "short8VectE",\
                        short8VectNE, "short8VectNE",\
                        short8VectMuls, "short8VectMuls",\
                        short8VectAdds, "short8VectAdds",\
                        short8VectSubs, "short8VectSubs",\
                        short8VectMulu, "short8VectMulu",\
                        short8VectAddu, "short8VectAddu",\
                        short8VectSubu, "short8VectSubu",\
                        intScalPlus, "intScalPlus",\
                        intScalMinus, "intScalMinus",\
                        intScalMul, "intScalMul",\
                        intScalDiv, "intScalDiv",\
                        intScalDivu, "intScalDivu",\
                        intScalRem, "intScalRem",\
                        intScalRemu, "intScalRemu",\
                        intScalAdd, "intScalAdd",\
                        intScalSub, "intScalSub",\
                        intScalSar, "intScalSar",\
                        intScalSal, "intScalSal",\
                        intScalShr, "intScalShr",\
                        intScalG, "intScalG",\
                        intScalGE, "intScalGE",\
                        intScalL, "intScalL",\
                        intScalLE, "intScalLE",\
                        intScalE, "intScalE",\
                        intScalNE, "intScalNE",\
                        intBitNot, "intBitNot",\
                        intBitAnd, "intBitAnd",\
                        intBitOr, "intBitOr",\
                        intBitXor, "intBitXor",\
                        intVectUnpckl, "intVectUnpckl",\
                        intVectUnpcku, "intVectUnpcku",\
                        intVectPack, "intVectPack",\
                        intVectPlus, "intVectPlus",\
                        intVectMinus, "intVectMinus",\
                        intVectMul, "intVectMul",\
                        intVectAdd, "intVectAdd",\
                        intVectSub, "intVectSub",\
                        intVectSar, "intVectSar",\
                        intVectSal, "intVectSal",\
                        intVectShr, "intVectShr",\
                        intVectG, "intVectG",\
                        intVectGE, "intVectGE",\
                        intVectL, "intVectL",\
                        intVectLE, "intVectLE",\
                        intVectE, "intVectE",\
                        intVectNE, "intVectNE",\
                        int2ScalPlus, "int2ScalPlus",\
                        int2ScalMinus, "int2ScalMinus",\
                        int2ScalMul, "int2ScalMul",\
                        int2ScalAdd, "int2ScalAdd",\
                        int2ScalSub, "int2ScalSub",\
                        int2ScalSar, "int2ScalSar",\
                        int2ScalSal, "int2ScalSal",\
                        int2ScalShr, "int2ScalShr",\
                        int2ScalE, "int2ScalE",\
                        int2ScalNE, "int2ScalNE",\
                        int2BitNot, "int2BitNot",\
                        int2BitAnd, "int2BitAnd",\
                        int2BitOr, "int2BitOr",\
                        int2BitXor, "int2BitXor",\
                        int2VectUnpckl, "int2VectUnpckl",\
                        int2VectUnpcku, "int2VectUnpcku",\
                        int2VectPack, "int2VectPack",\
                        int2VectPlus, "int2VectPlus",\
                        int2VectMinus, "int2VectMinus",\
                        int2VectMul, "int2VectMul",\
                        int2VectAdd, "int2VectAdd",\
                        int2VectSub, "int2VectSub",\
                        int2VectSar, "int2VectSar",\
                        int2VectSal, "int2VectSal",\
                        int2VectShr, "int2VectShr",\
                        int2VectG, "int2VectG",\
                        int2VectGE, "int2VectGE",\
                        int2VectL, "int2VectL",\
                        int2VectLE, "int2VectLE",\
                        int2VectE, "int2VectE",\
                        int2VectNE, "int2VectNE",\
                        int4ScalPlus, "int4ScalPlus",\
                        int4ScalMinus, "int4ScalMinus",\
                        int4ScalMul, "int4ScalMul",\
                        int4ScalAdd, "int4ScalAdd",\
                        int4ScalSub, "int4ScalSub",\
                        int4ScalSar, "int4ScalSar",\
                        int4ScalSal, "int4ScalSal",\
                        int4ScalShr, "int4ScalShr",\
                        int4ScalE, "int4ScalE",\
                        int4ScalNE, "int4ScalNE",\
                        int4BitNot, "int4BitNot",\
                        int4BitAnd, "int4BitAnd",\
                        int4BitOr, "int4BitOr",\
                        int4BitXor, "int4BitXor",\
                        int4VectUnpckl, "int4VectUnpckl",\
                        int4VectUnpcku, "int4VectUnpcku",\
                        int4VectPack, "int4VectPack",\
                        int4VectPlus, "int4VectPlus",\
                        int4VectMinus, "int4VectMinus",\
                        int4VectMul, "int4VectMul",\
                        int4VectAdd, "int4VectAdd",\
                        int4VectSub, "int4VectSub",\
                        int4VectSar, "int4VectSar",\
                        int4VectSal, "int4VectSal",\
                        int4VectShr, "int4VectShr",\
                        int4VectG, "int4VectG",\
                        int4VectGE, "int4VectGE",\
                        int4VectL, "int4VectL",\
                        int4VectLE, "int4VectLE",\
                        int4VectE, "int4VectE",\
                        int4VectNE, "int4VectNE",\
                        int8ScalPlus, "int8ScalPlus",\
                        int8ScalMinus, "int8ScalMinus",\
                        int8ScalMul, "int8ScalMul",\
                        int8ScalAdd, "int8ScalAdd",\
                        int8ScalSub, "int8ScalSub",\
                        int8ScalSar, "int8ScalSar",\
                        int8ScalSal, "int8ScalSal",\
                        int8ScalShr, "int8ScalShr",\
                        int8ScalE, "int8ScalE",\
                        int8ScalNE, "int8ScalNE",\
                        int8BitNot, "int8BitNot",\
                        int8BitAnd, "int8BitAnd",\
                        int8BitOr, "int8BitOr",\
                        int8BitXor, "int8BitXor",\
                        int8VectUnpckl, "int8VectUnpckl",\
                        int8VectUnpcku, "int8VectUnpcku",\
                        int8VectPack, "int8VectPack",\
                        int8VectPlus, "int8VectPlus",\
                        int8VectMinus, "int8VectMinus",\
                        int8VectMul, "int8VectMul",\
                        int8VectAdd, "int8VectAdd",\
                        int8VectSub, "int8VectSub",\
                        int8VectSar, "int8VectSar",\
                        int8VectSal, "int8VectSal",\
                        int8VectShr, "int8VectShr",\
                        int8VectG, "int8VectG",\
                        int8VectGE, "int8VectGE",\
                        int8VectL, "int8VectL",\
                        int8VectLE, "int8VectLE",\
                        int8VectE, "int8VectE",\
                        int8VectNE, "int8VectNE",\
                        longScalPlus, "longScalPlus",\
                        longScalMinus, "longScalMinus",\
                        longScalMul, "longScalMul",\
                        longScalDiv, "longScalDiv",\
                        longScalDivu, "longScalDivu",\
                        longScalRem, "longScalRem",\
                        longScalRemu, "longScalRemu",\
                        longScalAdd, "longScalAdd",\
                        longScalSub, "longScalSub",\
                        longScalSar, "longScalSar",\
                        longScalSal, "longScalSal",\
                        longScalShr, "longScalShr",\
                        longScalG, "longScalG",\
                        longScalGE, "longScalGE",\
                        longScalL, "longScalL",\
                        longScalLE, "longScalLE",\
                        longScalE, "longScalE",\
                        longScalNE, "longScalNE",\
                        longBitNot, "longBitNot",\
                        longBitAnd, "longBitAnd",\
                        longBitOr, "longBitOr",\
                        longBitXor, "longBitXor",\
                        longVectPack, "longVectPack",\
                        longVectPlus, "longVectPlus",\
                        longVectMinus, "longVectMinus",\
                        longVectMul, "longVectMul",\
                        longVectAdd, "longVectAdd",\
                        longVectSub, "longVectSub",\
                        longVectSar, "longVectSar",\
                        longVectSal, "longVectSal",\
                        longVectShr, "longVectShr",\
                        longVectG, "longVectG",\
                        longVectGE, "longVectGE",\
                        longVectL, "longVectL",\
                        longVectLE, "longVectLE",\
                        longVectE, "longVectE",\
                        longVectNE, "longVectNE",\
                        long2ScalPlus, "long2ScalPlus",\
                        long2ScalMinus, "long2ScalMinus",\
                        long2ScalMul, "long2ScalMul",\
                        long2ScalAdd, "long2ScalAdd",\
                        long2ScalSub, "long2ScalSub",\
                        long2ScalSar, "long2ScalSar",\
                        long2ScalSal, "long2ScalSal",\
                        long2ScalShr, "long2ScalShr",\
                        long2ScalE, "long2ScalE",\
                        long2ScalNE, "long2ScalNE",\
                        long2BitNot, "long2BitNot",\
                        long2BitAnd, "long2BitAnd",\
                        long2BitOr, "long2BitOr",\
                        long2BitXor, "long2BitXor",\
                        long2VectPack, "long2VectPack",\
                        long2VectPlus, "long2VectPlus",\
                        long2VectMinus, "long2VectMinus",\
                        long2VectMul, "long2VectMul",\
                        long2VectAdd, "long2VectAdd",\
                        long2VectSub, "long2VectSub",\
                        long2VectSar, "long2VectSar",\
                        long2VectSal, "long2VectSal",\
                        long2VectShr, "long2VectShr",\
                        long2VectG, "long2VectG",\
                        long2VectGE, "long2VectGE",\
                        long2VectL, "long2VectL",\
                        long2VectLE, "long2VectLE",\
                        long2VectE, "long2VectE",\
                        long2VectNE, "long2VectNE",\
                        long4ScalPlus, "long4ScalPlus",\
                        long4ScalMinus, "long4ScalMinus",\
                        long4ScalMul, "long4ScalMul",\
                        long4ScalAdd, "long4ScalAdd",\
                        long4ScalSub, "long4ScalSub",\
                        long4ScalSar, "long4ScalSar",\
                        long4ScalSal, "long4ScalSal",\
                        long4ScalShr, "long4ScalShr",\
                        long4ScalE, "long4ScalE",\
                        long4ScalNE, "long4ScalNE",\
                        long4BitNot, "long4BitNot",\
                        long4BitAnd, "long4BitAnd",\
                        long4BitOr, "long4BitOr",\
                        long4BitXor, "long4BitXor",\
                        long4VectPack, "long4VectPack",\
                        long4VectPlus, "long4VectPlus",\
                        long4VectMinus, "long4VectMinus",\
                        long4VectMul, "long4VectMul",\
                        long4VectAdd, "long4VectAdd",\
                        long4VectSub, "long4VectSub",\
                        long4VectSar, "long4VectSar",\
                        long4VectSal, "long4VectSal",\
                        long4VectShr, "long4VectShr",\
                        long4VectG, "long4VectG",\
                        long4VectGE, "long4VectGE",\
                        long4VectL, "long4VectL",\
                        long4VectLE, "long4VectLE",\
                        long4VectE, "long4VectE",\
                        long4VectNE, "long4VectNE",\
                        long8ScalPlus, "long8ScalPlus",\
                        long8ScalMinus, "long8ScalMinus",\
                        long8ScalMul, "long8ScalMul",\
                        long8ScalAdd, "long8ScalAdd",\
                        long8ScalSub, "long8ScalSub",\
                        long8ScalSar, "long8ScalSar",\
                        long8ScalSal, "long8ScalSal",\
                        long8ScalShr, "long8ScalShr",\
                        long8ScalE, "long8ScalE",\
                        long8ScalNE, "long8ScalNE",\
                        long8BitNot, "long8BitNot",\
                        long8BitAnd, "long8BitAnd",\
                        long8BitOr, "long8BitOr",\
                        long8BitXor, "long8BitXor",\
                        long8VectPack, "long8VectPack",\
                        long8VectPlus, "long8VectPlus",\
                        long8VectMinus, "long8VectMinus",\
                        long8VectMul, "long8VectMul",\
                        long8VectAdd, "long8VectAdd",\
                        long8VectSub, "long8VectSub",\
                        long8VectSar, "long8VectSar",\
                        long8VectSal, "long8VectSal",\
                        long8VectShr, "long8VectShr",\
                        long8VectG, "long8VectG",\
                        long8VectGE, "long8VectGE",\
                        long8VectL, "long8VectL",\
                        long8VectLE, "long8VectLE",\
                        long8VectE, "long8VectE",\
                        long8VectNE, "long8VectNE",\
                        floatScalPlus, "floatScalPlus",\
                        floatScalMinus, "floatScalMinus",\
                        floatScalMul, "floatScalMul",\
                        floatScalDiv, "floatScalDiv",\
                        floatScalDivu, "floatScalDivu",\
                        floatScalRem, "floatScalRem",\
                        floatScalRemu, "floatScalRemu",\
                        floatScalAdd, "floatScalAdd",\
                        floatScalSub, "floatScalSub",\
                        floatScalG, "floatScalG",\
                        floatScalGE, "floatScalGE",\
                        floatScalL, "floatScalL",\
                        floatScalLE, "floatScalLE",\
                        floatScalE, "floatScalE",\
                        floatScalNE, "floatScalNE",\
                        floatVectPlus, "floatVectPlus",\
                        floatVectMinus, "floatVectMinus",\
                        floatVectMul, "floatVectMul",\
                        floatVectDiv, "floatVectDiv",\
                        floatVectAdd, "floatVectAdd",\
                        floatVectSub, "floatVectSub",\
                        floatVectG, "floatVectG",\
                        floatVectGE, "floatVectGE",\
                        floatVectL, "floatVectL",\
                        floatVectLE, "floatVectLE",\
                        floatVectE, "floatVectE",\
                        floatVectNE, "floatVectNE",\
                        float2ScalPlus, "float2ScalPlus",\
                        float2ScalMinus, "float2ScalMinus",\
                        float2ScalMul, "float2ScalMul",\
                        float2ScalDiv, "float2ScalDiv",\
                        float2ScalDivu, "float2ScalDivu",\
                        float2ScalAdd, "float2ScalAdd",\
                        float2ScalSub, "float2ScalSub",\
                        float2ScalE, "float2ScalE",\
                        float2ScalNE, "float2ScalNE",\
                        float2VectPlus, "float2VectPlus",\
                        float2VectMinus, "float2VectMinus",\
                        float2VectMul, "float2VectMul",\
                        float2VectDiv, "float2VectDiv",\
                        float2VectAdd, "float2VectAdd",\
                        float2VectSub, "float2VectSub",\
                        float2VectG, "float2VectG",\
                        float2VectGE, "float2VectGE",\
                        float2VectL, "float2VectL",\
                        float2VectLE, "float2VectLE",\
                        float2VectE, "float2VectE",\
                        float2VectNE, "float2VectNE",\
                        float4ScalPlus, "float4ScalPlus",\
                        float4ScalMinus, "float4ScalMinus",\
                        float4ScalMul, "float4ScalMul",\
                        float4ScalDiv, "float4ScalDiv",\
                        float4ScalDivu, "float4ScalDivu",\
                        float4ScalAdd, "float4ScalAdd",\
                        float4ScalSub, "float4ScalSub",\
                        float4ScalE, "float4ScalE",\
                        float4ScalNE, "float4ScalNE",\
                        float4VectPlus, "float4VectPlus",\
                        float4VectMinus, "float4VectMinus",\
                        float4VectMul, "float4VectMul",\
                        float4VectDiv, "float4VectDiv",\
                        float4VectAdd, "float4VectAdd",\
                        float4VectSub, "float4VectSub",\
                        float4VectG, "float4VectG",\
                        float4VectGE, "float4VectGE",\
                        float4VectL, "float4VectL",\
                        float4VectLE, "float4VectLE",\
                        float4VectE, "float4VectE",\
                        float4VectNE, "float4VectNE",\
                        float8ScalPlus, "float8ScalPlus",\
                        float8ScalMinus, "float8ScalMinus",\
                        float8ScalMul, "float8ScalMul",\
                        float8ScalDiv, "float8ScalDiv",\
                        float8ScalDivu, "float8ScalDivu",\
                        float8ScalAdd, "float8ScalAdd",\
                        float8ScalSub, "float8ScalSub",\
                        float8ScalE, "float8ScalE",\
                        float8ScalNE, "float8ScalNE",\
                        float8VectPlus, "float8VectPlus",\
                        float8VectMinus, "float8VectMinus",\
                        float8VectMul, "float8VectMul",\
                        float8VectDiv, "float8VectDiv",\
                        float8VectAdd, "float8VectAdd",\
                        float8VectSub, "float8VectSub",\
                        float8VectG, "float8VectG",\
                        float8VectGE, "float8VectGE",\
                        float8VectL, "float8VectL",\
                        float8VectLE, "float8VectLE",\
                        float8VectE, "float8VectE",\
                        float8VectNE, "float8VectNE",\
                        doubleScalPlus, "doubleScalPlus",\
                        doubleScalMinus, "doubleScalMinus",\
                        doubleScalMul, "doubleScalMul",\
                        doubleScalDiv, "doubleScalDiv",\
                        doubleScalDivu, "doubleScalDivu",\
                        doubleScalRem, "doubleScalRem",\
                        doubleScalRemu, "doubleScalRemu",\
                        doubleScalAdd, "doubleScalAdd",\
                        doubleScalSub, "doubleScalSub",\
                        doubleScalG, "doubleScalG",\
                        doubleScalGE, "doubleScalGE",\
                        doubleScalL, "doubleScalL",\
                        doubleScalLE, "doubleScalLE",\
                        doubleScalE, "doubleScalE",\
                        doubleScalNE, "doubleScalNE",\
                        doubleVectPlus, "doubleVectPlus",\
                        doubleVectMinus, "doubleVectMinus",\
                        doubleVectMul, "doubleVectMul",\
                        doubleVectDiv, "doubleVectDiv",\
                        doubleVectAdd, "doubleVectAdd",\
                        doubleVectSub, "doubleVectSub",\
                        doubleVectG, "doubleVectG",\
                        doubleVectGE, "doubleVectGE",\
                        doubleVectL, "doubleVectL",\
                        doubleVectLE, "doubleVectLE",\
                        doubleVectE, "doubleVectE",\
                        doubleVectNE, "doubleVectNE",\
                        double2ScalPlus, "double2ScalPlus",\
                        double2ScalMinus, "double2ScalMinus",\
                        double2ScalMul, "double2ScalMul",\
                        double2ScalDiv, "double2ScalDiv",\
                        double2ScalDivu, "double2ScalDivu",\
                        double2ScalAdd, "double2ScalAdd",\
                        double2ScalSub, "double2ScalSub",\
                        double2ScalE, "double2ScalE",\
                        double2ScalNE, "double2ScalNE",\
                        double2VectPlus, "double2VectPlus",\
                        double2VectMinus, "double2VectMinus",\
                        double2VectMul, "double2VectMul",\
                        double2VectDiv, "double2VectDiv",\
                        double2VectAdd, "double2VectAdd",\
                        double2VectSub, "double2VectSub",\
                        double2VectG, "double2VectG",\
                        double2VectGE, "double2VectGE",\
                        double2VectL, "double2VectL",\
                        double2VectLE, "double2VectLE",\
                        double2VectE, "double2VectE",\
                        double2VectNE, "double2VectNE",\
                        double4ScalPlus, "double4ScalPlus",\
                        double4ScalMinus, "double4ScalMinus",\
                        double4ScalMul, "double4ScalMul",\
                        double4ScalDiv, "double4ScalDiv",\
                        double4ScalDivu, "double4ScalDivu",\
                        double4ScalAdd, "double4ScalAdd",\
                        double4ScalSub, "double4ScalSub",\
                        double4ScalE, "double4ScalE",\
                        double4ScalNE, "double4ScalNE",\
                        double4VectPlus, "double4VectPlus",\
                        double4VectMinus, "double4VectMinus",\
                        double4VectMul, "double4VectMul",\
                        double4VectDiv, "double4VectDiv",\
                        double4VectAdd, "double4VectAdd",\
                        double4VectSub, "double4VectSub",\
                        double4VectG, "double4VectG",\
                        double4VectGE, "double4VectGE",\
                        double4VectL, "double4VectL",\
                        double4VectLE, "double4VectLE",\
                        double4VectE, "double4VectE",\
                        double4VectNE, "double4VectNE",\
                        double8ScalPlus, "double8ScalPlus",\
                        double8ScalMinus, "double8ScalMinus",\
                        double8ScalMul, "double8ScalMul",\
                        double8ScalDiv, "double8ScalDiv",\
                        double8ScalDivu, "double8ScalDivu",\
                        double8ScalAdd, "double8ScalAdd",\
                        double8ScalSub, "double8ScalSub",\
                        double8ScalE, "double8ScalE",\
                        double8ScalNE, "double8ScalNE",\
                        double8VectPlus, "double8VectPlus",\
                        double8VectMinus, "double8VectMinus",\
                        double8VectMul, "double8VectMul",\
                        double8VectDiv, "double8VectDiv",\
                        double8VectAdd, "double8VectAdd",\
                        double8VectSub, "double8VectSub",\
                        double8VectG, "double8VectG",\
                        double8VectGE, "double8VectGE",\
                        double8VectL, "double8VectL",\
                        double8VectLE, "double8VectLE",\
                        double8VectE, "double8VectE",\
                        double8VectNE, "double8VectNE",\
                        realScalPlus, "realScalPlus",\
                        realScalMinus, "realScalMinus",\
                        realScalMul, "realScalMul",\
                        realScalDiv, "realScalDiv",\
                        realScalDivu, "realScalDivu",\
                        realScalRem, "realScalRem",\
                        realScalRemu, "realScalRemu",\
                        realScalAdd, "realScalAdd",\
                        realScalSub, "realScalSub",\
                        realScalG, "realScalG",\
                        realScalGE, "realScalGE",\
                        realScalL, "realScalL",\
                        realScalLE, "realScalLE",\
                        realScalE, "realScalE",\
                        realScalNE, "realScalNE",\
                        castByte8ToShort8, "castByte8ToShort8",\
                        castByte8ToInt8, "castByte8ToInt8",\
                        castByte8ToLong8, "castByte8ToLong8",\
                        castByte8ToFloat8, "castByte8ToFloat8",\
                        castByte8ToDouble8, "castByte8ToDouble8",\
                        castByte8ToReal, "castByte8ToReal",\
                        castShort8ToByte8, "castShort8ToByte8",\
                        castShort8ToInt8, "castShort8ToInt8",\
                        castShort8ToLong8, "castShort8ToLong8",\
                        castShort8ToFloat8, "castShort8ToFloat8",\
                        castShort8ToDouble8, "castShort8ToDouble8",\
                        castShort8ToReal, "castShort8ToReal",\
                        castInt8ToByte8, "castInt8ToByte8",\
                        castInt8ToShort8, "castInt8ToShort8",\
                        castInt8ToLong8, "castInt8ToLong8",\
                        castInt8ToFloat8, "castInt8ToFloat8",\
                        castInt8ToDouble8, "castInt8ToDouble8",\
                        castInt8ToReal, "castInt8ToReal",\
                        castLong8ToByte8, "castLong8ToByte8",\
                        castLong8ToShort8, "castLong8ToShort8",\
                        castLong8ToInt8, "castLong8ToInt8",\
                        castLong8ToFloat8, "castLong8ToFloat8",\
                        castLong8ToDouble8, "castLong8ToDouble8",\
                        castLong8ToReal, "castLong8ToReal",\
                        castFloat8ToByte8, "castFloat8ToByte8",\
                        castFloat8ToShort8, "castFloat8ToShort8",\
                        castFloat8ToInt8, "castFloat8ToInt8",\
                        castFloat8ToLong8, "castFloat8ToLong8",\
                        castFloat8ToDouble8, "castFloat8ToDouble8",\
                        castFloat8ToReal, "castFloat8ToReal",\
                        castDouble8ToByte8, "castDouble8ToByte8",\
                        castDouble8ToShort8, "castDouble8ToShort8",\
                        castDouble8ToInt8, "castDouble8ToInt8",\
                        castDouble8ToLong8, "castDouble8ToLong8",\
                        castDouble8ToFloat8, "castDouble8ToFloat8",\
                        castDouble8ToReal, "castDouble8ToReal",\
                        castRealToByte8, "castRealToByte8",\
                        castRealToShort8, "castRealToShort8",\
                        castRealToInt8, "castRealToInt8",\
                        castRealToLong8, "castRealToLong8",\
                        castRealToFloat8, "castRealToFloat8",\
                        castRealToDouble8, "castRealToDouble8",\
                        setPrimitiveAddress, "setPrimitiveAddress"

section ".reloc" fixups data readable discardable

    if $ = $$
                    dd      0, 8
    end if