Warning, /frameworks/syntax-highlighting/autotests/input/highlight.asm-fasm is written in an unsupported language. File is not indexed.

     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