macro crypt str
{
  ...
}
someString db crypt "hello", 0    

someString db 'h' xor 10, 'e' xor 11, 'l' xor 12, 'l', xor 13, 'o' xor 14, 0    

struc crypt [def] {
common local b
  . def
  repeat $-.
    load b from .+%-1
    store b xor 10 at .+%-1
  end repeat
}
someString crypt db "hello"
  db 0    

struc crypt key, [def] {
common local b
  . def
  repeat $-.
    load b from .+%-1
    store b xor key at .+%-1
  end repeat
}

macro DeclareCryptStr name, key, dat
{
  db key
  name crypt key, db dat
  db 0
}    

struc reEqu [v] {
common; probably «v» contains «,»
  match _v, v \{; save «.» value to protect it from «restore»
    restore .
    . equ _v
  \}
  match , v \{; heh, «v» is empty
    restore .
    . equ
  \}
}

struc xcrypt [def*] {
common
  !mask equ 10; establish defaults
  !def equ def; unless «key=#» is used
local b
  match =key==mask _def, !def \{
    !mask reEqu mask; extract mask
    !def reEqu _def; and definition
  \}
  match _def, !def \{ . _def \}; guess why not plain «. !def» 
  repeat $-.
    load b from $-%; now do it backward 
    store b xor !mask at $-%
  end repeat
  restore !mask; clean up
  restore !def
}

macro xcrypt [def*] {; wrapper for unusual usage
local ..label
  ..label xcrypt def
}

cryptedString xcrypt key=11 db "hello"
  db 0

cryptedUnicodeString xcrypt key=12 du "hello"
  du 0

; Now «macro» takes its turn (label «letItBe» is optional, as you may guess)
letItBe: xcrypt key=13 db "hello"
  db 0