global {
  type void = void
  type int8 = int8
  type uint8 = uint8
  type int16 = int16
  type uint16 = uint16
  type int32 = int32
  type uint32 = uint32
  type int64 = int64
  type uint64 = uint64
  type float = float
  type sfloat = sfloat
  type lfloat = lfloat
  type byte = int8
  type short = int16
  type int = int32
  type long = int64
  type ubyte = uint8
  type ushort = uint16
  type uint = uint32
  type ulong = uint64
  type bool = bool
  type char = char
  type cstr = char[]
  proc void print (char[]);
  proc void wait (uint32);
  proc uint32 count (int32[]);
  proc float now ();
  proc int32[] alloc (uint32);
  proc void putchar (char);
  proc int32& min (int32[]);
  const char nl = '\x0A'

  float fak (float)
  {
    IF
      le
        vref &n: float&
        ival 1: float
      RETURN
        ival 1: float
    ELSE
      RETURN
        mul
          call fak: float(float)
            sub
              vref &n: float&
              ival 1: float
          vref &n: float&
  }

  void print (int32[])
  {
    call print: void(int32[])
      ival "{": char[]
    IF
      call count: uint32(int32[])
        vref &a: int32[]&
      {
        var uint32 i
        call print: void(int32[])
          ati
            ival 0: uint16
        var uint32 i = 
          ival 0: uint16
        DO
          {
            WHILE
              lt
                pre_incr
                  vref &i: uint32&
                call count: uint32(int32[])
                  vref &a: int32[]&
            call print: void(int32[])
              ival ", ": char[]
            call print: void(int32[])
              ati
                vref &i: uint32&
          }
      }
    call print: void(int32[])
      ival "}\n": char[]
  }
  var float ta
  var float dt
  var float te
  var char[] s
  var int32 si
  var float st

  int32[] add (int32[],int32)
  {
    var uint32 i
    var int32[] r
    var uint32 i = 
      call count: uint32(int32[])
        vref &a: int32[]&
    DO
      {
        WHILE
          postdecr
            vref &i: uint32&
        +=
          ati
            vref &i: uint32&
          cast 
            vref &n: int32&
      }
    RETURN
      vref &r: int32[]&
  }
  var int32 i
  call print: void(char[])
    ival "\nhi, i'm vicci!\n": char[]
  call print: void(char[])
    ival "and i'm incredibly fast! ...\n": char[]
  call wait: void(uint32)
    ival 1: uint16
  call print: void(char[])
    ival "\nlet's make the test.": char[]
  call print: void(char[])
    ival "\ncalculating... ": char[]
  var float ta = 
    call now: float()
  var float dt = 
    ival 10: uint16
  var float te = 
    add
      call now: float()
      vref &dt: float&
  var char[] s = 
    ival "|/-\\": char[]
  var int32 si = 
    ival 0: uint16
  var float st = 
    vref &ta: float&
  var int32 i = 
    ival 0: uint16
  DO
    {
      var int32[] l
      var int32[] z
      var char[] z
      var int32 j
      var int32[] l = (null)
      var int32[] z = (null)
      WHILE
        lt
          call now: float()
          vref &te: float&
      incr
        vref &i: int32&
      IF
        gt
          call now: float()
          vref &st: float&
        {
          +=
            vref &st: float&
            ival 0.1: float
          call putchar: void(char)
            ati
              rem
                postincr
                  vref &si: int32&
                ival 4: uint16
          call print: void(int32[])
            ival "\b": char[]
        }
      +=
        vref &l: int32[]&
        call add: int32[](int32[],int32)
          vref &l: int32[]&
          ival 10: uint16
      +=
        vref &l: int32[]&
        call add: int32[](int32[],int32)
          vref &l: int32[]&
          ival 20: uint16
      +=
        vref &l: int32[]&
        call add: int32[](int32[],int32)
          vref &l: int32[]&
          ival 40: uint16
      +=
        vref &l: int32[]&
        call add: int32[](int32[],int32)
          vref &l: int32[]&
          ival 80: uint16
      IF
        ne
          call min: int32&(int32[])
            vref &l: int32[]&
          ival 0: uint16
        {
          call print: void(int32[])
            ival "booboo1\n": char[]
        }
      IF
        ne
          vref &z: int32[]&
          vref &l: int32[]&
        {
          call print: void(int32[])
            ival "booboo3\n": char[]
          call print: void(int32[])
            vref &z: int32[]&
          call putchar: void(char)
            ival '\x0A': char
        }
      var char[] z = 
        ival "": char[]
      var int32 j = 
        ival 0: uint16
      DO
        {
          WHILE
            lt
              vref &j: int32&
              ival 100: uint16
        }
    }
  call print: void(int32[])
    ival " \n": char[]
  call print: void(int32[])
    ival "unbelievable...\n": char[]
}