(* This code extends 'std_prelude'. *)

Dlet (Pvar "push")
  (Fun "v2" (Fun "v1" (Con "Cons" [Var "v1"; Var "v2"])))

Dletrec
  [("pop","v3",
    Fun "v4"
      (Mat (Var "v3")
         [(Pcon "Nil" [],Con "Nil" []);
          (Pcon "Cons" [Pvar "v2"; Pvar "v1"],
           If (App (Opb Leq) (Var "v4") (Val (Lit (IntLit 0))))
             (Con "Cons" [Var "v2"; Var "v1"])
             (App Opapp (App Opapp (Var "pop") (Var "v1"))
                (App (Opn Minus) (Var "v4")
                   (Val (Lit (IntLit 1))))))]))]

Dletrec
  [("take1","x",
    Fun "x1"
      (If (App (Opb Leq) (Var "x") (Val (Lit (IntLit 0))))
         (Mat (Var "x1")
            [(Pcon "Nil" [],Con "Nil" []);
             (Pcon "Cons" [Pvar "v2"; Pvar "v1"],Con "Nil" [])])
         (Mat (Var "x1")
            [(Pcon "Nil" [],Raise Bind_error);
             (Pcon "Cons" [Pvar "v4"; Pvar "v3"],
              If (App (Opb Leq) (Var "x") (Val (Lit (IntLit 0))))
                (Con "Nil" [])
                (Con "Cons"
                   [Var "v4";
                    App Opapp
                      (App Opapp (Var "take1")
                         (App (Opn Minus) (Var "x")
                            (Val (Lit (IntLit 1))))) (Var "v3")]))])))]

Dlet (Pvar "take")
  (Fun "v2"
     (Fun "v1"
        (If
           (App (Opb Geq) (App Opapp (Var "LENGTH") (Var "v1"))
              (Var "v2"))
           (Con "Some"
              [App Opapp (App Opapp (Var "take1") (Var "v2"))
                 (Var "v1")]) (Con "None" []))))

Dtype
  [([],"symbol",
    [("Nts",[Tapp [Tnum] "list"]); ("Ts",[Tapp [Tnum] "list"])])]

Dlet (Pvar "isNonTmnlSym")
  (Fun "v3"
     (Mat (Var "v3")
        [(Pcon "Ts" [Pvar "v1"],Val (Lit (Bool F)));
         (Pcon "Nts" [Pvar "v2"],Val (Lit (Bool T)))]))

Dlet (Pvar "sym2Str")
  (Fun "v3"
     (Mat (Var "v3")
        [(Pcon "Ts" [Pvar "v1"],Var "v1");
         (Pcon "Nts" [Pvar "v2"],Var "v2")]))

Dtype
  [([],"rule",
    [("Rule",[Tapp [Tnum] "list"; Tapp [Tapp [] "symbol"] "list"])])]

Dlet (Pvar "ruleRhs")
  (Fun "v3"
     (Mat (Var "v3") [(Pcon "Rule" [Pvar "v2"; Pvar "v1"],Var "v1")]))

Dlet (Pvar "ruleLhs")
  (Fun "v3"
     (Mat (Var "v3") [(Pcon "Rule" [Pvar "v2"; Pvar "v1"],Var "v2")]))

Dtype
  [([],"ptree",
    [("Node",[Tapp [Tnum] "list"; Tapp [Tapp [] "ptree"] "list"]);
     ("Leaf",[Tapp [Tnum] "list"])])]

Dlet (Pvar "ptree2Sym")
  (Fun "v4"
     (Mat (Var "v4")
        [(Pcon "Leaf" [Pvar "v1"],Con "Ts" [Var "v1"]);
         (Pcon "Node" [Pvar "v3"; Pvar "v2"],Con "Nts" [Var "v3"])]))

Dlet (Pvar "buildTree")
  (Fun "v2"
     (Fun "v3"
        (Let "v1"
           (App Opapp
              (App Opapp (Var "take")
                 (App Opapp (Var "LENGTH") (Var "v3")))
              (App Opapp
                 (App Opapp (Var "MAP")
                    (App Opapp (App Opapp (Var "o") (Var "ptree2Sym"))
                       (Var "SND"))) (Var "v2")))
           (If (App Equality (Var "v1") (Con "None" [])) (Con "None" [])
              (If
                 (App Equality (Var "v3")
                    (App Opapp (Var "THE") (Var "v1")))
                 (App Opapp
                    (App Opapp (Var "take")
                       (App Opapp (Var "LENGTH")
                          (App Opapp (Var "THE") (Var "v1"))))
                    (App Opapp (App Opapp (Var "MAP") (Var "SND"))
                       (Var "v2"))) (Con "None" []))))))

Dlet (Pvar "addRule")
  (Fun "v4"
     (Fun "v5"
        (Mat (Var "v5")
           [(Pcon "Rule" [Pvar "v3"; Pvar "v2"],
             Let "v1"
               (App Opapp (App Opapp (Var "buildTree") (Var "v4"))
                  (App Opapp (Var "REVERSE") (Var "v2")))
               (If (App Equality (Var "v1") (Con "None" []))
                  (Con "None" [])
                  (Con "Some"
                     [Con "Node"
                        [Var "v3";
                         App Opapp (Var "REVERSE")
                           (App Opapp (Var "THE") (Var "v1"))]])))])))

Dlet (Pvar "stackSyms")
  (Fun "v1"
     (App Opapp (Var "REVERSE")
        (App Opapp (App Opapp (Var "MAP") (Var "FST"))
           (App Opapp (App Opapp (Var "MAP") (Var "FST")) (Var "v1")))))

Dtype
  [([],"item",
    [("Item",
      [Tapp [Tnum] "list";
       Tapp
         [Tapp [Tapp [] "symbol"] "list";
          Tapp [Tapp [] "symbol"] "list"] "prod"])])]

Dlet (Pvar "findItemInRules")
  (Fun "v11"
     (Fun "v12"
        (Mat (Var "v11")
           [(Pcon "Item" [Pvar "v10"; Pvar "v9"],
             Mat (Var "v9")
               [(Pcon "Pair" [Pvar "v8"; Pvar "v7"],
                 Mat (Var "v7")
                   [(Pcon "Nil" [],
                     Mat (Var "v12")
                       [(Pcon "Nil" [],Val (Lit (Bool F)));
                        (Pcon "Cons" [Pvar "v4"; Pvar "v3"],
                         Mat (Var "v4")
                           [(Pcon "Rule" [Pvar "v2"; Pvar "v1"],
                             Val (Lit (Bool T)))])]);
                    (Pcon "Cons" [Pvar "v6"; Pvar "v5"],
                     Val (Lit (Bool F)))])])])))

Dletrec
  [("itemEqRuleList","v7",
    Fun "v8"
      (Mat (Var "v7")
         [(Pcon "Nil" [],
           Mat (Var "v8")
             [(Pcon "Nil" [],Val (Lit (Bool T)));
              (Pcon "Cons" [Pvar "v2"; Pvar "v1"],Val (Lit (Bool T)))]);
          (Pcon "Cons" [Pvar "v6"; Pvar "v5"],
           Mat (Var "v8")
             [(Pcon "Nil" [],Val (Lit (Bool F)));
              (Pcon "Cons" [Pvar "v4"; Pvar "v3"],
               If
                 (App Equality
                    (App Equality
                       (App Opapp (Var "LENGTH")
                          (Con "Cons" [Var "v6"; Var "v5"]))
                       (App Opapp (Var "LENGTH")
                          (Con "Cons" [Var "v4"; Var "v3"])))
                    (Val (Lit (Bool F)))) (Val (Lit (Bool F)))
                 (If
                    (App Opapp
                       (App Opapp (Var "findItemInRules")
                          (App Opapp (Var "HD")
                             (Con "Cons" [Var "v6"; Var "v5"])))
                       (Con "Cons" [Var "v4"; Var "v3"]))
                    (App Opapp
                       (App Opapp (Var "itemEqRuleList")
                          (App Opapp (Var "TL")
                             (Con "Cons" [Var "v6"; Var "v5"])))
                       (Con "Cons" [Var "v4"; Var "v3"]))
                    (Val (Lit (Bool F)))))])]))]

Dtype
  [([],"action",
    [("Na",[]); ("Goto",[Tapp [Tapp [] "item"] "list"]);
     ("Reduce",[Tapp [] "rule"])])]

Dlet (Pvar "getState")
  (Fun "v11"
     (Fun "v12"
        (Fun "v13"
           (Mat (Var "v11")
              [(Pcon "Pair" [Pvar "v10"; Pvar "v9"],
                Let "v8"
                  (App Opapp (App Opapp (Var "v10") (Var "v12"))
                     (Var "v13"))
                  (Let "v7"
                     (App Opapp (App Opapp (Var "v9") (Var "v12"))
                        (App Opapp (Var "sym2Str") (Var "v13")))
                     (Mat (Var "v8")
                        [(Pcon "Nil" [],
                          Mat (Var "v7")
                            [(Pcon "Nil" [],Con "Na" []);
                             (Pcon "Cons" [Pvar "v2"; Pvar "v1"],
                              If
                                (App Equality
                                   (App Opapp (Var "LENGTH") (Var "v7"))
                                   (Val (Lit (IntLit 1))))
                                (Con "Reduce"
                                   [App Opapp (Var "HD") (Var "v7")])
                                (Con "Na" []))]);
                         (Pcon "Cons" [Pvar "v6"; Pvar "v5"],
                          Mat (Var "v7")
                            [(Pcon "Nil" [],Con "Goto" [Var "v8"]);
                             (Pcon "Cons" [Pvar "v4"; Pvar "v3"],
                              If
                                (App Opapp
                                   (App Opapp (Var "itemEqRuleList")
                                      (Con "Cons" [Var "v6"; Var "v5"]))
                                   (Con "Cons" [Var "v4"; Var "v3"]))
                                (Con "Reduce"
                                   [App Opapp (Var "HD") (Var "v7")])
                                (Con "Na" []))])])))]))))

Dlet (Pvar "stackSyms_1")
  (Fun "v1"
     (App Opapp (Var "REVERSE")
        (App Opapp (App Opapp (Var "MAP") (Var "FST"))
           (App Opapp (App Opapp (Var "MAP") (Var "FST")) (Var "v1")))))

Dlet (Pvar "exitCond")
  (Fun "v7"
     (Fun "v8"
        (Mat (Var "v7")
           [(Pcon "Pair" [Pvar "v6"; Pvar "v5"],
             Mat (Var "v8")
               [(Pcon "Pair" [Pvar "v4"; Pvar "v3"],
                 Mat (Var "v3")
                   [(Pcon "Pair" [Pvar "v2"; Pvar "v1"],
                     Log And
                       (Log And
                          (App Equality
                             (App Equality (Var "v2") (Con "Nil" []))
                             (Val (Lit (Bool F))))
                          (App Equality
                             (App Opapp (Var "stackSyms_1") (Var "v2"))
                             (Con "Cons" [Var "v5"; Con "Nil" []])))
                       (App Equality (Var "v4")
                          (Con "Cons"
                             [Con "Ts" [Var "v6"];
                              Con "Nil" []])))])])])))

Dlet (Pvar "init")
  (Fun "v1"
     (Fun "v2"
        (Con "Pair"
           [Var "v2";
            Con "Pair"
              [Con "Nil" []; Con "Cons" [Var "v1"; Con "Nil" []]]])))

Dlet (Pvar "doReduce")
  (Fun "x"
     (Fun "x1"
        (Fun "x2"
           (Mat (Var "x1")
              [(Pcon "Pair" [Pvar "v19"; Pvar "v18"],
                Mat (Var "v19")
                  [(Pcon "Nil" [],Raise Bind_error);
                   (Pcon "Cons" [Pvar "v17"; Pvar "v16"],
                    Mat (Var "v18")
                      [(Pcon "Pair" [Pvar "v15"; Pvar "v14"],
                        Mat (Var "v14")
                          [(Pcon "Nil" [],Raise Bind_error);
                           (Pcon "Cons" [Pvar "v13"; Pvar "v12"],
                            Mat (Var "v13")
                              [(Pcon "Pair" [Pvar "v11"; Pvar "v10"],
                                If
                                  (App Opapp (Var "isNonTmnlSym")
                                     (Var "v17")) (Con "None" [])
                                  (Let "v9"
                                     (App Opapp (Var "ruleLhs")
                                        (Var "x2"))
                                     (Let "v8"
                                        (App Opapp (Var "ruleRhs")
                                           (Var "x2"))
                                        (Let "v7"
                                           (App Opapp
                                              (App Opapp (Var "addRule")
                                                 (Var "v15"))
                                              (Var "x2"))
                                           (Mat (Var "v7")
                                              [(Pcon "None" [],
                                                Con "None" []);
                                               (Pcon "Some" [Pvar "v6"],
                                                Let "v5"
                                                  (App Opapp
                                                     (App Opapp
                                                        (Var "pop")
                                                        (Var "v15"))
                                                     (App Opapp
                                                        (Var "LENGTH")
                                                        (Var "v8")))
                                                  (Let "v4"
                                                     (App Opapp
                                                        (App Opapp
                                                           (Var "pop")
                                                           (Con "Cons"
                                                              [Con
                                                                 "Pair"
                                                                 [Var
                                                                    "v11";
                                                                  Var
                                                                    "v10"];
                                                               Var
                                                                 "v12"]))
                                                        (App Opapp
                                                           (Var
                                                              "LENGTH")
                                                           (Var "v8")))
                                                     (If
                                                        (App Equality
                                                           (Var "v4")
                                                           (Con "Nil"
                                                              []))
                                                        (Con "None" [])
                                                        (Let "v3"
                                                           (App Opapp
                                                              (Var
                                                                 "SND")
                                                              (App Opapp
                                                                 (Var
                                                                    "HD")
                                                                 (Var
                                                                    "v4")))
                                                           (Let "v2"
                                                              (App Opapp
                                                                 (App
                                                                    Opapp
                                                                    (App
                                                                       Opapp
                                                                       (Var
                                                                          "FST")
                                                                       (Var
                                                                          "x"))
                                                                    (Var
                                                                       "v3"))
                                                                 (Con
                                                                    "Nts"
                                                                    [Var
                                                                       "v9"]))
                                                              (If
                                                                 (App
                                                                    Equality
                                                                    (Var
                                                                       "v2")
                                                                    (Con
                                                                       "Nil"
                                                                       []))
                                                                 (Con
                                                                    "None"
                                                                    [])
                                                                 (Let
                                                                    "v1"
                                                                    (Con
                                                                       "Pair"
                                                                       [Con
                                                                          "Nts"
                                                                          [Var
                                                                             "v9"];
                                                                        Var
                                                                          "v2"])
                                                                    (Con
                                                                       "Some"
                                                                       [Con
                                                                          "Pair"
                                                                          [Con
                                                                             "Cons"
                                                                             [Var
                                                                                "v17";
                                                                              Var
                                                                                "v16"];
                                                                           Con
                                                                             "Pair"
                                                                             [App
                                                                                Opapp
                                                                                (App
                                                                                   Opapp
                                                                                   (Var
                                                                                      "APPEND")
                                                                                   (Con
                                                                                      "Cons"
                                                                                      [Con
                                                                                         "Pair"
                                                                                         [Var
                                                                                            "v1";
                                                                                          Var
                                                                                            "v6"];
                                                                                       Con
                                                                                         "Nil"
                                                                                         []]))
                                                                                (Var
                                                                                   "v5");
                                                                              App
                                                                                Opapp
                                                                                (App
                                                                                   Opapp
                                                                                   (Var
                                                                                      "push")
                                                                                   (Var
                                                                                      "v4"))
                                                                                (Var
                                                                                   "v1")]]]))))))))])))))])])])])]))))

Dlet (Pvar "parse")
  (Fun "x"
     (Fun "x1"
        (Mat (Var "x1")
           [(Pcon "Pair" [Pvar "v19"; Pvar "v18"],
             Mat (Var "v18")
               [(Pcon "Pair" [Pvar "v17"; Pvar "v16"],
                 Mat (Var "v16")
                   [(Pcon "Nil" [],Raise Bind_error);
                    (Pcon "Cons" [Pvar "v15"; Pvar "v14"],
                     Mat (Var "v15")
                       [(Pcon "Pair" [Pvar "v13"; Pvar "v12"],
                         Mat (Var "x")
                           [(Pcon "None" [],Con "None" []);
                            (Pcon "Some" [Pvar "v11"],
                             Mat (Var "v19")
                               [(Pcon "Nil" [],Con "None" []);
                                (Pcon "Cons" [Pvar "v10"; Pvar "v9"],
                                 Mat (Var "v9")
                                   [(Pcon "Nil" [],
                                     Let "v3"
                                       (App Opapp
                                          (App Opapp
                                             (App Opapp (Var "getState")
                                                (Var "v11"))
                                             (Var "v12")) (Var "v10"))
                                       (Mat (Var "v3")
                                          [(Pcon "Reduce" [Pvar "v1"],
                                            App Opapp
                                              (App Opapp
                                                 (App Opapp
                                                    (Var "doReduce")
                                                    (Var "v11"))
                                                 (Con "Pair"
                                                    [Con "Cons"
                                                       [Var "v10";
                                                        Con "Nil" []];
                                                     Con "Pair"
                                                       [Var "v17";
                                                        Con "Cons"
                                                          [Con "Pair"
                                                             [Var "v13";
                                                              Var
                                                                "v12"];
                                                           Var
                                                             "v14"]]]))
                                              (Var "v1"));
                                           (Pcon "Goto" [Pvar "v2"],
                                            Con "None" []);
                                           (Pcon "Na" [],
                                            Con "None" [])]));
                                    (Pcon "Cons" [Pvar "v8"; Pvar "v7"],
                                     Let "v6"
                                       (App Opapp
                                          (App Opapp
                                             (App Opapp (Var "getState")
                                                (Var "v11"))
                                             (Var "v12")) (Var "v10"))
                                       (Mat (Var "v6")
                                          [(Pcon "Reduce" [Pvar "v4"],
                                            App Opapp
                                              (App Opapp
                                                 (App Opapp
                                                    (Var "doReduce")
                                                    (Var "v11"))
                                                 (Con "Pair"
                                                    [Con "Cons"
                                                       [Var "v10";
                                                        Con "Cons"
                                                          [Var "v8";
                                                           Var "v7"]];
                                                     Con "Pair"
                                                       [Var "v17";
                                                        Con "Cons"
                                                          [Con "Pair"
                                                             [Var "v13";
                                                              Var
                                                                "v12"];
                                                           Var
                                                             "v14"]]]))
                                              (Var "v4"));
                                           (Pcon "Goto" [Pvar "v5"],
                                            If
                                              (App Opapp
                                                 (Var "isNonTmnlSym")
                                                 (Var "v10"))
                                              (Con "None" [])
                                              (Con "Some"
                                                 [Con "Pair"
                                                    [Con "Cons"
                                                       [Var "v8";
                                                        Var "v7"];
                                                     Con "Pair"
                                                       [Con "Cons"
                                                          [Con "Pair"
                                                             [Con "Pair"
                                                                [Var
                                                                   "v10";
                                                                 Var
                                                                   "v5"];
                                                              Con "Leaf"
                                                                [App
                                                                   Opapp
                                                                   (Var
                                                                      "sym2Str")
                                                                   (Var
                                                                      "v10")]];
                                                           Var "v17"];
                                                        App Opapp
                                                          (App Opapp
                                                             (Var
                                                                "push")
                                                             (Con "Cons"
                                                                [Con
                                                                   "Pair"
                                                                   [Var
                                                                      "v13";
                                                                    Var
                                                                      "v12"];
                                                                 Var
                                                                   "v14"]))
                                                          (Con "Pair"
                                                             [Var "v10";
                                                              Var
                                                                "v5"])]]]));
                                           (Pcon "Na" [],
                                            Con "None"
                                              [])]))])])])])])])])))

Dlet (Pvar "parser")
  (Fun "v26"
     (Fun "v27"
        (Fun "v28"
           (Mat (Var "v26")
              [(Pcon "Pair" [Pvar "v25"; Pvar "v24"],
                Mat (Var "v24")
                  [(Pcon "Pair" [Pvar "v23"; Pvar "v22"],
                    Let "v13"
                      (App Opapp
                         (App Opapp
                            (App Opapp
                               (Letrec
                                  [("owhile","g",
                                    Fun "f"
                                      (Fun "x"
                                         (If
                                            (App Opapp (Var "g")
                                               (Var "x"))
                                            (App Opapp
                                               (App Opapp
                                                  (App Opapp
                                                     (Var "owhile")
                                                     (Var "g"))
                                                  (Var "f"))
                                               (App Opapp (Var "f")
                                                  (Var "x")))
                                            (Con "Some" [Var "x"]))))]
                                  (Var "owhile"))
                               (Fun "v15"
                                  (Mat (Var "v15")
                                     [(Pcon "None" [],
                                       Val (Lit (Bool F)));
                                      (Pcon "Some" [Pvar "v14"],
                                       App Equality
                                         (App Opapp
                                            (App Opapp (Var "exitCond")
                                               (Con "Pair"
                                                  [Var "v23";
                                                   Con "Nts"
                                                     [Var "v22"]]))
                                            (Var "v14"))
                                         (Val (Lit (Bool F))))])))
                            (Fun "v21"
                               (Mat (Var "v21")
                                  [(Pcon "None" [],Con "None" []);
                                   (Pcon "Some" [Pvar "v20"],
                                    Mat (Var "v20")
                                      [(Pcon "Pair"
                                          [Pvar "v19"; Pvar "v18"],
                                        Mat (Var "v18")
                                          [(Pcon "Pair"
                                              [Pvar "v17"; Pvar "v16"],
                                            App Opapp
                                              (App Opapp (Var "parse")
                                                 (Var "v27"))
                                              (Con "Pair"
                                                 [Var "v19";
                                                  Con "Pair"
                                                    [Var "v17";
                                                     Var
                                                       "v16"]]))])])])))
                         (Con "Some"
                            [App Opapp
                               (App Opapp (Var "init") (Var "v25"))
                               (Var "v28")]))
                      (Mat (Var "v13")
                         [(Pcon "None" [],Con "None" []);
                          (Pcon "Some" [Pvar "v12"],
                           Mat (Var "v12")
                             [(Pcon "None" [],
                               Con "Some" [Con "None" []]);
                              (Pcon "Some" [Pvar "v11"],
                               Mat (Var "v11")
                                 [(Pcon "Pair" [Pvar "v10"; Pvar "v9"],
                                   Mat (Var "v9")
                                     [(Pcon "Pair"
                                         [Pvar "v8"; Pvar "v7"],
                                       Mat (Var "v8")
                                         [(Pcon "Nil" [],
                                           Con "Some" [Con "None" []]);
                                          (Pcon "Cons"
                                             [Pvar "v6"; Pvar "v5"],
                                           Mat (Var "v6")
                                             [(Pcon "Pair"
                                                 [Pvar "v4"; Pvar "v3"],
                                               Mat (Var "v5")
                                                 [(Pcon "Nil" [],
                                                   Con "Some"
                                                     [Con "Some"
                                                        [Var "v3"]]);
                                                  (Pcon "Cons"
                                                     [Pvar "v2";
                                                      Pvar "v1"],
                                                   Con "Some"
                                                     [Con "None"
                                                        []])])])])])])])]))])]))))