F run_utm(halt, state, Char blank; rules_in, [Char] &tape = [Char](); =pos = 0)
   V st = state
   I tape.empty
      tape.append(blank)
   I pos < 0
      pos += tape.len
   V rules = Dict(rules_in, r -> ((r[0], Char(string' r[1])), (Char(string' r[2]), r[3], r[4])))

   L
      print(st.ljust(4), end' ‘ ’)
      L(v) tape
         V i = L.index
         I i == pos
            print(‘[’v‘]’, end' ‘ ’)
         E
            print(v, end' ‘ ’)
      print()

      I st == halt
         L.break
      I (st, tape[pos]) !C rules
         L.break

      V (v1, dr, s1) = rules[(st, tape[pos])]
      tape[pos] = v1
      I dr == ‘left’
         I pos > 0
            pos--
         E
            tape.insert(0, blank)
      I dr == ‘right’
         pos++
         I pos >= tape.len
            tape.append(blank)
      st = s1

print("incr machine\n")
run_utm(
   halt' ‘qf’,
   state' ‘q0’,
   blank' Char(‘B’),
   rules_in' [‘q0 1 1 right q0’.split_sg(),
              ‘q0 B 1 stay  qf’.split_sg()],
   tape' &[‘1’, ‘1’, ‘1’]
   )

print("\nbusy beaver\n")
run_utm(
   halt' ‘halt’,
   state' ‘a’,
   blank' Char(‘0’),
   rules_in'
      [‘a 0 1 right b’.split_sg(),
       ‘a 1 1 left  c’.split_sg(),
       ‘b 0 1 left  a’.split_sg(),
       ‘b 1 1 right b’.split_sg(),
       ‘c 0 1 left  b’.split_sg(),
       ‘c 1 1 stay  halt’.split_sg()]
   )

print("\nsorting test\n")
run_utm(
   halt' ‘STOP’,
   state' ‘A’,
   blank' Char(‘0’),
   rules_in'
      [‘A 1 1 right A’.split_sg(),
       ‘A 2 3 right B’.split_sg(),
       ‘A 0 0 left  E’.split_sg(),
       ‘B 1 1 right B’.split_sg(),
       ‘B 2 2 right B’.split_sg(),
       ‘B 0 0 left  C’.split_sg(),
       ‘C 1 2 left  D’.split_sg(),
       ‘C 2 2 left  C’.split_sg(),
       ‘C 3 2 left  E’.split_sg(),
       ‘D 1 1 left  D’.split_sg(),
       ‘D 2 2 left  D’.split_sg(),
       ‘D 3 1 right A’.split_sg(),
       ‘E 1 1 left  E’.split_sg(),
       ‘E 0 0 right STOP’.split_sg()],
   tape' &‘2 2 2 1 2 2 1 2 1 2 1 2 1 2’.split(‘ ’).map(Char)
   )