diff --git a/ldtext/Parser.fs b/ldtext/Parser.fs
index d6ba291..e099777 100644
--- a/ldtext/Parser.fs
+++ b/ldtext/Parser.fs
@@ -38,10 +38,13 @@ type nonTerminalId =
     | NONTERM__startrung
     | NONTERM_rung
     | NONTERM_steps
+    | NONTERM_steps_reversed
     | NONTERM_branch
     | NONTERM_branch_arms
+    | NONTERM_branch_arms_reversed
     | NONTERM_instr
     | NONTERM_operands
+    | NONTERM_operands_reversed
     | NONTERM_operand
 
 // This function maps tokens to integer indexes
@@ -79,18 +82,21 @@ let prodIdxToNonTerminal (prodIdx:int) =
     | 0 -> NONTERM__startrung 
     | 1 -> NONTERM_rung 
     | 2 -> NONTERM_steps 
-    | 3 -> NONTERM_steps 
-    | 4 -> NONTERM_steps 
-    | 5 -> NONTERM_branch 
-    | 6 -> NONTERM_branch_arms 
+    | 3 -> NONTERM_steps_reversed 
+    | 4 -> NONTERM_steps_reversed 
+    | 5 -> NONTERM_steps_reversed 
+    | 6 -> NONTERM_branch 
     | 7 -> NONTERM_branch_arms 
-    | 8 -> NONTERM_branch_arms 
-    | 9 -> NONTERM_instr 
-    | 10 -> NONTERM_operands 
-    | 11 -> NONTERM_operands 
+    | 8 -> NONTERM_branch_arms_reversed 
+    | 9 -> NONTERM_branch_arms_reversed 
+    | 10 -> NONTERM_branch_arms_reversed 
+    | 11 -> NONTERM_instr 
     | 12 -> NONTERM_operands 
-    | 13 -> NONTERM_operand 
-    | 14 -> NONTERM_operand 
+    | 13 -> NONTERM_operands_reversed 
+    | 14 -> NONTERM_operands_reversed 
+    | 15 -> NONTERM_operands_reversed 
+    | 16 -> NONTERM_operand 
+    | 17 -> NONTERM_operand 
     | _ -> failwith "prodIdxToNonTerminal: bad production index"
 
 let _fsyacc_endOfInputTag = 11 
@@ -121,18 +127,18 @@ let _fsyacc_dataOfToken (t:token) =
   | RIGHT_PAREN  -> (null : System.Object) 
   | LEFT_PAREN  -> (null : System.Object) 
   | IDENTIFIER _fsyacc_x -> Microsoft.FSharp.Core.Operators.box _fsyacc_x 
-let _fsyacc_gotos = [| 0us;65535us;1us;65535us;0us;1us;5us;65535us;0us;2us;5us;6us;7us;8us;9us;12us;13us;12us;5us;65535us;0us;7us;5us;7us;7us;7us;9us;7us;13us;7us;2us;65535us;9us;10us;13us;14us;5us;65535us;0us;5us;5us;5us;7us;5us;9us;5us;13us;5us;2us;65535us;16us;17us;20us;21us;2us;65535us;16us;19us;20us;19us;|]
-let _fsyacc_sparseGotoTableRowOffsets = [|0us;1us;3us;9us;15us;18us;24us;27us;|]
-let _fsyacc_stateToProdIdxsTableElements = [| 1us;0us;1us;0us;1us;1us;1us;1us;1us;1us;1us;3us;1us;3us;1us;4us;1us;4us;1us;5us;1us;5us;1us;5us;2us;7us;8us;1us;7us;1us;7us;1us;9us;1us;9us;1us;9us;1us;9us;2us;11us;12us;1us;11us;1us;11us;1us;13us;1us;14us;|]
-let _fsyacc_stateToProdIdxsTableRowOffsets = [|0us;2us;4us;6us;8us;10us;12us;14us;16us;18us;20us;22us;24us;27us;29us;31us;33us;35us;37us;39us;42us;44us;46us;48us;|]
-let _fsyacc_action_rows = 24
-let _fsyacc_actionTableElements = [|2us;16386us;5us;9us;8us;15us;0us;49152us;1us;32768us;2us;3us;1us;32768us;0us;4us;0us;16385us;2us;16386us;5us;9us;8us;15us;0us;16387us;2us;16386us;5us;9us;8us;15us;0us;16388us;2us;16386us;5us;9us;8us;15us;1us;32768us;4us;11us;0us;16389us;1us;16392us;3us;13us;2us;16386us;5us;9us;8us;15us;0us;16391us;1us;32768us;7us;16us;2us;16394us;1us;23us;8us;22us;1us;32768us;6us;18us;0us;16393us;1us;16396us;3us;20us;2us;16394us;1us;23us;8us;22us;0us;16395us;0us;16397us;0us;16398us;|]
-let _fsyacc_actionTableRowOffsets = [|0us;3us;4us;6us;8us;9us;12us;13us;16us;17us;20us;22us;23us;25us;28us;29us;31us;34us;36us;37us;39us;42us;43us;44us;|]
-let _fsyacc_reductionSymbolCounts = [|1us;3us;0us;2us;2us;3us;0us;3us;1us;4us;0us;3us;1us;1us;1us;|]
-let _fsyacc_productionToNonTerminalTable = [|0us;1us;2us;2us;2us;3us;4us;4us;4us;5us;6us;6us;6us;7us;7us;|]
-let _fsyacc_immediateActions = [|65535us;49152us;65535us;65535us;16385us;65535us;16387us;65535us;16388us;65535us;65535us;16389us;65535us;65535us;16391us;65535us;65535us;65535us;16393us;65535us;65535us;16395us;16397us;16398us;|]
+let _fsyacc_gotos = [| 0us;65535us;1us;65535us;0us;1us;3us;65535us;0us;2us;8us;14us;12us;13us;3us;65535us;0us;5us;8us;5us;12us;5us;1us;65535us;5us;7us;1us;65535us;8us;9us;1us;65535us;8us;11us;1us;65535us;5us;6us;1us;65535us;16us;17us;1us;65535us;16us;19us;2us;65535us;16us;22us;20us;21us;|]
+let _fsyacc_sparseGotoTableRowOffsets = [|0us;1us;3us;7us;11us;13us;15us;17us;19us;21us;23us;|]
+let _fsyacc_stateToProdIdxsTableElements = [| 1us;0us;1us;0us;1us;1us;1us;1us;1us;1us;3us;2us;4us;5us;1us;4us;1us;5us;1us;6us;1us;6us;1us;6us;2us;7us;9us;1us;9us;1us;9us;1us;10us;1us;11us;1us;11us;1us;11us;1us;11us;2us;12us;14us;1us;14us;1us;14us;1us;15us;1us;16us;1us;17us;|]
+let _fsyacc_stateToProdIdxsTableRowOffsets = [|0us;2us;4us;6us;8us;10us;14us;16us;18us;20us;22us;24us;27us;29us;31us;33us;35us;37us;39us;41us;44us;46us;48us;50us;52us;|]
+let _fsyacc_action_rows = 25
+let _fsyacc_actionTableElements = [|0us;16387us;0us;49152us;1us;32768us;2us;3us;1us;32768us;0us;4us;0us;16385us;2us;16386us;5us;8us;8us;15us;0us;16388us;0us;16389us;0us;16387us;1us;32768us;4us;10us;0us;16390us;1us;16391us;3us;12us;0us;16387us;0us;16393us;0us;16394us;1us;32768us;7us;16us;2us;16397us;1us;24us;8us;23us;1us;32768us;6us;18us;0us;16395us;1us;16396us;3us;20us;2us;32768us;1us;24us;8us;23us;0us;16398us;0us;16399us;0us;16400us;0us;16401us;|]
+let _fsyacc_actionTableRowOffsets = [|0us;1us;2us;4us;6us;7us;10us;11us;12us;13us;15us;16us;18us;19us;20us;21us;23us;26us;28us;29us;31us;34us;35us;36us;37us;|]
+let _fsyacc_reductionSymbolCounts = [|1us;3us;1us;0us;2us;2us;3us;1us;0us;3us;1us;4us;1us;0us;3us;1us;1us;1us;|]
+let _fsyacc_productionToNonTerminalTable = [|0us;1us;2us;3us;3us;3us;4us;5us;6us;6us;6us;7us;8us;9us;9us;9us;10us;10us;|]
+let _fsyacc_immediateActions = [|65535us;49152us;65535us;65535us;16385us;65535us;16388us;16389us;65535us;65535us;16390us;65535us;65535us;16393us;16394us;65535us;65535us;65535us;16395us;65535us;65535us;16398us;16399us;16400us;16401us;|]
 let _fsyacc_reductions = lazy [|
-# 135 "Parser.fs"
+# 141 "Parser.fs"
         (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             let _1 = parseState.GetInput(1) :?> Rung in
             Microsoft.FSharp.Core.Operators.box
@@ -141,7 +147,7 @@ let _fsyacc_reductions = lazy [|
                       raise (FSharp.Text.Parsing.Accept(Microsoft.FSharp.Core.Operators.box _1))
                    )
                  : 'gentype__startrung));
-# 144 "Parser.fs"
+# 150 "Parser.fs"
         (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             let _1 = parseState.GetInput(1) :?> 'gentype_steps in
             Microsoft.FSharp.Core.Operators.box
@@ -152,152 +158,185 @@ let _fsyacc_reductions = lazy [|
                    )
 # 26 "Parser.fsy"
                  : Rung));
-# 155 "Parser.fs"
+# 161 "Parser.fs"
         (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_steps_reversed in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
 # 29 "Parser.fsy"
+                                          List.rev _1 
+                   )
+# 29 "Parser.fsy"
+                 : 'gentype_steps));
+# 172 "Parser.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            Microsoft.FSharp.Core.Operators.box
+                (
+                   (
+# 32 "Parser.fsy"
                            [] 
                    )
-# 29 "Parser.fsy"
-                 : 'gentype_steps));
-# 165 "Parser.fs"
+# 32 "Parser.fsy"
+                 : 'gentype_steps_reversed));
+# 182 "Parser.fs"
         (fun (parseState : FSharp.Text.Parsing.IParseState) ->
-            let _1 = parseState.GetInput(1) :?> 'gentype_instr in
-            let _2 = parseState.GetInput(2) :?> 'gentype_steps in
+            let _1 = parseState.GetInput(1) :?> 'gentype_steps_reversed in
+            let _2 = parseState.GetInput(2) :?> 'gentype_instr in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 30 "Parser.fsy"
-                                       StepInstr _1 :: _2 
+# 33 "Parser.fsy"
+                                                StepInstr _2 :: _1 
                    )
-# 30 "Parser.fsy"
-                 : 'gentype_steps));
-# 177 "Parser.fs"
+# 33 "Parser.fsy"
+                 : 'gentype_steps_reversed));
+# 194 "Parser.fs"
         (fun (parseState : FSharp.Text.Parsing.IParseState) ->
-            let _1 = parseState.GetInput(1) :?> 'gentype_branch in
-            let _2 = parseState.GetInput(2) :?> 'gentype_steps in
+            let _1 = parseState.GetInput(1) :?> 'gentype_steps_reversed in
+            let _2 = parseState.GetInput(2) :?> 'gentype_branch in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 31 "Parser.fsy"
-                                        StepBranch _1 :: _2 
+# 34 "Parser.fsy"
+                                                 StepBranch _2 :: _1 
                    )
-# 31 "Parser.fsy"
-                 : 'gentype_steps));
-# 189 "Parser.fs"
+# 34 "Parser.fsy"
+                 : 'gentype_steps_reversed));
+# 206 "Parser.fs"
         (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             let _2 = parseState.GetInput(2) :?> 'gentype_branch_arms in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 34 "Parser.fsy"
+# 37 "Parser.fsy"
                                                                   Branch _2 
                    )
-# 34 "Parser.fsy"
+# 37 "Parser.fsy"
                  : 'gentype_branch));
-# 200 "Parser.fs"
+# 217 "Parser.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_branch_arms_reversed in
+            Microsoft.FSharp.Core.Operators.box
+                (
+                   (
+# 40 "Parser.fsy"
+                                                List.rev _1 
+                   )
+# 40 "Parser.fsy"
+                 : 'gentype_branch_arms));
+# 228 "Parser.fs"
         (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 37 "Parser.fsy"
+# 43 "Parser.fsy"
                            [] 
                    )
-# 37 "Parser.fsy"
-                 : 'gentype_branch_arms));
-# 210 "Parser.fs"
+# 43 "Parser.fsy"
+                 : 'gentype_branch_arms_reversed));
+# 238 "Parser.fs"
         (fun (parseState : FSharp.Text.Parsing.IParseState) ->
-            let _1 = parseState.GetInput(1) :?> 'gentype_steps in
-            let _3 = parseState.GetInput(3) :?> 'gentype_branch_arms in
+            let _1 = parseState.GetInput(1) :?> 'gentype_branch_arms_reversed in
+            let _3 = parseState.GetInput(3) :?> 'gentype_steps in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 38 "Parser.fsy"
-                                                   BranchArm _1 :: _3
+# 44 "Parser.fsy"
+                                                            BranchArm _3 :: _1
                    )
-# 38 "Parser.fsy"
-                 : 'gentype_branch_arms));
-# 222 "Parser.fs"
+# 44 "Parser.fsy"
+                 : 'gentype_branch_arms_reversed));
+# 250 "Parser.fs"
         (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             let _1 = parseState.GetInput(1) :?> 'gentype_steps in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 39 "Parser.fsy"
+# 45 "Parser.fsy"
                                  [ BranchArm _1 ] 
                    )
-# 39 "Parser.fsy"
-                 : 'gentype_branch_arms));
-# 233 "Parser.fs"
+# 45 "Parser.fsy"
+                 : 'gentype_branch_arms_reversed));
+# 261 "Parser.fs"
         (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             let _1 = parseState.GetInput(1) :?> string in
             let _3 = parseState.GetInput(3) :?> 'gentype_operands in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 42 "Parser.fsy"
+# 48 "Parser.fsy"
                                                                       { Op = _1; Args = _3 } 
                    )
-# 42 "Parser.fsy"
+# 48 "Parser.fsy"
                  : 'gentype_instr));
-# 245 "Parser.fs"
+# 273 "Parser.fs"
+        (fun (parseState : FSharp.Text.Parsing.IParseState) ->
+            let _1 = parseState.GetInput(1) :?> 'gentype_operands_reversed in
+            Microsoft.FSharp.Core.Operators.box
+                (
+                   (
+# 51 "Parser.fsy"
+                                             List.rev _1 
+                   )
+# 51 "Parser.fsy"
+                 : 'gentype_operands));
+# 284 "Parser.fs"
         (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 45 "Parser.fsy"
+# 54 "Parser.fsy"
                            [] 
                    )
-# 45 "Parser.fsy"
-                 : 'gentype_operands));
-# 255 "Parser.fs"
+# 54 "Parser.fsy"
+                 : 'gentype_operands_reversed));
+# 294 "Parser.fs"
         (fun (parseState : FSharp.Text.Parsing.IParseState) ->
-            let _1 = parseState.GetInput(1) :?> 'gentype_operand in
-            let _3 = parseState.GetInput(3) :?> 'gentype_operands in
+            let _1 = parseState.GetInput(1) :?> 'gentype_operands_reversed in
+            let _3 = parseState.GetInput(3) :?> 'gentype_operand in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 46 "Parser.fsy"
-                                                  _1 :: _3 
+# 55 "Parser.fsy"
+                                                           _3 :: _1 
                    )
-# 46 "Parser.fsy"
-                 : 'gentype_operands));
-# 267 "Parser.fs"
+# 55 "Parser.fsy"
+                 : 'gentype_operands_reversed));
+# 306 "Parser.fs"
         (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             let _1 = parseState.GetInput(1) :?> 'gentype_operand in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 47 "Parser.fsy"
+# 56 "Parser.fsy"
                                    [ _1 ] 
                    )
-# 47 "Parser.fsy"
-                 : 'gentype_operands));
-# 278 "Parser.fs"
+# 56 "Parser.fsy"
+                 : 'gentype_operands_reversed));
+# 317 "Parser.fs"
         (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             let _1 = parseState.GetInput(1) :?> string in
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 50 "Parser.fsy"
+# 59 "Parser.fsy"
                                       OperandTag _1 
                    )
-# 50 "Parser.fsy"
+# 59 "Parser.fsy"
                  : 'gentype_operand));
-# 289 "Parser.fs"
+# 328 "Parser.fs"
         (fun (parseState : FSharp.Text.Parsing.IParseState) ->
             Microsoft.FSharp.Core.Operators.box
                 (
                    (
-# 51 "Parser.fsy"
+# 60 "Parser.fsy"
                                          OperandHole 
                    )
-# 51 "Parser.fsy"
+# 60 "Parser.fsy"
                  : 'gentype_operand));
 |]
-# 300 "Parser.fs"
+# 339 "Parser.fs"
 let tables : FSharp.Text.Parsing.Tables<_> = 
   { reductions = _fsyacc_reductions.Value;
     endOfInputTag = _fsyacc_endOfInputTag;
diff --git a/ldtext/Parser.fsi b/ldtext/Parser.fsi
index 334e3ce..d076146 100644
--- a/ldtext/Parser.fsi
+++ b/ldtext/Parser.fsi
@@ -26,10 +26,13 @@ type nonTerminalId =
     | NONTERM__startrung
     | NONTERM_rung
     | NONTERM_steps
+    | NONTERM_steps_reversed
     | NONTERM_branch
     | NONTERM_branch_arms
+    | NONTERM_branch_arms_reversed
     | NONTERM_instr
     | NONTERM_operands
+    | NONTERM_operands_reversed
     | NONTERM_operand
 /// This function maps tokens to integer indexes
 val tagOfToken: token -> int
diff --git a/ldtext/Parser.fsy b/ldtext/Parser.fsy
index e2a50d3..146b3dc 100644
--- a/ldtext/Parser.fsy
+++ b/ldtext/Parser.fsy
@@ -26,24 +26,33 @@ rung:
   | steps SEMICOLON EOF { Rung $1 }
 
 steps:
+  | steps_reversed { List.rev $1 }
+
+steps_reversed:
   | { [] }
-  | instr steps { StepInstr $1 :: $2 }
-  | branch steps { StepBranch $1 :: $2 }
+  | steps_reversed instr { StepInstr $2 :: $1 }
+  | steps_reversed branch { StepBranch $2 :: $1 }
 
 branch:
   | LEFT_BRACKET branch_arms RIGHT_BRACKET { Branch $2 }
 
 branch_arms:
+  | branch_arms_reversed { List.rev $1 }
+
+branch_arms_reversed:
   | { [] }
-  | steps COMMA branch_arms { BranchArm $1 :: $3}
+  | branch_arms_reversed COMMA steps { BranchArm $3 :: $1}
   | steps { [ BranchArm $1 ] }
 
 instr:
   | IDENTIFIER LEFT_PAREN operands RIGHT_PAREN { { Op = $1; Args = $3 } }
 
 operands:
+  | operands_reversed { List.rev $1 }
+
+operands_reversed:
   | { [] }
-  | operand COMMA operands { $1 :: $3 }
+  | operands_reversed COMMA operand { $3 :: $1 }
   | operand { [ $1 ] }
 
 operand:
diff --git a/ldtext/test.fsx b/ldtext/test.fsx
index bfc7f19..3ba92d4 100644
--- a/ldtext/test.fsx
+++ b/ldtext/test.fsx
@@ -21,7 +21,7 @@ let parse (s:string) =
 parse "abc();"
 parse "abc(def);"
 parse "abc(def,ghi);"
-parse "abc(def,ghi) a(b) ;"
+parse "abc(def,ghi) j(k) ;"
 parse "a() [ b() c(), d(), , e() [ f() ] g() ] h();"
 
 if failed then exit 1 else exit 0
\ No newline at end of file