    ; Example file for nasm.xml kate syntax file
    ; compile with `nasm example.asm -f elf -o example.o`
    ; and link with 'gcc example.o -o example`
    ; Public domain
    ; kate: hl Intel x86 (NASM);

    section .data

    hello dd 'Hello World', 0x0A, 0h
    printf_param dd '%s', 0q

    section .text

    extern printf

    global main
    main:
    	push ebp
    	mov ebp, esp

    	push hello
    	push printf_param
    	call printf

    	mov eax, 0b
    	leave
    	ret

    NULL              EQU 0                         ; Constants
    STD_OUTPUT_HANDLE EQU -11

    extern GetStdHandle                             ; Import external symbols

    global Start                                    ; Export symbols. The entry point

    section .data                                   ; Initialized data segment
     Message        db "Console Message 64", 0Dh, 0Ah
     MessageLength  EQU $-Message                   ; Address of this line ($) - address of Message

    section .bss                                    ; Uninitialized data segment
    alignb 8
     Written        resq 1

    section .text                                   ; Code segment
    Start:
     sub   RSP, 8                                   ; Align the stack to a multiple of 16 bytes

     mov   ECX, STD_OUTPUT_HANDLE
     call  GetStdHandle
     mov   qword [REL StandardHandle], RAX

     sub   RSP, 32 + 8 + 8                          ; Shadow space + 5th parameter + align stack
                                                    ; to a multiple of 16 bytes
     mov   RCX, qword [REL StandardHandle]          ; 1st parameter
     lea   RDX, [REL Message]                       ; 2nd parameter
     mov   R8, MessageLength                        ; 3rd parameter
     mov   qword [RSP + 4 * 8], NULL                ; 5th parameter
                                                    ; Message Box, 64 bit. V1.02
    .DisplayMessageBox:
     xor   ECX, ECX                                 ; 1st parameter
     lea   RDX, [REL MessageBoxText]                ; 2nd parameter
     lea   R8, [REL MessageBoxCaption]              ; 3rd parameter
     mov   R9D, MB_YESNO | MB_DEFBUTTON2            ; 4th parameter. 2 constants ORed together
     call  MessageBoxA

     cmp   RAX, IDNO                                ; Check the return value for "No"
     je    .DisplayMessageBox

    extern _GetStdHandle@4                          ; Import external symbols
    Start:
     call  _WriteFile@20

    section .data                                   ; Initialized data segment
     Static1Colour    dd 0F0F0F0h,
     Edit2            resq 1

    %define Screen.Width       RBP - 160            ; 4 bytes
    %define ClientArea         RBP - 152            ; RECT structure. 16 bytes

     mov   dword [wc.cbSize], 80                    ; [RBP - 136]
     mov   dword [wc.style], CS_HREDRAW | CS_VREDRAW | CS_BYTEALIGNWINDOW  ; [RBP - 132]
     mov   qword [wc.lpfnWndProc], RAX              ; [RBP - 128]
     mov   qword [wc.hIcon], RAX                    ; [RBP - 104]
     mov   dword [RSP + 4 * 8], EAX                 ; X position, now centred

     cmp   qword [uMsg], WM_CLOSE                   ; [RBP + 24]
     je    WMCLOSE
     call  DestroyWindow                            ; Send a WM_DESTROY message
     jmp   Return.WM_Processed
     mov   EDX, 0604060h
     call  SetBkColor
     mov   EDX, 0005000h

    db 0x55 ; just the byte 0x55
    db 0x55,0x56,0x57 ; three bytes in succession
    db 'a',0x55 ; character constants are OK
    db 'hello',13,10,'$' ; so are string constants
    dw 0x1234 ; 0x34 0x12
    dw 'a' ; 0x61 0x00 (it's just a number)
    dw 'ab' ; 0x61 0x62 (character constant)
    dw 'abc' ; 0x61 0x62 0x63 0x00 (string)
    dd 0x12345678 ; 0x78 0x56 0x34 0x12
    dd 1.234567e20 ; floating-point constant
    dq 0x123456789abcdef0 ; eight byte constant
    dq 1.234567e20 ; double-precision float
    dt 1.234567e20 ; extended-precision float

    db 33
    db (44)               ; Integer expression
    ; db (44,55)            ; Invalid - error
    db %(44,55)
    db %('XX','YY')
    db ('AA')             ; Integer expression - outputs single byte
    db %('BB')            ; List, containing a string
    db ?
    db 6 dup (33)
    db 6 dup (33, 34)
    db 6 dup (33, 34), 35
    db 7 dup (99)
    db 7 dup dword (?, word ?, ?)
    dw byte (?,44)
    dw 3 dup (0xcc, 4 dup byte ('PQR'), ?), 0xabcd
    dd 16 dup (0xaaaa, ?, 0xbbbbbb)
    dd 64 dup (?)
    db `\u263a`            ; UTF-8 smiley face
    db `\xe2\x98\xba`      ; UTF-8 smiley face
    db 0E2h, 098h, 0BAh    ; UTF-8 smiley face
    buffer:         resb    64              ; reserve 64 bytes
    wordvar:        resw    1               ; reserve a word
    buffer:         db      64 dup (?)      ; reserve 64 bytes
    wordvar:        dw      ?               ; reserve a word

    incbin  "file.dat"             ; include the whole file
    incbin  "file.dat",1024        ; skip the first 1024 bytes
    incbin  "file.dat",1024,512    ; skip the first 1024, and
                                   ; actually include at most 512

    message         db      'hello, world'
    msglen          equ     $-message

    buffer: db      'hello, world'
            times 64-$+buffer db ' '

         bndstx [rbx*1+rax+0x3], bnd0    ; GAS - '*1' indecates an index reg
         VDIVPS zmm4, zmm5, dword [rbx]{1to16}   ; single-precision float
         VDIVPS zmm4, zmm5, zword [rbx]          ; packed 512 bit memory

    mov     ax,200          ; decimal
    mov     ax,0200         ; still decimal
    mov     ax,0200d        ; explicitly decimal
    mov     ax,0d200        ; also decimal
    mov     ax,0c8h         ; hex
    mov     ax,$0c8         ; hex again: the 0 is required
    mov     ax,0xc8         ; hex yet again
    mov     ax,0hc8         ; still hex
    mov     ax,310q         ; octal
    mov     ax,310o         ; octal again
    mov     ax,0o310        ; octal yet again
    mov     ax,0q310        ; octal yet again
    mov     ax,11001000b    ; binary
    mov     ax,1100_1000b   ; same binary constant
    mov     ax,1100_1000y   ; same binary constant once more
    mov     ax,0b1100_1000  ; same binary constant yet again
    mov     ax,0y1100_1000  ; same binary constant yet again

    %define u(x) __?utf16?__(x)
    %define w(x) __?utf32?__(x)

    dw u('C:\WINDOWS'), 0       ; Pathname in UTF-16
    dd w(`A + B = \u206a`), 0   ; String in UTF-32

    db    -0.2                    ; "Quarter precision"
    dw    -0.5                    ; IEEE 754r/SSE5 half precision
    dd    1.2                     ; an easy one
    dd    1.222_222_222           ; underscores are permitted
    dd    0x1p+2                  ; 1.0x2^2 = 4.0
    dq    0x1p+32                 ; 1.0x2^32 = 4 294 967 296.0
    dq    1.e10                   ; 10 000 000 000.0
    dq    1.e+10                  ; synonymous with 1.e10
    dq    1.e-10                  ; 0.000 000 000 1
    dt    3.141592653589793238462 ; pi
    do    1.e+4000                ; IEEE 754r quad precision

    mov    rax,__?float64?__(3.141592653589793238462)
    mov    rax,0x400921fb54442d18

    %define Inf __?Infinity?__
    %define NaN __?QNaN?__

    dq    +1.5, -Inf, NaN         ; Double-precision constants
    dt 12_345_678_901_245_678p
    dt -12_345_678_901_245_678p
    dt +0p33
    dt 33p

    dq b * (a // b) + (a %% b)

    call    (seg procedure):procedure
    call    weird_seg:(procedure wrt weird_seg)

    push dword 33
    push strict dword 33

    times (label-$) db 0

    label:  db      'Where am I?'
            times (label-$+1) db 0
    label:  db      'NOW where am I?'

    label1  ; some code

    .loop
            ; some more code

            jne     .loop
            ret

    label1:                         ; a non-local label
    .local:                         ; this is really label1.local
    ..@foo:                         ; this is a special symbol
    label2:                         ; another non-local label
    .local:                         ; this is really label2.local

            jmp     ..@foo          ; this will jump three lines up

    %define THIS_VERY_LONG_MACRO_NAME_IS_DEFINED_TO \
            THIS_VALUE

    %define ctrl    0x1F &
    %define param(a,b) ((a)+(a)*(b))

            mov     byte [param(2,ebx)], ctrl 'D'
            mov     byte [(2)+(2)*(ebx)], 0x1F & 'D'

    %define a(x)    1+b(x)
    %define b(x)    2*x

            mov     ax,a(8)

       %define foo (a,b)               ; no arguments, (a,b) is the expansion
       %define bar(a,b)                ; two arguments, empty expansion

       %define ereg(foo,) e %+ foo
         mov eax,ereg(dx,cx)

        %define xyzzy(=expr,&val) expr, str
        %define plugh(x) xyzzy(x,x)
        db plugh(3+5), `\0` ; Expands to: db 8, "3+5", `\0`

         mov ax,Foo%[__?BITS?__] ; The Foo value
    %xdefine Bar         Quux    ; Expands due to %xdefine
    %define  Bar         %[Quux] ; Expands due to %[...]

    %define BDASTART 400h                ; Start of BIOS data area

    struc   tBIOSDA                      ; its structure
            .COM1addr       RESW    1
            .COM2addr       RESW    1
            ; ..and so on
    endstruc

            mov     ax,BDASTART + tBIOSDA.COM1addr
            mov     bx,BDASTART + tBIOSDA.COM2addr
    ; Macro to access BIOS variables by their names (from tBDA):

    %idefine Foo mov %?,%??

    %idefine keyword $%?

    %idefine pause $%?                  ; Hide the PAUSE instruction
    %define foo bar
    %undef  foo

            mov     eax, foo
    %assign i i+1
    %defstr test TEST
    %define test 'TEST'
    %defstr PATH %!PATH          ; The operating system PATH variable

    %deftok test 'TEST'

    %define test TEST

    %define greedy(a,b,c+) a + 66 %, b * 3 %, c

           db greedy(1,2)          ; db 1 + 66, 2 * 3
           db greedy(1,2,3)        ; db 1 + 66, 2 * 3, 3
           db greedy(1,2,3,4)      ; db 1 + 66, 2 * 3, 3, 4
           db greedy(1,2,3,4,5)    ; db 1 + 66, 2 * 3, 3, 4, 5

    %macro  silly 2
        %2: db      %1
    %endmacro

            silly 'a', letter_a             ; letter_a:  db 'a'
            silly 'ab', string_ab           ; string_ab: db 'ab'
            silly {13,10}, crlf             ; crlf:      db 13,10
    %pragma preproc sane_empty_expansion

    %macro mpar 1-*
         db %{3:5}
         db %{-1:-3}
    %endmacro

    mpar 1,2,3,4,5,6

    %macro  die 0-1 "Painful program death has occurred."

            writefile 2,%1
            mov     ax,0x4c01
            int     0x21

    %endmacro

    %macro  multipush 1-*

      %rep  %0
            push    %1
      %rotate 1
      %endrep

            j%-1    %%skip
            ret
      %%skip:

    %endmacro

    %macro foo 1.nolist

    %endmacro

    %macro  pushparam 1

      %ifidni %1,ip
            call    %%label
      %%label:
      %else
            push    %1
      %endif

    %endmacro

    %assign i 0
    %rep    64
            inc     word [table+2*i]
    %assign i i+1
    %endrep

    fibonacci:
    %assign i 0
    %assign j 1
    %rep 100
    %if j > 65535
        %exitrep
    %endif
            dw j
    %assign k j+i
    %assign i j
    %assign j k
    %endrep

    fib_number equ ($-fibonacci)/2

    %include "macros.mac"

    %ifndef MACROS_MAC
        %define MACROS_MAC
        ; now define some macros
    %endif

    %pathsearch MyFoo "foo.bin"

    %imacro incbin 1-2+ 0
    %pathsearch dep %1
    %depend dep
            incbin dep,%2
    %endmacro
    %use altreg
    %use 'altreg'

    %push    foobar

    %macro repeat 0

        %push   repeat
        %$begin:

    %endmacro

    %macro until 1

            j%-1    %$begin
        %pop

    %endmacro

    %define %$localmac 3

    %macro else 0

      %ifctx if
            %repl   else
            jmp     %$ifend
            %$ifnot:
      %else
            %error  "expected `if' before `else'"
      %endif

    %endmacro

    %macro endif 0

      %ifctx if
            %$ifnot:
            %pop
      %elifctx      else
            %$ifend:
            %pop
      %else
            %error  "expected `if' or `else' before `endif'"
      %endif

    %endmacro

    some_function:
        %push mycontext             ; save the current context
        %stacksize small            ; tell NASM to use bp
        %assign %$localsize 0       ; see text for explanation
        %local old_ax:word, old_dx:word

            enter   %$localsize,0   ; see text for explanation
            mov     [old_ax],ax     ; swap ax & bx
            mov     cx,[old_dx]
            leave                   ; restore old bp
            ret                     ;

        %pop                        ; restore original context

    %ifdef F1
        ; do some setup
    %elifdef F2
        ; do some different setup
    %else
        %error "Neither F1 nor F2 was defined."
    %endif
    %ifdef F1
        ; do some setup
    %elifdef F2
        ; do some different setup
    %else
        %warning "Neither F1 nor F2 was defined, assuming F1."
        %define F1
    %endif%if foo > 64
        %assign foo_over foo-64
        %error foo is foo_over bytes too large
    %endif

            db      __?NASM_VER?__

    struc   mytype
      mt_long:      resd    1
      .str:         resb    32
    endstruc

    %use altreg

    %macro  writefile 2+

            [section .data]

      %%str:        db      %2
      %%endstr:

            __?SECT?__

            mov     dx,%%str
            mov     cx,%%endstr-%%str
            mov     bx,%1
            mov     ah,0x40
            int     0x21

    %endmacro

     DEFAULT BND
         call foo            ; BND will be prefixed
         nobnd call foo      ; BND will NOT be prefixed

    global _main
    _main:
    global  hashlookup:function, hashtable:data

    common  intvar  4
    static foo
    foo:
             ; codes

    %pragma macho lprefix L_
    ; The most common conventions
    %pragma output gprefix _
    %pragma output lprefix L_
    ; ELF uses a different convention
    %pragma elf    gprefix                       ; empty
    %pragma elf    lprefix .L

    section .pdata  rdata align=4
            dd      main wrt ..imagebase
            dd      main_end wrt ..imagebase
            dd      xmain wrt ..imagebase
    section .xdata  rdata align=8
    xmain:  db      9,0,0,0
            dd      handler wrt ..imagebase
    section .drectve info
            db      '/defaultlib:user32.lib /defaultlib:msvcrt.lib '