tagged-stack.inc

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

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

; <fold операции с тагированным стаком>
    ; <fold список неиспользуемых компилятором ПВТ-ОО макроинструкций>
        ; не все макроинструкции из этого файла исходного кода могут быть использованы при компиляции исходного кода на языке ПВТ-ОО.
        ; список таких макроинструкций:
        ; - tdup1e_p
        ; - tdup1d_p
        ; - tdup1d2_p
        ; - tdup1d4_p
        ; - tdup1d8_p
        ; - tdup1f_p
        ; - tdup1f2_p
        ; - tdup1f4_p
        ; - tdup1f8_p
        ; - tdup1b2_p
        ; - tdup1b4_p
        ; - tdup1b8_p
        ; - tdup1s2_p
        ; - tdup1s4_p
        ; - tdup1s8_p
        ; - tdup1i_p
        ; - tdup1i2_p
        ; - tdup1i4_p
        ; - tdup1i8_p
        ; - tdup1l_p
        ; - tdup1l2_p
        ; - tdup1l4_p
        ; - tdup1l8_p
        ; - tdup1x2r
        ; - tdup2r
        ; - tdup2e
        ; - tdup2d
        ; - tdup2d2
        ; - tdup2d4
        ; - tdup2d8
        ; - tdup2f
        ; - tdup2f2
        ; - tdup2f4
        ; - tdup2f8
        ; - tdup2b2
        ; - tdup2b4
        ; - tdup2b8
        ; - tdup2s2
        ; - tdup2s4
        ; - tdup2s8
        ; - tdup2i2
        ; - tdup2i4
        ; - tdup2i8
        ; - tdup2l
        ; - tdup2l2
        ; - tdup2l4
        ; - tdup2l8
    ; </fold>

    ; <fold приватные макросы — должны использоваться только этим текстом исходного кода>
        macro _dup1x2lp dataElements* {
                        local       .L.0000
                        call        inst$dup1x2
                        __push      (dataElements)*$01
            .L.0000:    vmovdqa     xmm1, [rsp+r02*8+(dataElements)*$10]
                        vmovdqa     xword [rsp+r02*8+$00], xmm1
                        mov         bsc9, [rsi+r01*1+(dataElements)*$01]
                        mov         byte  [rsi+r01*1+$00], bsc9
                        lea         r01q, [r01+$01]
                        lea         r02q, [r02+$02]
                        cmp         r01d, r08d
                        jb          .L.0000
                        lea         r09q, [r08+r08*1+$00]
        }

        macro _dup1x2lp_p dataElements* {
                        local       .L.0000
                        call        inst$dup1x2
                        __push      (dataElements)*$02
            .L.0000:    vmovdqa     xmm1, [rsp+r02*8+(dataElements)*$20]
                        vmovdqa     xword [rsp+r02*8+(dataElements)*$10], xmm1
                        mov         bsc9, [rsi+r01*1+(dataElements)*$02]
                        mov         byte  [rsi+r01*1+(dataElements)*$01], bsc9
                        lea         r01q, [r01+$01]
                        lea         r02q, [r02+$02]
                        cmp         r01d, r08d
                        jb          .L.0000
                        lea         r08q, [r08+(dataElements)*$01]
                        lea         r09q, [r08+r08*1+$00]
        }

        macro _dup2 {
                        mov         qsc1, [rsp+$00]
                        tstincrcoth qsc1
        }
    ; </fold>

    ; <fold размещение значения аккумулятора на стаке>
        macro tpushr {
                        __push      $01
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
                        __sttag_x   $00,  TAG_OBJECT
        }

        macro tpushe {
                        __push      $01
                        mov         dword [rsp+$0c], $00
                        mov         word  [rsp+$0a], $00
                        fstp        tbyte [rsp+$00]
        }

        macro tpushd {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tpushd2 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tpushd4 {
                        __push      $02
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $00,  TAG_DOUBLE4
        }

        macro tpushd8 {
                        __push      $04
                        vmovdqu64   zword [rsp+$00], zmm0
                        __sttag_z   $00,  TAG_DOUBLE8
        }

        macro tpushf {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tpushf2 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tpushf4 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tpushf8 {
                        __push      $02
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $00,  TAG_FLOAT8
        }

        macro tpushb2 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tpushb4 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tpushb8 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tpushs2 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tpushs4 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tpushs8 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tpushi {
                        __push      $01
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
        }

        macro tpushi2 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tpushi4 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tpushi8 {
                        __push      $02
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $00,  TAG_INT8
        }

        macro tpushl {
                        __push      $01
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
        }

        macro tpushl2 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tpushl4 {
                        __push      $02
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $00,  TAG_LONG4
        }

        macro tpushl8 {
                        __push      $04
                        vmovdqu64   zword [rsp+$00], zmm0
                        __sttag_z   $00,  TAG_LONG8
        }
    ; </fold>

    ; <fold извлечение значения из стака в аккумулятор>
        macro tpopr {
                        mov         qsc0, [rsp+$00]
                        __cltag_x   $00
                        __pop       $01
        }

        macro tpope {
                        fld         tbyte [rsp+$00]
                        __pop       $01
        }

        macro tpopd {
                        vmovdqa     xmm0, [rsp+$00]
                        __pop       $01
        }

        macro tpopd2 {
                        vmovdqa     xmm0, [rsp+$00]
                        __pop       $01
        }

        macro tpopd4 {
                        vmovdqu     ymm0, [rsp+$00]
                        __cltag_y   $00
                        __pop       $02
        }

        macro tpopd8 {
                        vmovdqu64   zmm0, [rsp+$00]
                        __cltag_z   $00
                        __pop       $04
        }

        macro tpopf {
                        vmovdqa     xmm0, [rsp+$00]
                        __pop       $01
        }

        macro tpopf2 {
                        vmovdqa     xmm0, [rsp+$00]
                        __pop       $01
        }

        macro tpopf4 {
                        vmovdqa     xmm0, [rsp+$00]
                        __pop       $01
        }

        macro tpopf8 {
                        vmovdqu     ymm0, [rsp+$00]
                        __cltag_y   $00
                        __pop       $02
        }

        macro tpopb2 {
                        vmovdqa     xmm0, [rsp+$00]
                        __pop       $01
        }

        macro tpopb4 {
                        vmovdqa     xmm0, [rsp+$00]
                        __pop       $01
        }

        macro tpopb8 {
                        vmovdqa     xmm0, [rsp+$00]
                        __pop       $01
        }

        macro tpops2 {
                        vmovdqa     xmm0, [rsp+$00]
                        __pop       $01
        }

        macro tpops4 {
                        vmovdqa     xmm0, [rsp+$00]
                        __pop       $01
        }

        macro tpops8 {
                        vmovdqa     xmm0, [rsp+$00]
                        __pop       $01
        }

        macro tpopi {
                        mov         dsc0, [rsp+$00]
                        __pop       $01
        }

        macro tpopi2 {
                        vmovdqa     xmm0, [rsp+$00]
                        __pop       $01
        }

        macro tpopi4 {
                        vmovdqa     xmm0, [rsp+$00]
                        __pop       $01
        }

        macro tpopi8 {
                        vmovdqu     ymm0, [rsp+$00]
                        __cltag_y   $00
                        __pop       $02
        }

        macro tpopl {
                        mov         qsc0, [rsp+$00]
                        __pop       $01
        }

        macro tpopl2 {
                        vmovdqa     xmm0, [rsp+$00]
                        __pop       $01
        }

        macro tpopl4 {
                        vmovdqu     ymm0, [rsp+$00]
                        __cltag_y   $00
                        __pop       $02
        }

        macro tpopl8 {
                        vmovdqu64   zmm0, [rsp+$00]
                        __cltag_z   $00
                        __pop       $04
        }
    ; </fold>

    ; <fold размещение объектной ссылки из аккумулятора одним значением ниже на стаке>
        macro tswapr_p {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_OBJECT shl 0)
        }

        macro tswape_p {
                        fld         tbyte [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        mov         dword [rsp+$0c], $00
                        mov         word  [rsp+$0a], $00
                        fstp        tbyte [rsp+$00]
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswapd_p {
                        vmovdqa     xmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswapd2_p {
                        vmovdqa     xmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswapd4_p {
                        vmovdqu     ymm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc0
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_x   $02,  TAG_OBJECT
                        __sttag_y   $00,  TAG_DOUBLE4
        }

        macro tswapd8_p {
                        vmovdqu64   zmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$48], $00
                        mov         qword [rsp+$40], qsc0
                        vmovdqu64   zword [rsp+$00], zmm0
                        __sttag_x   $04,  TAG_OBJECT
                        __sttag_z   $00,  TAG_DOUBLE8
        }

        macro tswapf_p {
                        vmovdqa     xmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswapf2_p {
                        vmovdqa     xmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswapf4_p {
                        vmovdqa     xmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswapf8_p {
                        vmovdqu     ymm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc0
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_x   $02,  TAG_OBJECT
                        __sttag_y   $00,  TAG_FLOAT8
        }

        macro tswapb2_p {
                        vmovdqa     xmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswapb4_p {
                        vmovdqa     xmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswapb8_p {
                        vmovdqa     xmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswaps2_p {
                        vmovdqa     xmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswaps4_p {
                        vmovdqa     xmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswaps8_p {
                        vmovdqa     xmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswapi_p {
                        mov         dsc1, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswapi2_p {
                        vmovdqa     xmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswapi4_p {
                        vmovdqa     xmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswapi8_p {
                        vmovdqu     ymm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc0
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_x   $02,  TAG_OBJECT
                        __sttag_y   $00,  TAG_INT8
        }

        macro tswapl_p {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswapl2_p {
                        vmovdqa     xmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_EMPTY shl 0)
        }

        macro tswapl4_p {
                        vmovdqu     ymm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc0
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_x   $02,  TAG_OBJECT
                        __sttag_y   $00,  TAG_LONG4
        }

        macro tswapl8_p {
                        vmovdqu64   zmm0, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$48], $00
                        mov         qword [rsp+$40], qsc0
                        vmovdqu64   zword [rsp+$00], zmm0
                        __sttag_x   $04,  TAG_OBJECT
                        __sttag_z   $00,  TAG_LONG8
        }
    ; </fold>

    ; <fold дублирование значения аккумулятора на стаке, без дополнительного размещения значения>
        macro tdup1r {
                        tstincrcoth qsc0
                        __push      $01
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
                        __sttag_x   $00,  TAG_OBJECT
        }

        macro tdup1e {
                        fld         esc0
                        __push      $01
                        mov         dword [rsp+$0c], $00
                        mov         word  [rsp+$0a], $00
                        fstp        tbyte [rsp+$00]
        }

        macro tdup1d {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1d2 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1d4 {
                        __push      $02
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $00,  TAG_DOUBLE4
        }

        macro tdup1d8 {
                        __push      $04
                        vmovdqu64   zword [rsp+$00], zmm0
                        __sttag_z   $00,  TAG_DOUBLE8
        }

        macro tdup1f {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1f2 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1f4 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1f8 {
                        __push      $02
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $00,  TAG_FLOAT8
        }

        macro tdup1b2 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1b4 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1b8 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1s2 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1s4 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1s8 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1i {
                        __push      $01
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
        }

        macro tdup1i2 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1i4 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1i8 {
                        __push      $02
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $00,  TAG_INT8
        }

        macro tdup1l {
                        __push      $01
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
        }

        macro tdup1l2 {
                        __push      $01
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1l4 {
                        __push      $02
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $00,  TAG_LONG4
        }

        macro tdup1l8 {
                        __push      $04
                        vmovdqu64   zword [rsp+$00], zmm0
                        __sttag_z   $00,  TAG_LONG8
        }
    ; </fold>

    ; <fold дублирование значения аккумулятора на стаке, с дополнительным размещением значения>
        macro tdup1r_p {
                        tstincrcoth qsc0
                        __push      $02
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1e_p {
                        fld         esc0
                        __push      $02
                        mov         dword [rsp+$1c], $00
                        mov         word  [rsp+$1a], $00
                        fstp        tbyte [rsp+$10]
                        mov         dword [rsp+$0c], $00
                        mov         word  [rsp+$0a], $00
                        fstp        tbyte [rsp+$00]
        }

        macro tdup1d_p {
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1d2_p {
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1d4_p {
                        __push      $04
                        vmovdqu     yword [rsp+$20], ymm0
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_z   $00,  (TAG_DOUBLE4 shl $10)+(TAG_DOUBLE4 shl $00)
        }

        macro tdup1d8_p {
                        __push      $08
                        vmovdqu64   zword [rsp+$40], zmm0
                        vmovdqu64   zword [rsp+$00], zmm0
                        __sttag_z   $04,  TAG_DOUBLE8
                        __sttag_z   $00,  TAG_DOUBLE8
        }

        macro tdup1f_p {
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1f2_p {
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1f4_p {
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1f8_p {
                        __push      $04
                        vmovdqu     yword [rsp+$20], ymm0
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_z   $00,  (TAG_FLOAT8 shl $10)+(TAG_FLOAT8 shl $00)
        }

        macro tdup1b2_p {
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1b4_p {
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1b8_p {
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1s2_p {
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1s4_p {
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1s8_p {
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1i_p {
                        __push      $02
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
        }

        macro tdup1i2_p {
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1i4_p {
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1i8_p {
                        __push      $04
                        vmovdqu     yword [rsp+$20], ymm0
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_z   $00,  (TAG_INT8 shl $10)+(TAG_INT8 shl $00)
        }

        macro tdup1l_p {
                        __push      $02
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
        }

        macro tdup1l2_p {
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
        }

        macro tdup1l4_p {
                        __push      $04
                        vmovdqu     yword [rsp+$20], ymm0
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_z   $00,  (TAG_LONG4 shl $10)+(TAG_LONG4 shl $00)
        }

        macro tdup1l8_p {
                        __push      $08
                        vmovdqu64   zword [rsp+$40], zmm0
                        vmovdqu64   zword [rsp+$00], zmm0
                        __sttag_z   $04,  TAG_LONG8
                        __sttag_z   $00,  TAG_LONG8
        }
    ; </fold>

    ; <fold дублирование значения аккумулятора одним значением ниже на стаке, без дополнительного размещения значения>
        macro tdup1x1r {
                        tstincrcoth qsc0
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1e {
                        fld         esc0
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        mov         dword [rsp+$1c], $00
                        mov         word  [rsp+$1a], $00
                        fstp        tbyte [rsp+$10]
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1d {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1d2 {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1d4 {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqu     yword [rsp+$10], ymm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $01,  TAG_DOUBLE4
                        __sttag_x   $00,  TAG_OBJECT
        }

        macro tdup1x1d8 {
                        mov         qsc1, [rsp+$00]
                        __push      $04
                        vmovdqu64   zword [rsp+$10], zmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_z   $01,  TAG_DOUBLE8
                        __sttag_x   $00,  TAG_OBJECT
        }

        macro tdup1x1f {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1f2 {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1f4 {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1f8 {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqu     yword [rsp+$10], ymm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $01,  TAG_FLOAT8
                        __sttag_x   $00,  TAG_OBJECT
        }

        macro tdup1x1b2 {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1b4 {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1b8 {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1s2 {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1s4 {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1s8 {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1i {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1i2 {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1i4 {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1i8 {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqu     yword [rsp+$10], ymm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $01,  TAG_INT8
                        __sttag_x   $00,  TAG_OBJECT
        }

        macro tdup1x1l {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1l2 {
                        mov         qsc1, [rsp+$00]
                        __push      $01
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1l4 {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqu     yword [rsp+$10], ymm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $01,  TAG_LONG4
                        __sttag_x   $00,  TAG_OBJECT
        }

        macro tdup1x1l8 {
                        mov         qsc1, [rsp+$00]
                        __push      $04
                        vmovdqu64   zword [rsp+$10], zmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_z   $01,  TAG_LONG8
                        __sttag_x   $00,  TAG_OBJECT
        }
    ; </fold>

    ; <fold дублирование значения аккумулятора одним значением ниже на стаке, с дополнительным размещением значения>
        macro tdup1x1r_p {
                        tstincrcoth qsc0
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1e_p {
                        fld         esc0
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        mov         dword [rsp+$2c], $00
                        mov         word  [rsp+$2a], $00
                        fstp        tbyte [rsp+$20]
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        mov         dword [rsp+$0c], $00
                        mov         word  [rsp+$0a], $00
                        fstp        tbyte [rsp+$00]
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1d_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1d2_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1d4_p {
                        mov         qsc1, [rsp+$00]
                        __push      $04
                        vmovdqu     yword [rsp+$30], ymm0
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc1
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $03,  TAG_DOUBLE4
                        __sttag_x   $02,  TAG_OBJECT
                        __sttag_y   $00,  TAG_DOUBLE4
        }

        macro tdup1x1d8_p {
                        mov         qsc1, [rsp+$00]
                        __push      $08
                        vmovdqu64   zword [rsp+$50], zmm0
                        mov         qword [rsp+$48], $00
                        mov         qword [rsp+$40], qsc1
                        vmovdqu64   zword [rsp+$00], zmm0
                        __sttag_z   $05,  TAG_DOUBLE8
                        __sttag_x   $04,  TAG_OBJECT
                        __sttag_z   $00,  TAG_DOUBLE8
        }

        macro tdup1x1f_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1f2_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1f4_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1f8_p {
                        mov         qsc1, [rsp+$00]
                        __push      $04
                        vmovdqu     yword [rsp+$30], ymm0
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc1
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $03,  TAG_FLOAT8
                        __sttag_x   $02,  TAG_OBJECT
                        __sttag_y   $00,  TAG_FLOAT8
        }

        macro tdup1x1b2_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1b4_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1b8_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1s2_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1s4_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1s8_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1i_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1i2_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1i4_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1i8_p {
                        mov         qsc1, [rsp+$00]
                        __push      $04
                        vmovdqu     yword [rsp+$30], ymm0
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc1
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $03,  TAG_INT8
                        __sttag_x   $02,  TAG_OBJECT
                        __sttag_y   $00,  TAG_INT8
        }

        macro tdup1x1l_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1l2_p {
                        mov         qsc1, [rsp+$00]
                        __push      $02
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_y   $01,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup1x1l4_p {
                        mov         qsc1, [rsp+$00]
                        __push      $04
                        vmovdqu     yword [rsp+$30], ymm0
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc1
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $03,  TAG_LONG4
                        __sttag_x   $02,  TAG_OBJECT
                        __sttag_y   $00,  TAG_LONG4
        }

        macro tdup1x1l8_p {
                        mov         qsc1, [rsp+$00]
                        __push      $08
                        vmovdqu64   zword [rsp+$50], zmm0
                        mov         qword [rsp+$48], $00
                        mov         qword [rsp+$40], qsc1
                        vmovdqu64   zword [rsp+$00], zmm0
                        __sttag_z   $05,  TAG_LONG8
                        __sttag_x   $04,  TAG_OBJECT
                        __sttag_z   $00,  TAG_LONG8
        }
    ; </fold>

    ; <fold дублирование значения аккумулятора двумя значениями ниже на стаке, без дополнительного размещения значения>
        macro tdup1x2r {
                        tstincrcoth qsc0
                        _dup1x2lp   $01
                        mov         qword [rsp+r09*8+$08], $00
                        mov         qword [rsp+r09*8+$00], qsc0
        }

        macro tdup1x2e {
                        fld         esc0
                        _dup1x2lp   $01
                        mov         dword [rsp+r09*8+$0c], $00
                        mov         word  [rsp+r09*8+$0a], $00
                        fstp        tbyte [rsp+r09*8+$00]
                        __cltag_x   r08
        }

        macro tdup1x2d {
                        _dup1x2lp   $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2d2 {
                        _dup1x2lp   $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2d4 {
                        _dup1x2lp   $02
                        vmovdqu     yword [rsp+r09*8+$00], ymm0
                        __sttag_y   r08,  TAG_DOUBLE4
        }

        macro tdup1x2d8 {
                        _dup1x2lp   $04
                        vmovdqu64   zword [rsp+r09*8+$00], zmm0
                        __sttag_z   r08,  TAG_DOUBLE8
        }

        macro tdup1x2f {
                        _dup1x2lp   $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2f2 {
                        _dup1x2lp   $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2f4 {
                        _dup1x2lp   $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2f8 {
                        _dup1x2lp   $02
                        vmovdqu     yword [rsp+r09*8+$00], ymm0
                        __sttag_y   r08,  TAG_FLOAT8
        }

        macro tdup1x2b2 {
                        _dup1x2lp   $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2b4 {
                        _dup1x2lp   $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2b8 {
                        _dup1x2lp   $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2s2 {
                        _dup1x2lp   $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2s4 {
                        _dup1x2lp   $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2s8 {
                        _dup1x2lp   $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2i {
                        _dup1x2lp   $01
                        mov         qword [rsp+r09*8+$08], $00
                        mov         qword [rsp+r09*8+$00], qsc0
                        __cltag_x   r08
        }

        macro tdup1x2i2 {
                        _dup1x2lp   $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2i4 {
                        _dup1x2lp   $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2i8 {
                        _dup1x2lp   $02
                        vmovdqu     yword [rsp+r09*8+$00], ymm0
                        __sttag_y   r08,  TAG_INT8
        }

        macro tdup1x2l {
                        _dup1x2lp   $01
                        mov         qword [rsp+r09*8+$08], $00
                        mov         qword [rsp+r09*8+$00], qsc0
                        __cltag_x   r08
        }

        macro tdup1x2l2 {
                        _dup1x2lp   $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2l4 {
                        _dup1x2lp   $02
                        vmovdqu     yword [rsp+r09*8+$00], ymm0
                        __sttag_y   r08,  TAG_LONG4
        }

        macro tdup1x2l8 {
                        _dup1x2lp   $04
                        vmovdqu64   zword [rsp+r09*8+$00], zmm0
                        __sttag_z   r08,  TAG_LONG8
        }
    ; </fold>

    ; <fold дублирование значения аккумулятора двумя значениями ниже на стаке, с дополнительным размещением значения>
        macro tdup1x2r_p {
                        tstincrcoth qsc0
                        _dup1x2lp_p $01
                        mov         qword [rsp+r09*8+$08], $00
                        mov         qword [rsp+r09*8+$00], qsc0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
                        __sttag_x   $00,  TAG_OBJECT
        }

        macro tdup1x2e_p {
                        fld         esc0
                        _dup1x2lp_p $01
                        mov         dword [rsp+r09*8+$0c], $00
                        mov         word  [rsp+r09*8+$0a], $00
                        fstp        tbyte [rsp+r09*8+$00]
                        mov         dword [rsp+$0c], $00
                        mov         word  [rsp+$0a], $00
                        fstp        tbyte [rsp+$00]
                        __cltag_x   r08
        }

        macro tdup1x2d_p {
                        _dup1x2lp_p $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2d2_p {
                        _dup1x2lp_p $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2d4_p {
                        _dup1x2lp_p $02
                        vmovdqu     yword [rsp+r09*8+$00], ymm0
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   r08,  TAG_DOUBLE4
                        __sttag_y   $00,  TAG_DOUBLE4
        }

        macro tdup1x2d8_p {
                        _dup1x2lp_p $04
                        vmovdqu64   zword [rsp+r09*8+$00], zmm0
                        vmovdqu64   zword [rsp+$00], zmm0
                        __sttag_z   r08,  TAG_DOUBLE8
                        __sttag_z   $00,  TAG_DOUBLE8
        }

        macro tdup1x2f_p {
                        _dup1x2lp_p $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2f2_p {
                        _dup1x2lp_p $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2f4_p {
                        _dup1x2lp_p $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2f8_p {
                        _dup1x2lp_p $02
                        vmovdqu     yword [rsp+r09*8+$00], ymm0
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   r08,  TAG_FLOAT8
                        __sttag_y   $00,  TAG_FLOAT8
        }

        macro tdup1x2b2_p {
                        _dup1x2lp_p $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2b4_p {
                        _dup1x2lp_p $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2b8_p {
                        _dup1x2lp_p $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2s2_p {
                        _dup1x2lp_p $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2s4_p {
                        _dup1x2lp_p $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2s8_p {
                        _dup1x2lp_p $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2i_p {
                        _dup1x2lp_p $01
                        mov         qword [rsp+r09*8+$08], $00
                        mov         qword [rsp+r09*8+$00], qsc0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
                        __cltag_x   r08
        }

        macro tdup1x2i2_p {
                        _dup1x2lp_p $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2i4_p {
                        _dup1x2lp_p $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2i8_p {
                        _dup1x2lp_p $02
                        vmovdqu     yword [rsp+r09*8+$00], ymm0
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   r08,  TAG_INT8
                        __sttag_y   $00,  TAG_INT8
        }

        macro tdup1x2l_p {
                        _dup1x2lp_p $01
                        mov         qword [rsp+r09*8+$08], $00
                        mov         qword [rsp+r09*8+$00], qsc0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
                        __cltag_x   r08
        }

        macro tdup1x2l2_p {
                        _dup1x2lp_p $01
                        vmovdqa     xword [rsp+r09*8+$00], xmm0
                        vmovdqa     xword [rsp+$00], xmm0
                        __cltag_x   r08
        }

        macro tdup1x2l4_p {
                        _dup1x2lp_p $02
                        vmovdqu     yword [rsp+r09*8+$00], ymm0
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   r08,  TAG_LONG4
                        __sttag_y   $00,  TAG_LONG4
        }

        macro tdup1x2l8_p {
                        _dup1x2lp_p $04
                        vmovdqu64   zword [rsp+r09*8+$00], zmm0
                        vmovdqu64   zword [rsp+$00], zmm0
                        __sttag_z   r08,  TAG_LONG8
                        __sttag_z   $00,  TAG_LONG8
        }
    ; </fold>

    ; <fold дублирование двух значений на стаке: первое — из аккумулятора, второе — из стака; без дополнительного размещения значения>
        macro tdup2r {
                        _dup2
                        __push      $02
                        tstincrcoth qsc0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2e {
                        _dup2
                        __push      $02
                        fld         esc0
                        mov         dword [rsp+$1c], $00
                        mov         word  [rsp+$1a], $00
                        fstp        tbyte [rsp+$10]
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2d {
                        _dup2
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2d2 {
                        _dup2
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2d4 {
                        _dup2
                        __push      $03
                        vmovdqu     yword [rsp+$10], ymm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $01,  TAG_DOUBLE4
                        __sttag_x   $00,  TAG_OBJECT
        }

        macro tdup2d8 {
                        _dup2
                        __push      $05
                        vmovdqu64   zword [rsp+$10], zmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_z   $01,  TAG_DOUBLE8
                        __sttag_x   $00,  TAG_OBJECT
        }

        macro tdup2f {
                        _dup2
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2f2 {
                        _dup2
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2f4 {
                        _dup2
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2f8 {
                        _dup2
                        __push      $03
                        vmovdqu     yword [rsp+$10], ymm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $01,  TAG_FLOAT8
                        __sttag_x   $00,  TAG_OBJECT
        }

        macro tdup2b2 {
                        _dup2
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2b4 {
                        _dup2
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2b8 {
                        _dup2
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2s2 {
                        _dup2
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2s4 {
                        _dup2
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2s8 {
                        _dup2
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2i {
                        _dup2
                        __push      $02
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2i2 {
                        _dup2
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2i4 {
                        _dup2
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2i8 {
                        _dup2
                        __push      $03
                        vmovdqu     yword [rsp+$10], ymm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $01,  TAG_INT8
                        __sttag_x   $00,  TAG_OBJECT
        }

        macro tdup2l {
                        _dup2
                        __push      $02
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2l2 {
                        _dup2
                        __push      $02
                        vmovdqa     xword [rsp+$10], xmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $00,  (TAG_EMPTY shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2l4 {
                        _dup2
                        __push      $03
                        vmovdqu     yword [rsp+$10], ymm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_y   $01,  TAG_LONG4
                        __sttag_x   $00,  TAG_OBJECT
        }

        macro tdup2l8 {
                        _dup2
                        __push      $05
                        vmovdqu64   zword [rsp+$10], zmm0
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc1
                        __sttag_z   $01,  TAG_LONG8
                        __sttag_x   $00,  TAG_OBJECT
        }
    ; </fold>

    ; <fold дублирование двух значений на стаке: первое — из аккумулятора, второе — из стака; с дополнительным размещением значения>
        macro tdup2r_p {
                        _dup2
                        __push      $03
                        tstincrcoth qsc0
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
                        __sttag_x   $02,  TAG_OBJECT
                        __sttag_y   $00,  (TAG_OBJECT shl 8)+(TAG_OBJECT shl 0)
        }

        macro tdup2e_p {
                        _dup2
                        __push      $03
                        fld         esc0
                        mov         dword [rsp+$2c], $00
                        mov         word  [rsp+$2a], $00
                        fstp        tbyte [rsp+$20]
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        mov         dword [rsp+$0c], $00
                        mov         word  [rsp+$0a], $00
                        fstp        tbyte [rsp+$00]
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2d_p {
                        _dup2
                        __push      $03
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2d2_p {
                        _dup2
                        __push      $03
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2d4_p {
                        _dup2
                        __push      $05
                        vmovdqu     yword [rsp+$30], ymm0
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc1
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $03,  TAG_DOUBLE4
                        __sttag_x   $02,  TAG_OBJECT
                        __sttag_y   $00,  TAG_DOUBLE4
        }

        macro tdup2d8_p {
                        _dup2
                        __push      $09
                        vmovdqu64   zword [rsp+$50], zmm0
                        mov         qword [rsp+$48], $00
                        mov         qword [rsp+$40], qsc1
                        vmovdqu64   zword [rsp+$00], zmm0
                        __sttag_z   $05,  TAG_DOUBLE8
                        __sttag_x   $04,  TAG_OBJECT
                        __sttag_z   $00,  TAG_DOUBLE8
        }

        macro tdup2f_p {
                        _dup2
                        __push      $03
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2f2_p {
                        _dup2
                        __push      $03
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2f4_p {
                        _dup2
                        __push      $03
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2f8_p {
                        _dup2
                        __push      $05
                        vmovdqu     yword [rsp+$30], ymm0
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc1
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $03,  TAG_FLOAT8
                        __sttag_x   $02,  TAG_OBJECT
                        __sttag_y   $00,  TAG_FLOAT8
        }

        macro tdup2b2_p {
                        _dup2
                        __push      $03
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2b4_p {
                        _dup2
                        __push      $03
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2b8_p {
                        _dup2
                        __push      $03
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2s2_p {
                        _dup2
                        __push      $03
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2s4_p {
                        _dup2
                        __push      $03
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2s8_p {
                        _dup2
                        __push      $03
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2i_p {
                        _dup2
                        __push      $03
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2i2_p {
                        _dup2
                        __push      $03
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2i4_p {
                        _dup2
                        __push      $03
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2i8_p {
                        _dup2
                        __push      $05
                        vmovdqu     yword [rsp+$30], ymm0
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc1
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $03,  TAG_INT8
                        __sttag_x   $02,  TAG_OBJECT
                        __sttag_y   $00,  TAG_INT8
        }

        macro tdup2l_p {
                        _dup2
                        __push      $03
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        mov         qword [rsp+$08], $00
                        mov         qword [rsp+$00], qsc0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2l2_p {
                        _dup2
                        __push      $03
                        vmovdqa     xword [rsp+$20], xmm0
                        mov         qword [rsp+$18], $00
                        mov         qword [rsp+$10], qsc1
                        vmovdqa     xword [rsp+$00], xmm0
                        __sttag_x   $01,  TAG_OBJECT
        }

        macro tdup2l4_p {
                        _dup2
                        __push      $05
                        vmovdqu     yword [rsp+$30], ymm0
                        mov         qword [rsp+$28], $00
                        mov         qword [rsp+$20], qsc1
                        vmovdqu     yword [rsp+$00], ymm0
                        __sttag_y   $03,  TAG_LONG4
                        __sttag_x   $02,  TAG_OBJECT
                        __sttag_y   $00,  TAG_LONG4
        }

        macro tdup2l8_p {
                        _dup2
                        __push      $09
                        vmovdqu64   zword [rsp+$50], zmm0
                        mov         qword [rsp+$48], $00
                        mov         qword [rsp+$40], qsc1
                        vmovdqu64   zword [rsp+$00], zmm0
                        __sttag_z   $05,  TAG_LONG8
                        __sttag_x   $04,  TAG_OBJECT
                        __sttag_z   $00,  TAG_LONG8
        }
    ; </fold>
; </fold>