diff --git a/code.jaa b/code.cs
similarity index 96%
rename from code.jaa
rename to code.cs
index 7ddbcaad..caafc386 100644
--- a/code.jaa
+++ b/code.cs
@@ -1,4 +1,4 @@
-# TODO: Think of a name for this crazy thing.
+# TODO: Add range indexing: array[5..7] => array.slice(5, 7)
 
 # Functions:
 square: x => x * x.
diff --git a/documents.jaa b/documents.cs
similarity index 100%
rename from documents.jaa
rename to documents.cs
diff --git a/lexer_test.rb b/lexer_test.rb
index 0a1334a5..7821295d 100644
--- a/lexer_test.rb
+++ b/lexer_test.rb
@@ -1,2 +1,2 @@
 require "lexer"
-p Lexer.new.tokenize(File.read('code.jaa'))
+p Lexer.new.tokenize(File.read('code.cs'))
diff --git a/parser.rb b/parser.rb
index d32664f5..b3119306 100644
--- a/parser.rb
+++ b/parser.rb
@@ -11,7 +11,7 @@ require 'racc/parser.rb'
 
 class Parser < Racc::Parser
 
-module_eval(<<'...end grammar.y/module_eval...', 'grammar.y', 312)
+module_eval(<<'...end grammar.y/module_eval...', 'grammar.y', 314)
   def parse(code, show_tokens=false)
     # @yydebug = true
     @tokens = Lexer.new.tokenize(code)
@@ -766,49 +766,49 @@ Racc_debug_parser = false
 
 # reduce 0 omitted
 
-module_eval(<<'.,.,', 'grammar.y', 36)
+module_eval(<<'.,.,', 'grammar.y', 38)
   def _reduce_1(val, _values, result)
      result = Nodes.new([]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 37)
+module_eval(<<'.,.,', 'grammar.y', 39)
   def _reduce_2(val, _values, result)
      result = Nodes.new([]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 38)
+module_eval(<<'.,.,', 'grammar.y', 40)
   def _reduce_3(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 43)
+module_eval(<<'.,.,', 'grammar.y', 45)
   def _reduce_4(val, _values, result)
      result = Nodes.new(val) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 44)
+module_eval(<<'.,.,', 'grammar.y', 46)
   def _reduce_5(val, _values, result)
      result = val[0] << val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 45)
+module_eval(<<'.,.,', 'grammar.y', 47)
   def _reduce_6(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 46)
+module_eval(<<'.,.,', 'grammar.y', 48)
   def _reduce_7(val, _values, result)
      result = val[1] 
     result
@@ -849,672 +849,672 @@ module_eval(<<'.,.,', 'grammar.y', 46)
 
 # reduce 24 omitted
 
-module_eval(<<'.,.,', 'grammar.y', 80)
+module_eval(<<'.,.,', 'grammar.y', 82)
   def _reduce_25(val, _values, result)
      result = LiteralNode.new(val[0]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 81)
+module_eval(<<'.,.,', 'grammar.y', 83)
   def _reduce_26(val, _values, result)
      result = LiteralNode.new(val[0]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 82)
+module_eval(<<'.,.,', 'grammar.y', 84)
   def _reduce_27(val, _values, result)
      result = LiteralNode.new(val[0]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 83)
+module_eval(<<'.,.,', 'grammar.y', 85)
   def _reduce_28(val, _values, result)
      result = LiteralNode.new(val[0]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 84)
+module_eval(<<'.,.,', 'grammar.y', 86)
   def _reduce_29(val, _values, result)
      result = LiteralNode.new(true) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 85)
+module_eval(<<'.,.,', 'grammar.y', 87)
   def _reduce_30(val, _values, result)
      result = LiteralNode.new(false) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 86)
+module_eval(<<'.,.,', 'grammar.y', 88)
   def _reduce_31(val, _values, result)
      result = LiteralNode.new(nil) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 87)
+module_eval(<<'.,.,', 'grammar.y', 89)
   def _reduce_32(val, _values, result)
      result = LiteralNode.new(val[0]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 88)
+module_eval(<<'.,.,', 'grammar.y', 90)
   def _reduce_33(val, _values, result)
      result = LiteralNode.new(val[0]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 93)
+module_eval(<<'.,.,', 'grammar.y', 95)
   def _reduce_34(val, _values, result)
      result = AssignNode.new(val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 98)
+module_eval(<<'.,.,', 'grammar.y', 100)
   def _reduce_35(val, _values, result)
      result = AssignNode.new(val[0], val[2], :object) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 103)
+module_eval(<<'.,.,', 'grammar.y', 105)
   def _reduce_36(val, _values, result)
      result = ReturnNode.new(val[1]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 110)
+module_eval(<<'.,.,', 'grammar.y', 112)
   def _reduce_37(val, _values, result)
      result = OpNode.new(val[0], val[1]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 111)
+module_eval(<<'.,.,', 'grammar.y', 113)
   def _reduce_38(val, _values, result)
      result = OpNode.new(val[0], val[1]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 112)
+module_eval(<<'.,.,', 'grammar.y', 114)
   def _reduce_39(val, _values, result)
      result = OpNode.new(val[0], val[1]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 115)
+module_eval(<<'.,.,', 'grammar.y', 117)
   def _reduce_40(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 116)
+module_eval(<<'.,.,', 'grammar.y', 118)
   def _reduce_41(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 117)
+module_eval(<<'.,.,', 'grammar.y', 119)
   def _reduce_42(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 119)
+module_eval(<<'.,.,', 'grammar.y', 121)
   def _reduce_43(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 120)
+module_eval(<<'.,.,', 'grammar.y', 122)
   def _reduce_44(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 122)
+module_eval(<<'.,.,', 'grammar.y', 124)
   def _reduce_45(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 123)
+module_eval(<<'.,.,', 'grammar.y', 125)
   def _reduce_46(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 124)
+module_eval(<<'.,.,', 'grammar.y', 126)
   def _reduce_47(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 125)
+module_eval(<<'.,.,', 'grammar.y', 127)
   def _reduce_48(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 127)
+module_eval(<<'.,.,', 'grammar.y', 129)
   def _reduce_49(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 128)
+module_eval(<<'.,.,', 'grammar.y', 130)
   def _reduce_50(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 129)
+module_eval(<<'.,.,', 'grammar.y', 131)
   def _reduce_51(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 130)
+module_eval(<<'.,.,', 'grammar.y', 132)
   def _reduce_52(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 132)
+module_eval(<<'.,.,', 'grammar.y', 134)
   def _reduce_53(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 133)
+module_eval(<<'.,.,', 'grammar.y', 135)
   def _reduce_54(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 134)
+module_eval(<<'.,.,', 'grammar.y', 136)
   def _reduce_55(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 135)
+module_eval(<<'.,.,', 'grammar.y', 137)
   def _reduce_56(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 137)
+module_eval(<<'.,.,', 'grammar.y', 139)
   def _reduce_57(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 138)
+module_eval(<<'.,.,', 'grammar.y', 140)
   def _reduce_58(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 139)
+module_eval(<<'.,.,', 'grammar.y', 141)
   def _reduce_59(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 140)
+module_eval(<<'.,.,', 'grammar.y', 142)
   def _reduce_60(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 141)
+module_eval(<<'.,.,', 'grammar.y', 143)
   def _reduce_61(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 142)
+module_eval(<<'.,.,', 'grammar.y', 144)
   def _reduce_62(val, _values, result)
      result = OpNode.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 148)
+module_eval(<<'.,.,', 'grammar.y', 150)
   def _reduce_63(val, _values, result)
      result = CodeNode.new(val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 149)
+module_eval(<<'.,.,', 'grammar.y', 151)
   def _reduce_64(val, _values, result)
      result = CodeNode.new([], val[1]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 153)
+module_eval(<<'.,.,', 'grammar.y', 155)
   def _reduce_65(val, _values, result)
      result = val 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 154)
+module_eval(<<'.,.,', 'grammar.y', 156)
   def _reduce_66(val, _values, result)
      result = val[0] << val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 158)
+module_eval(<<'.,.,', 'grammar.y', 160)
   def _reduce_67(val, _values, result)
      result = ValueNode.new(val) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 159)
+module_eval(<<'.,.,', 'grammar.y', 161)
   def _reduce_68(val, _values, result)
      result = ValueNode.new(val) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 160)
+module_eval(<<'.,.,', 'grammar.y', 162)
   def _reduce_69(val, _values, result)
      result = ValueNode.new(val) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 161)
+module_eval(<<'.,.,', 'grammar.y', 163)
   def _reduce_70(val, _values, result)
      result = ValueNode.new(val) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 162)
+module_eval(<<'.,.,', 'grammar.y', 164)
   def _reduce_71(val, _values, result)
      result = val[0] << val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 163)
+module_eval(<<'.,.,', 'grammar.y', 165)
   def _reduce_72(val, _values, result)
      result = ValueNode.new(val[0], [val[1]]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 167)
+module_eval(<<'.,.,', 'grammar.y', 169)
   def _reduce_73(val, _values, result)
      result = AccessorNode.new(val[1]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 168)
+module_eval(<<'.,.,', 'grammar.y', 170)
   def _reduce_74(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 172)
+module_eval(<<'.,.,', 'grammar.y', 174)
   def _reduce_75(val, _values, result)
      result = IndexNode.new(val[1]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 176)
+module_eval(<<'.,.,', 'grammar.y', 178)
   def _reduce_76(val, _values, result)
      result = ObjectNode.new([]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 177)
+module_eval(<<'.,.,', 'grammar.y', 179)
   def _reduce_77(val, _values, result)
      result = ObjectNode.new(val[1]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 181)
+module_eval(<<'.,.,', 'grammar.y', 183)
   def _reduce_78(val, _values, result)
      result = []
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 182)
+module_eval(<<'.,.,', 'grammar.y', 184)
   def _reduce_79(val, _values, result)
      result = val 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 183)
+module_eval(<<'.,.,', 'grammar.y', 185)
   def _reduce_80(val, _values, result)
      result = val[0] << val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 184)
+module_eval(<<'.,.,', 'grammar.y', 186)
   def _reduce_81(val, _values, result)
      result = val[0] << val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 189)
+module_eval(<<'.,.,', 'grammar.y', 191)
   def _reduce_82(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 190)
+module_eval(<<'.,.,', 'grammar.y', 192)
   def _reduce_83(val, _values, result)
      result = val[1].new_instance 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 194)
+module_eval(<<'.,.,', 'grammar.y', 196)
   def _reduce_84(val, _values, result)
      result = CallNode.new(val[0], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 199)
+module_eval(<<'.,.,', 'grammar.y', 201)
   def _reduce_85(val, _values, result)
      result = ArrayNode.new(val[1]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 204)
+module_eval(<<'.,.,', 'grammar.y', 206)
   def _reduce_86(val, _values, result)
      result = [] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 205)
+module_eval(<<'.,.,', 'grammar.y', 207)
   def _reduce_87(val, _values, result)
      result = val 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 206)
+module_eval(<<'.,.,', 'grammar.y', 208)
   def _reduce_88(val, _values, result)
      result = val[0] << val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 207)
+module_eval(<<'.,.,', 'grammar.y', 209)
   def _reduce_89(val, _values, result)
      result = val[0] << val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 212)
+module_eval(<<'.,.,', 'grammar.y', 214)
   def _reduce_90(val, _values, result)
      result = IfNode.new(val[1], val[3]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 215)
+module_eval(<<'.,.,', 'grammar.y', 217)
   def _reduce_91(val, _values, result)
      result = IfNode.new(val[1], val[3], val[5]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 216)
+module_eval(<<'.,.,', 'grammar.y', 218)
   def _reduce_92(val, _values, result)
      result = IfNode.new(val[2], Nodes.new([val[0]])) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 217)
+module_eval(<<'.,.,', 'grammar.y', 219)
   def _reduce_93(val, _values, result)
      result = IfNode.new(val[2], Nodes.new([val[0]]), nil, :invert) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 222)
+module_eval(<<'.,.,', 'grammar.y', 224)
   def _reduce_94(val, _values, result)
      result = TryNode.new(val[1], val[3], val[4]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 224)
+module_eval(<<'.,.,', 'grammar.y', 226)
   def _reduce_95(val, _values, result)
      result = TryNode.new(val[1], nil, nil, val[3]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 227)
+module_eval(<<'.,.,', 'grammar.y', 229)
   def _reduce_96(val, _values, result)
      result = TryNode.new(val[1], val[3], val[4], val[6]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 231)
+module_eval(<<'.,.,', 'grammar.y', 233)
   def _reduce_97(val, _values, result)
      result = ThrowNode.new(val[1]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 235)
+module_eval(<<'.,.,', 'grammar.y', 237)
   def _reduce_98(val, _values, result)
      result = ParentheticalNode.new(val[1]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 240)
+module_eval(<<'.,.,', 'grammar.y', 242)
   def _reduce_99(val, _values, result)
      result = WhileNode.new(val[1], val[3]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 245)
+module_eval(<<'.,.,', 'grammar.y', 247)
   def _reduce_100(val, _values, result)
      result = ForNode.new(val[0], val[4], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 248)
+module_eval(<<'.,.,', 'grammar.y', 250)
   def _reduce_101(val, _values, result)
      result = ForNode.new(val[0], val[6], val[2], val[4]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 251)
+module_eval(<<'.,.,', 'grammar.y', 253)
   def _reduce_102(val, _values, result)
      result = ForNode.new(IfNode.new(val[6], Nodes.new([val[0]])), val[4], val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 255)
+module_eval(<<'.,.,', 'grammar.y', 257)
   def _reduce_103(val, _values, result)
      result = ForNode.new(IfNode.new(val[8], Nodes.new([val[0]])), val[6], val[2], val[4]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 260)
+module_eval(<<'.,.,', 'grammar.y', 262)
   def _reduce_104(val, _values, result)
      result = val[3].rewrite_condition(val[1]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 262)
+module_eval(<<'.,.,', 'grammar.y', 264)
   def _reduce_105(val, _values, result)
      result = val[3].rewrite_condition(val[1]).add_default(val[5]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 266)
+module_eval(<<'.,.,', 'grammar.y', 268)
   def _reduce_106(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 267)
+module_eval(<<'.,.,', 'grammar.y', 269)
   def _reduce_107(val, _values, result)
      result = val[0] << val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 271)
+module_eval(<<'.,.,', 'grammar.y', 273)
   def _reduce_108(val, _values, result)
      result = IfNode.new(val[1], val[3]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 275)
+module_eval(<<'.,.,', 'grammar.y', 277)
   def _reduce_109(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 276)
+module_eval(<<'.,.,', 'grammar.y', 278)
   def _reduce_110(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 280)
+module_eval(<<'.,.,', 'grammar.y', 282)
   def _reduce_111(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 281)
+module_eval(<<'.,.,', 'grammar.y', 283)
   def _reduce_112(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 285)
+module_eval(<<'.,.,', 'grammar.y', 287)
   def _reduce_113(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 286)
+module_eval(<<'.,.,', 'grammar.y', 288)
   def _reduce_114(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 290)
+module_eval(<<'.,.,', 'grammar.y', 292)
   def _reduce_115(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 291)
+module_eval(<<'.,.,', 'grammar.y', 293)
   def _reduce_116(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 295)
+module_eval(<<'.,.,', 'grammar.y', 297)
   def _reduce_117(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 296)
+module_eval(<<'.,.,', 'grammar.y', 298)
   def _reduce_118(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 300)
+module_eval(<<'.,.,', 'grammar.y', 302)
   def _reduce_119(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.y', 301)
+module_eval(<<'.,.,', 'grammar.y', 303)
   def _reduce_120(val, _values, result)
      result = nil 
     result
diff --git a/parser_test.rb b/parser_test.rb
index 171438be..e9ede388 100644
--- a/parser_test.rb
+++ b/parser_test.rb
@@ -2,9 +2,9 @@
 # With debugging and verbose: -v -g
 `racc -v -o parser.rb grammar.y`
 
-# Parse and print "code.jaa".
+# Parse and print the compiled CoffeeScript source.
 require "parser.rb"
-js = Parser.new.parse(File.read('code.jaa')).compile
+js = Parser.new.parse(File.read('code.cs')).compile
 puts "\n\n"
 puts js
 
diff --git a/poignant.jaa b/poignant.cs
similarity index 100%
rename from poignant.jaa
rename to poignant.cs
diff --git a/underscore.jaa b/underscore.cs
similarity index 100%
rename from underscore.jaa
rename to underscore.cs