   end
 
   # true/false constants
-  def compute([ "FALSE" | remaining_input], data_stack, return_stack, dict) do
-    compute(remaining_input, [0 | data_stack], return_stack, dict)
-  end
-  def compute([ "false" | remaining_input], data_stack, return_stack, dict) do
-    compute(remaining_input, [0 | data_stack], return_stack, dict)
-  end
-
-  def compute([ "TRUE" | remaining_input], data_stack, return_stack, dict) do
-    compute(remaining_input, [-1 | data_stack], return_stack, dict)
-  end
-  def compute([ "true" | remaining_input], data_stack, return_stack, dict) do
-    compute(remaining_input, [-1 | data_stack], return_stack, dict)
-  end
-
-  def compute([ "AND" | remaining_input], [y, x | data_stack], return_stack, dict) do
-    out = if ((y != 0) and (x != 0)), do: -1, else: 0
-    compute(remaining_input, [out | data_stack], return_stack, dict)
-  end
-  def compute([ "and" | remaining_input], [y, x | data_stack], return_stack, dict) do
-    out = if ((y != 0) and (x != 0)), do: -1, else: 0
-    compute(remaining_input, [out | data_stack], return_stack, dict)
-  end
-
-  def compute([ "OR" | remaining_input], [y, x | data_stack], return_stack, dict) do
-    out = if ((y != 0) or (x != 0)), do: -1, else: 0
-    compute(remaining_input, [out | data_stack], return_stack, dict)
-  end
-  def compute([ "or" | remaining_input], [y, x | data_stack], return_stack, dict) do
-    out = if ((y != 0) or (x != 0)), do: -1, else: 0
-    compute(remaining_input, [out | data_stack], return_stack, dict)
-  end
-
-  def compute([ "NOT" | remaining_input], [0 | data_stack], return_stack, dict) do
-    compute(remaining_input, [-1 | data_stack], return_stack, dict)
-  end
-  def compute([ "not" | remaining_input], [0 | data_stack], return_stack, dict) do
-    compute(remaining_input, [-1 | data_stack], return_stack, dict)
-  end
-  def compute([ "NOT" | remaining_input], [_truthy | data_stack], return_stack, dict) do
-    compute(remaining_input, [0 | data_stack], return_stack, dict)
-  end
-  def compute([ "not" | remaining_input], [_truthy | data_stack], return_stack, dict) do
-    compute(remaining_input, [0 | data_stack], return_stack, dict)
-  end
-
-  def compute([ "INVERT" | remaining_input], [0 | data_stack], return_stack, dict) do
-    compute(remaining_input, [-1 | data_stack], return_stack, dict)
-  end
-  def compute([ "invert" | remaining_input], [0 | data_stack], return_stack, dict) do
-    compute(remaining_input, [-1 | data_stack], return_stack, dict)
-  end
-  def compute([ "INVERT" | remaining_input], [_truthy | data_stack], return_stack, dict) do
-    compute(remaining_input, [0 | data_stack], return_stack, dict)
-  end
-  def compute([ "invert" | remaining_input], [_truthy | data_stack], return_stack, dict) do
-    compute(remaining_input, [0 | data_stack], return_stack, dict)
+  inanycase :false, fn funcname ->
+    def compute([ unquote(funcname) | remaining_input], data_stack, return_stack, dict) do
+      compute(remaining_input, [0 | data_stack], return_stack, dict)
+    end
+  end
+
+  inanycase :true, fn funcname ->
+    def compute([ unquote(funcname) | remaining_input], data_stack, return_stack, dict) do
+      compute(remaining_input, [-1 | data_stack], return_stack, dict)
+    end
+  end
+
+  inanycase :and, fn funcname ->
+    def compute([ unquote(funcname) | remaining_input], [y, x | data_stack], return_stack, dict) do
+      out = if ((y != 0) and (x != 0)), do: -1, else: 0
+      compute(remaining_input, [out | data_stack], return_stack, dict)
+    end
+  end
+
+  inanycase :or, fn funcname ->
+    def compute([ unquote(funcname) | remaining_input], [y, x | data_stack], return_stack, dict) do
+      out = if ((y != 0) or (x != 0)), do: -1, else: 0
+      compute(remaining_input, [out | data_stack], return_stack, dict)
+    end
+  end
+
+  inanycase :not, fn funcname ->
+    def compute([ unquote(funcname) | remaining_input], [0 | data_stack], return_stack, dict) do
+      compute(remaining_input, [-1 | data_stack], return_stack, dict)
+    end
+  end
+  inanycase :not, fn funcname ->
+    def compute([ unquote(funcname) | remaining_input], [_truthy | data_stack], return_stack, dict) do
+      compute(remaining_input, [0 | data_stack], return_stack, dict)
+    end
+  end
+
+  inanycase :invert, fn funcname ->
+    def compute([ unquote(funcname) | remaining_input], [0 | data_stack], return_stack, dict) do
+      compute(remaining_input, [-1 | data_stack], return_stack, dict)
+    end
+  end
+  inanycase :invert, fn funcname ->
+    def compute([ unquote(funcname) | remaining_input], [_truthy | data_stack], return_stack, dict) do
+      compute(remaining_input, [0 | data_stack], return_stack, dict)
+    end
   end
 
   # Rotation

    data_stack
  end

  def compute([ "END" | _ ], [last_elem_in_data_stack], [], _) do
    last_elem_in_data_stack
  end
  def compute([ "end" | _ ], [last_elem_in_data_stack], [], _) do
    last_elem_in_data_stack
  end

  def compute([ "END" | _ ], data_stack, [], _) when is_list(data_stack) do
    data_stack
  end
  def compute([ "end" | _ ], data_stack, [], _) when is_list(data_stack) do
    data_stack
  end

# If-Else-Then

  # puts then-clause on top of instruction data_stack if test_val != 0, else-clause if test_val == 0.

  # closing condition: a THEN is encountered, and there is an if-else-state on the return stack
  inanycase :then, fn funcname ->
    def compute([ unquote(funcname) | remaining_input ], data_stack, [0, %{if: _if_stack, else: else_stack} | return_stack], dict) do
      compute(dump_stack_onto_stack(else_stack, remaining_input), data_stack, return_stack, dict)
    end
  end
  inanycase :then, fn funcname ->
    def compute([ unquote(funcname) | remaining_input ], data_stack, [_truthy, %{if: if_stack, else: _else_stack} | return_stack], dict) do
      compute(dump_stack_onto_stack(if_stack, remaining_input), data_stack, return_stack, dict)
    end
  end
  # closing condition: a THEN is encountered, and there is an if-state on the return stack
  inanycase :then, fn funcname ->
    def compute([ unquote(funcname) | remaining_input ], data_stack, [0, %{if: _if_stack} | return_stack], dict) do
      compute(remaining_input, data_stack, return_stack, dict)
    end
  end
  inanycase :then, fn funcname ->
    def compute([ unquote(funcname) | remaining_input ], data_stack, [_truthy, %{if: if_stack} | return_stack], dict) do
      compute(dump_stack_onto_stack(if_stack, remaining_input), data_stack, return_stack, dict)
    end
  end

  # accumulate if-instructions or else-instructions on return stack (until a THEN is encountered, which should match above)
