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