        jmp near dword [0]
        jmp far dword [0]

        mov bx,ax       ; general register to general register
        mov [char],al   ; general register to memory
        mov dl,32       ; immediate value to general register
        mov cr3,ebx     ; general register to control register

        xchg ax,bx      ; swap two general registers
        xchg al,[char]  ; swap register with memory

        push ax         ; store general register
        push es         ; store segment register
        pushw [bx]      ; store memory
        push 1000h      ; store immediate value

        imul ax,[si],10 ; memory by immediate value to register

        bt  ax,15        ; test bit in register
        bts word [bx],15 ; test and set bit in memory

        bswap edx        ; swap bytes in register

        jmp 100h         ; direct near jump
        jmp 0FFFFh:0     ; direct far jump
        jmp ax           ; indirect near jump
        jmp pword [ebx]  ; indirect far jump

        movs byte [di],[si]        ; transfer byte
        movs word [es:di],[ss:si]  ; transfer word
        movsd                      ; transfer double word

        cmpxchg8b [bx]   ; compare and exchange 8 bytes

        movq2dq xmm0,mm1   ; move from MMX register to SSE register
        movdq2q mm0,xmm1   ; move from SSE register to MMX register

        enter 2048,0     ; enter and allocate 2048 bytes on stack

        mov [rip+3],sil    ; manual RIP-relative addressing

        blendvps xmm3,xmm7,xmm0 ; blend according to mask
        vgatherqps xmm0,[xmm2],xmm3        ; gather two floats
        vgatherqps xmm0,[ymm2+64],xmm3     ; gather four floats
        vfmsub231ps ymm1,ymm2,ymm3     ; multiply and subtract
        vfnmadd132sd xmm0,xmm5,[ebx]   ; multiply, negate and add
        vpermil2ps ymm0,ymm3,ymm7,ymm2,0  ; permute from two sources

        vscatterdps [eax+xmm1]{k1},xmm0    ; scatter four floats
        vscatterdpd [ymm3*8]{k3},zmm0      ; scatter eight doubles

        dd sum
        x = 1
        x = x+2
        sum = x

        if count>0
            mov cx,count
            rep movsb
        end if

        if count & ~ count mod 4
            mov cx,count/4
            rep movsd
        else if count>4
            mov cx,count/4
            rep movsd
            mov cx,count mod 4
            rep movsb
        else
            mov cx,count
            rep movsb
        end if

        repeat 8
            mov byte [bx],%
            inc bx
        end repeat

        s = x/2
        repeat 100
            if x/s = s
                break
            end if
            s = (s+x/s)/2
        end repeat

        repeat $-$$
            load a byte from $$+%-1
            store byte a xor c at $$+%-1
        end repeat

        GDTR dp ?
        virtual at GDTR
            GDT_limit dw ?
            GDT_address dd ?
        end virtual

        virtual at 0
            file 'a.txt':10h,1
            load char from 0
        end virtual

        virtual at 0 as 'asc'
            times 256 db %-1
        end virtual

        virtual at 0
            hex_digits::
            db '0123456789ABCDEF'
        end virtual
        load a byte from hex_digits:10

        bits = 16
        display 'Current offset is 0x'
        repeat bits/4
            d = '0' + $ shr (bits-%*4) and 0Fh
            if d > '9'
                d = d + 'A'-'9'-1
            end if
            display d
        end repeat
        display 13,10

        if ~ defined alpha
            alpha:
        end if

        if ~ defined alpha | defined @f
            alpha:
            @@:
        end if

        include 'macros.inc'

        d equ dword
        NULL equ d 0
        d equ edx

        d equ d,eax

        b equ byte
        w equ word
        d equ dword
        p equ pword
        f equ fword
        q equ qword
        t equ tword
        x equ dqword
        y equ qqword

        incl fix include

        macro tst {test al,0xFF}

        macro stos0
         {
            xor al,al
            stosb
         }

        macro align value { rb (value-1)-($+value-1) mod value }

        macro mov op1,op2
         {
          if op1 in <ds,es,fs,gs,ss> & op2 in <cs,ds,es,fs,gs,ss>
            push  op2
            pop   op1
          else
            mov   op1,op2
          end if
         }

        macro stoschar [char]
         {
            mov al,char
            stosb
         }

        macro movstr
         {
            local move
          move:
            lodsb
            stosb
            test al,al
            jnz move
         }

        macro strtbl name,[string]
         {
          common
            label name dword
          forward
            local label
            dd label
          forward
            label db string,0
         }

        push 3
        push 2
        push 1
        call foo

        macro invoke proc,[arg]
         { common stdcall [proc],arg }

        macro jif op1,cond,op2,label
         {
            cmp op1,op2
            j#cond label
         }

        macro label name
         {
            label name
            if ~ used name
              display `name # " is defined but not used.",13,10
            end if
         }

        macro message arg
         {
          if arg eqtype ""
            local str
            jmp   @f
            str   db arg,0Dh,0Ah,24h
            @@:
            mov   dx,str
          else
            mov   dx,arg
          end if
            mov   ah,9
            int   21h
         }

        macro ext instr
         {
          macro instr op1,op2,op3
           \{
            if op3 eq
              instr op1,op2
            else
              instr op1,op2
              instr op2,op3
            end if
           \}
         }

        ext add
        ext sub

        macro tmacro [params]
         {
          common macro params {
         }
        MACRO fix tmacro
        ENDM fix }

        MACRO stoschar char
            mov al,char
            stosb
        ENDM

        postpone
         {
          code_size = $
         }

        struc point x,y
         {
            .x dw x
            .y dw y
         }

        struc db [data]
         {
           common
            . db data
            .size = $ - .
         }

        rept 5 { in al,dx }

        rept 3 counter
         {
            byte#counter db counter
         }

        match +,+ { include 'first.inc' }
        match +,- { include 'second.inc' }
        match a b, 1+2+3 { db a }

        V fix {
          macro empty
           V
        V fix }
           V

        list equ

        macro append item
         {
           match any, list \{ list equ list,item \}
           match , list \{ list equ item \}
         }

        define a b+4
        define b 3
        rept 1 result:a*b+2 { define c result }

        rept 8 n:0 { pxor xmm#n,xmm#n }

       irps reg, al bx ecx
        { xor reg,reg }

        if 0
        a = 1
        b equ 2
        end if
        dd b

        extrn exit
        extrn '__imp__MessageBoxA@16' as MessageBox:dword

        extrn 'printf' as _printf
        printf = PLT _printf

        tester? = 0

            space:
            space.x = 1
            space.y = 2
            space.color:
            space.color.r = 0
            space.color.g = 0
            space.color.b = 0

            space:
            namespace space
                    x = 1
                    y = 2
                    color:
                    .r = 0
                    .g = 0
                    .b = 0
            end namespace

            first:
                    .child = 1
                    ..other = 0
            second:
                    .child = 2
                    ..another = ..other

            label character:byte
            label char:1

            byte? = 1       ; 8 bits
            word? = 2       ; 16 bits
            dword? = 4      ; 32 bits
            fword? = 6      ; 48 bits
            pword? = 6      ; 48 bits
            qword? = 8      ; 64 bits
            tbyte? = 10     ; 80 bits
            tword? = 10     ; 80 bits
            dqword? = 16    ; 128 bits
            xword? = 16     ; 128 bits
            qqword? = 32    ; 256 bits
            yword? = 32     ; 256 bits
            dqqword? = 64   ; 512 bits
            zword? = 64     ; 512 bits

            element A
            linpoly = A + A + 3
            vterm = linpoly scale 1 * linpoly element 1     ; vterm = 2 * A

            db 4 dup 90h            ; generate 4 bytes
            db 2 dup ('abc',10)     ; generate 8 bytes

            macro measured name,string
                    local top
                    name db string
                    top: name.length = top - name
            end macro

            measured hello, 'Hello!'        ; hello.length = 6

            A equ 1
            A equ 2

            drop A
            drop A

            data1 dw 1
            buffer1 rb 10h          ; zeroed and present in the output

            org 400h
            data dw 2
            buffer2 rb 20h          ; not in the output

            section 1000h
            data3 dw 3
            buffer3 rb 30h          ; not in the output

            virtual at 0
                    hex_digits::
                    db '0123456789ABCDEF'
            end virtual
            load a:byte from hex_digits:10  ; a = 'A'

            db "Text"
            key = 7Bh
            repeat $-$$
                    load a : byte from $$+%-1
                    store a xor key : byte at $$+%-1
            end repeat

            load char : byte from const:0

            if $>10000h
                    err 'segment too large'
            end if
            calminstruction please? cmd&
                    match =do? =not? cmd, cmd
                    jyes done
                    assemble cmd
                done:
            end calminstruction

            please do not display 'Bye!'

            macro jmpi target
                    if target-($+2) < 80h & target-($+2) >= -80h
                            db 0EBh
                            db target-($+1)
                    else
                            db 0E9h
                            dw target-($+2)
                    end if
            end macro

            macro EX? first,second
                    match (=SP?), first
                            match =HL?, second
                                    db 0E3h
                            else match =IX?, second
                                    db 0DDh,0E3h
                            else match =IY?, second
                                    db 0FDh,0E3h
                            else
                                    err "incorrect second argument"
                            end match
                    else match =AF?, first
                            match =AF'?, second
                                    db 08h
                            else
                                    err "incorrect second argument"
                            end match
                    else match =DE?, first
                            match =HL?, second
                                    db 0EBh
                            else
                                    err "incorrect second argument"
                            end match
                    else
                            err "incorrect first argument"
                    end match
            end macro

            EX (SP),HL

            macro INC? argument
                    match [:r:], argument
                            db 100b + r shl 3
                    else match (=HL?), argument
                            db 34h
                    else match (=IX?+d), argument
                            db 0DDh,34h,d
                    else match (=IY?+d), argument
                            db 0FDh,34h,d
                    else
                            err "incorrect argument"
                    end match
            end macro

            INC (IX+2)

            element IY?

            element L? : register + 101b

            macro CALL? arguments&
                    local cc,nn
                    match condition =, target, arguments
                            cc = condition - CC
                            nn = target
                            db 0C4h + cc shl 3
                    else
                            nn = arguments
                            db 0CDh
                    end match
                    dw nn
            end macro