Repository: kevinmehall/rust-peg (language: rust)

Issue:
Add debug tracing like yydebug
It would be very useful to have some type of debug tracing like `yydebug` in lex/yacc. All I'd really like is to know when a certain state has been entered and then left.



Discussion / hints:
I know how syntax extensions work now after writing my own, so this looks pretty easy to me now. Would you be willing to accept a pull request if I just added basic tracing output, i.e. if you enable some flag then peg prints out which function was entered and when it was exited?


Fix patch:
diff --git a/src/grammar.rs b/src/grammar.rs
index c4c88e8..45de1c5 100644
--- a/src/grammar.rs
+++ b/src/grammar.rs
@@ -112,210 +112,285 @@ fn pos_to_line(input: &str, pos: usize) -> (usize, usize) {
 }
 fn parse_grammar<'input>(input: &'input str, state: &mut ParseState,
                          pos: usize) -> RuleResult<Grammar> {
-    {
-        let start_pos = pos;
-        {
-            let seq_res = parse___(input, state, pos);
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let seq_res =
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "grammar" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res = parse___(input, state, pos);
+                    match seq_res {
+                        Matched(pos, _) => {
                             {
-                                let mut repeat_pos = pos;
-                                let mut repeat_value = vec!();
-                                loop  {
-                                    let pos = repeat_pos;
-                                    let step_res =
-                                        parse_rust_use(input, state, pos);
-                                    match step_res {
-                                        Matched(newpos, value) => {
-                                            repeat_pos = newpos;
-                                            repeat_value.push(value);
+                                let seq_res =
+                                    {
+                                        let mut repeat_pos = pos;
+                                        let mut repeat_value = vec!();
+                                        loop  {
+                                            let pos = repeat_pos;
+                                            let step_res =
+                                                parse_rust_use(input, state,
+                                                               pos);
+                                            match step_res {
+                                                Matched(newpos, value) => {
+                                                    repeat_pos = newpos;
+                                                    repeat_value.push(value);
+                                                }
+                                                Failed => { break ; }
+                                            }
                                         }
-                                        Failed => { break ; }
-                                    }
-                                }
-                                Matched(repeat_pos, repeat_value)
-                            };
-                        match seq_res {
-                            Matched(pos, imports) => {
-                                {
-                                    let seq_res =
+                                        Matched(repeat_pos, repeat_value)
+                                    };
+                                match seq_res {
+                                    Matched(pos, imports) => {
                                         {
-                                            let mut repeat_pos = pos;
-                                            let mut repeat_value = vec!();
-                                            loop  {
-                                                let pos = repeat_pos;
-                                                let step_res =
-                                                    parse_rule(input, state,
-                                                               pos);
-                                                match step_res {
-                                                    Matched(newpos, value) =>
+                                            let seq_res =
+                                                {
+                                                    let mut repeat_pos = pos;
+                                                    let mut repeat_value =
+                                                        vec!();
+                                                    loop  {
+                                                        let pos = repeat_pos;
+                                                        let step_res =
+                                                            parse_rule(input,
+                                                                       state,
+                                                                       pos);
+                                                        match step_res {
+                                                            Matched(newpos,
+                                                                    value) =>
+                                                            {
+                                                                repeat_pos =
+                                                                    newpos;
+                                                                repeat_value.push(value);
+                                                            }
+                                                            Failed => {
+                                                                break ;
+                                                            }
+                                                        }
+                                                    }
+                                                    Matched(repeat_pos,
+                                                            repeat_value)
+                                                };
+                                            match seq_res {
+                                                Matched(pos, rules) => {
                                                     {
-                                                        repeat_pos = newpos;
-                                                        repeat_value.push(value);
+                                                        let match_str =
+                                                            &input[start_pos..pos];
+                                                        Matched(pos,
+                                                                {
+                                                                    Grammar{imports:
+                                                                                imports,
+                                                                            rules:
+                                                                                rules,}
+                                                                })
                                                     }
-                                                    Failed => { break ; }
                                                 }
-                                            }
-                                            Matched(repeat_pos, repeat_value)
-                                        };
-                                    match seq_res {
-                                        Matched(pos, rules) => {
-                                            {
-                                                let match_str =
-                                                    &input[start_pos..pos];
-                                                Matched(pos,
-                                                        {
-                                                            Grammar{imports:
-                                                                        imports,
-                                                                    rules:
-                                                                        rules,}
-                                                        })
+                                                Failed => Failed,
                                             }
                                         }
-                                        Failed => Failed,
                                     }
+                                    Failed => Failed,
                                 }
                             }
-                            Failed => Failed,
                         }
+                        Failed => Failed,
                     }
                 }
-                Failed => Failed,
-            }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "grammar" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "grammar" , line , col),
         }
-    }
-}
-fn parse_rule<'input>(input: &'input str, state: &mut ParseState, pos: usize)
- -> RuleResult<Rule> {
-    {
-        let start_pos = pos;
+        __peg_result
+    } else {
         {
-            let seq_res = parse_exportflag(input, state, pos);
-            match seq_res {
-                Matched(pos, exported) => {
-                    {
-                        let seq_res = parse_identifier(input, state, pos);
-                        match seq_res {
-                            Matched(pos, name) => {
+            let start_pos = pos;
+            {
+                let seq_res = parse___(input, state, pos);
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res =
                                 {
-                                    let seq_res =
-                                        parse_returntype(input, state, pos);
-                                    match seq_res {
-                                        Matched(pos, returns) => {
+                                    let mut repeat_pos = pos;
+                                    let mut repeat_value = vec!();
+                                    loop  {
+                                        let pos = repeat_pos;
+                                        let step_res =
+                                            parse_rust_use(input, state, pos);
+                                        match step_res {
+                                            Matched(newpos, value) => {
+                                                repeat_pos = newpos;
+                                                repeat_value.push(value);
+                                            }
+                                            Failed => { break ; }
+                                        }
+                                    }
+                                    Matched(repeat_pos, repeat_value)
+                                };
+                            match seq_res {
+                                Matched(pos, imports) => {
+                                    {
+                                        let seq_res =
                                             {
-                                                let seq_res =
-                                                    parse_equals(input, state,
-                                                                 pos);
-                                                match seq_res {
-                                                    Matched(pos, _) => {
-                                                        {
-                                                            let seq_res =
-                                                                parse_expression(input,
-                                                                                 state,
-                                                                                 pos);
-                                                            match seq_res {
-                                                                Matched(pos,
-                                                                        expression)
-                                                                => {
-                                                                    {
-                                                                        let seq_res =
-                                                                            match parse_semicolon(input,
-                                                                                                  state,
-                                                                                                  pos)
-                                                                                {
-                                                                                Matched(newpos,
-                                                                                        value)
-                                                                                =>
-                                                                                {
-                                                                                    Matched(newpos,
-                                                                                            Some(value))
-                                                                                }
-                                                                                Failed
-                                                                                =>
-                                                                                {
-                                                                                    Matched(pos,
-                                                                                            None)
-                                                                                }
-                                                                            };
-                                                                        match seq_res
-                                                                            {
-                                                                            Matched(pos,
-                                                                                    _)
-                                                                            =>
-                                                                            {
-                                                                                {
-                                                                                    let match_str =
-                                                                                        &input[start_pos..pos];
-                                                                                    Matched(pos,
-                                                                                            {
-                                                                                                Rule{name:
-                                                                                                         name,
-                                                                                                     expr:
-                                                                                                         box() expression,
-                                                                                                     ret_type:
-                                                                                                         returns,
-                                                                                                     exported:
-                                                                                                         exported,}
-                                                                                            })
-                                                                                }
-                                                                            }
-                                                                            Failed
-                                                                            =>
-                                                                            Failed,
-                                                                        }
-                                                                    }
-                                                                }
-                                                                Failed =>
-                                                                Failed,
-                                                            }
+                                                let mut repeat_pos = pos;
+                                                let mut repeat_value = vec!();
+                                                loop  {
+                                                    let pos = repeat_pos;
+                                                    let step_res =
+                                                        parse_rule(input,
+                                                                   state,
+                                                                   pos);
+                                                    match step_res {
+                                                        Matched(newpos, value)
+                                                        => {
+                                                            repeat_pos =
+                                                                newpos;
+                                                            repeat_value.push(value);
                                                         }
+                                                        Failed => { break ; }
                                                     }
-                                                    Failed => Failed,
+                                                }
+                                                Matched(repeat_pos,
+                                                        repeat_value)
+                                            };
+                                        match seq_res {
+                                            Matched(pos, rules) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos,
+                                                            {
+                                                                Grammar{imports:
+                                                                            imports,
+                                                                        rules:
+                                                                            rules,}
+                                                            })
                                                 }
                                             }
+                                            Failed => Failed,
                                         }
-                                        Failed => Failed,
                                     }
                                 }
+                                Failed => Failed,
                             }
-                            Failed => Failed,
                         }
                     }
+                    Failed => Failed,
                 }
-                Failed => Failed,
             }
         }
     }
 }
-fn parse_exportflag<'input>(input: &'input str, state: &mut ParseState,
-                            pos: usize) -> RuleResult<bool> {
-    {
-        let choice_res =
+fn parse_rule<'input>(input: &'input str, state: &mut ParseState, pos: usize)
+ -> RuleResult<Rule> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "rule" ,
+                 line , col);
+        let mut __peg_closure = move || {
             {
                 let start_pos = pos;
                 {
-                    let seq_res =
-                        {
-                            let choice_res =
-                                slice_eq(input, state, pos, "#[export]");
-                            match choice_res {
-                                Matched(pos, value) => Matched(pos, value),
-                                Failed =>
-                                slice_eq(input, state, pos, "#[pub]"),
-                            }
-                        };
+                    let seq_res = parse_exportflag(input, state, pos);
                     match seq_res {
-                        Matched(pos, _) => {
+                        Matched(pos, exported) => {
                             {
-                                let seq_res = parse___(input, state, pos);
+                                let seq_res =
+                                    parse_identifier(input, state, pos);
                                 match seq_res {
-                                    Matched(pos, _) => {
+                                    Matched(pos, name) => {
                                         {
-                                            let match_str =
-                                                &input[start_pos..pos];
-                                            Matched(pos, { true })
+                                            let seq_res =
+                                                parse_returntype(input, state,
+                                                                 pos);
+                                            match seq_res {
+                                                Matched(pos, returns) => {
+                                                    {
+                                                        let seq_res =
+                                                            parse_equals(input,
+                                                                         state,
+                                                                         pos);
+                                                        match seq_res {
+                                                            Matched(pos, _) =>
+                                                            {
+                                                                {
+                                                                    let seq_res =
+                                                                        parse_expression(input,
+                                                                                         state,
+                                                                                         pos);
+                                                                    match seq_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                expression)
+                                                                        => {
+                                                                            {
+                                                                                let seq_res =
+                                                                                    match parse_semicolon(input,
+                                                                                                          state,
+                                                                                                          pos)
+                                                                                        {
+                                                                                        Matched(newpos,
+                                                                                                value)
+                                                                                        =>
+                                                                                        {
+                                                                                            Matched(newpos,
+                                                                                                    Some(value))
+                                                                                        }
+                                                                                        Failed
+                                                                                        =>
+                                                                                        {
+                                                                                            Matched(pos,
+                                                                                                    None)
+                                                                                        }
+                                                                                    };
+                                                                                match seq_res
+                                                                                    {
+                                                                                    Matched(pos,
+                                                                                            _)
+                                                                                    =>
+                                                                                    {
+                                                                                        {
+                                                                                            let match_str =
+                                                                                                &input[start_pos..pos];
+                                                                                            Matched(pos,
+                                                                                                    {
+                                                                                                        Rule{name:
+                                                                                                                 name,
+                                                                                                             expr:
+                                                                                                                 box() expression,
+                                                                                                             ret_type:
+                                                                                                                 returns,
+                                                                                                             exported:
+                                                                                                                 exported,}
+                                                                                                    })
+                                                                                        }
+                                                                                    }
+                                                                                    Failed
+                                                                                    =>
+                                                                                    Failed,
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                        Failed
+                                                                        =>
+                                                                        Failed,
+                                                                    }
+                                                                }
+                                                            }
+                                                            Failed => Failed,
+                                                        }
+                                                    }
+                                                }
+                                                Failed => Failed,
+                                            }
                                         }
                                     }
                                     Failed => Failed,
@@ -325,206 +400,427 @@ fn parse_exportflag<'input>(input: &'input str, state: &mut ParseState,
                         Failed => Failed,
                     }
                 }
-            };
-        match choice_res {
-            Matched(pos, value) => Matched(pos, value),
-            Failed => {
-                let start_pos = pos;
-                {
-                    let seq_res = slice_eq(input, state, pos, "");
-                    match seq_res {
-                        Matched(pos, _) => {
-                            {
-                                let match_str = &input[start_pos..pos];
-                                Matched(pos, { false })
-                            }
-                        }
-                        Failed => Failed,
-                    }
-                }
-            }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "rule" , line ,
+                     col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "rule" ,
+                     line , col),
         }
-    }
-}
-fn parse_returntype<'input>(input: &'input str, state: &mut ParseState,
-                            pos: usize) -> RuleResult<String> {
-    {
-        let choice_res =
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
             {
-                let start_pos = pos;
-                {
-                    let seq_res = parse_returns(input, state, pos);
-                    match seq_res {
-                        Matched(pos, _) => {
-                            {
-                                let seq_res =
+                let seq_res = parse_exportflag(input, state, pos);
+                match seq_res {
+                    Matched(pos, exported) => {
+                        {
+                            let seq_res = parse_identifier(input, state, pos);
+                            match seq_res {
+                                Matched(pos, name) => {
                                     {
-                                        let start_pos = pos;
-                                        {
-                                            let seq_res =
-                                                parse_rust_type(input, state,
-                                                                pos);
-                                            match seq_res {
-                                                Matched(pos, _) => {
-                                                    {
-                                                        let match_str =
-                                                            &input[start_pos..pos];
-                                                        Matched(pos,
-                                                                {
-                                                                    match_str.trim().to_string()
-                                                                })
+                                        let seq_res =
+                                            parse_returntype(input, state,
+                                                             pos);
+                                        match seq_res {
+                                            Matched(pos, returns) => {
+                                                {
+                                                    let seq_res =
+                                                        parse_equals(input,
+                                                                     state,
+                                                                     pos);
+                                                    match seq_res {
+                                                        Matched(pos, _) => {
+                                                            {
+                                                                let seq_res =
+                                                                    parse_expression(input,
+                                                                                     state,
+                                                                                     pos);
+                                                                match seq_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            expression)
+                                                                    => {
+                                                                        {
+                                                                            let seq_res =
+                                                                                match parse_semicolon(input,
+                                                                                                      state,
+                                                                                                      pos)
+                                                                                    {
+                                                                                    Matched(newpos,
+                                                                                            value)
+                                                                                    =>
+                                                                                    {
+                                                                                        Matched(newpos,
+                                                                                                Some(value))
+                                                                                    }
+                                                                                    Failed
+                                                                                    =>
+                                                                                    {
+                                                                                        Matched(pos,
+                                                                                                None)
+                                                                                    }
+                                                                                };
+                                                                            match seq_res
+                                                                                {
+                                                                                Matched(pos,
+                                                                                        _)
+                                                                                =>
+                                                                                {
+                                                                                    {
+                                                                                        let match_str =
+                                                                                            &input[start_pos..pos];
+                                                                                        Matched(pos,
+                                                                                                {
+                                                                                                    Rule{name:
+                                                                                                             name,
+                                                                                                         expr:
+                                                                                                             box() expression,
+                                                                                                         ret_type:
+                                                                                                             returns,
+                                                                                                         exported:
+                                                                                                             exported,}
+                                                                                                })
+                                                                                    }
+                                                                                }
+                                                                                Failed
+                                                                                =>
+                                                                                Failed,
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                    Failed =>
+                                                                    Failed,
+                                                                }
+                                                            }
+                                                        }
+                                                        Failed => Failed,
                                                     }
                                                 }
-                                                Failed => Failed,
                                             }
+                                            Failed => Failed,
                                         }
-                                    };
-                                match seq_res {
-                                    Matched(pos, tp) => {
-                                        {
-                                            let match_str =
-                                                &input[start_pos..pos];
-                                            Matched(pos, { tp })
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    }
+                    Failed => Failed,
+                }
+            }
+        }
+    }
+}
+fn parse_exportflag<'input>(input: &'input str, state: &mut ParseState,
+                            pos: usize) -> RuleResult<bool> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "exportflag" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let choice_res =
+                    {
+                        let start_pos = pos;
+                        {
+                            let seq_res =
+                                {
+                                    let choice_res =
+                                        slice_eq(input, state, pos,
+                                                 "#[export]");
+                                    match choice_res {
+                                        Matched(pos, value) =>
+                                        Matched(pos, value),
+                                        Failed =>
+                                        slice_eq(input, state, pos, "#[pub]"),
+                                    }
+                                };
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    {
+                                        let seq_res =
+                                            parse___(input, state, pos);
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos, { true })
+                                                }
+                                            }
+                                            Failed => Failed,
                                         }
                                     }
-                                    Failed => Failed,
                                 }
+                                Failed => Failed,
+                            }
+                        }
+                    };
+                match choice_res {
+                    Matched(pos, value) => Matched(pos, value),
+                    Failed => {
+                        let start_pos = pos;
+                        {
+                            let seq_res = slice_eq(input, state, pos, "");
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    {
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos, { false })
+                                    }
+                                }
+                                Failed => Failed,
                             }
                         }
-                        Failed => Failed,
                     }
                 }
-            };
-        match choice_res {
-            Matched(pos, value) => Matched(pos, value),
-            Failed => {
-                let start_pos = pos;
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "exportflag" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "exportflag" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let choice_res =
                 {
-                    let match_str = &input[start_pos..pos];
-                    Matched(pos, { "()".to_string() })
+                    let start_pos = pos;
+                    {
+                        let seq_res =
+                            {
+                                let choice_res =
+                                    slice_eq(input, state, pos, "#[export]");
+                                match choice_res {
+                                    Matched(pos, value) =>
+                                    Matched(pos, value),
+                                    Failed =>
+                                    slice_eq(input, state, pos, "#[pub]"),
+                                }
+                            };
+                        match seq_res {
+                            Matched(pos, _) => {
+                                {
+                                    let seq_res = parse___(input, state, pos);
+                                    match seq_res {
+                                        Matched(pos, _) => {
+                                            {
+                                                let match_str =
+                                                    &input[start_pos..pos];
+                                                Matched(pos, { true })
+                                            }
+                                        }
+                                        Failed => Failed,
+                                    }
+                                }
+                            }
+                            Failed => Failed,
+                        }
+                    }
+                };
+            match choice_res {
+                Matched(pos, value) => Matched(pos, value),
+                Failed => {
+                    let start_pos = pos;
+                    {
+                        let seq_res = slice_eq(input, state, pos, "");
+                        match seq_res {
+                            Matched(pos, _) => {
+                                {
+                                    let match_str = &input[start_pos..pos];
+                                    Matched(pos, { false })
+                                }
+                            }
+                            Failed => Failed,
+                        }
+                    }
                 }
             }
         }
     }
 }
-fn parse_rust_use<'input>(input: &'input str, state: &mut ParseState,
-                          pos: usize) -> RuleResult<RustUse> {
-    {
-        let start_pos = pos;
+fn parse_returntype<'input>(input: &'input str, state: &mut ParseState,
+                            pos: usize) -> RuleResult<String> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "returntype" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let choice_res =
+                    {
+                        let start_pos = pos;
+                        {
+                            let seq_res = parse_returns(input, state, pos);
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    {
+                                        let seq_res =
+                                            {
+                                                let start_pos = pos;
+                                                {
+                                                    let seq_res =
+                                                        parse_rust_type(input,
+                                                                        state,
+                                                                        pos);
+                                                    match seq_res {
+                                                        Matched(pos, _) => {
+                                                            {
+                                                                let match_str =
+                                                                    &input[start_pos..pos];
+                                                                Matched(pos,
+                                                                        {
+                                                                            match_str.trim().to_string()
+                                                                        })
+                                                            }
+                                                        }
+                                                        Failed => Failed,
+                                                    }
+                                                }
+                                            };
+                                        match seq_res {
+                                            Matched(pos, tp) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos, { tp })
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    };
+                match choice_res {
+                    Matched(pos, value) => Matched(pos, value),
+                    Failed => {
+                        let start_pos = pos;
+                        {
+                            let match_str = &input[start_pos..pos];
+                            Matched(pos, { "()".to_string() })
+                        }
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "returntype" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "returntype" , line , col),
+        }
+        __peg_result
+    } else {
         {
-            let seq_res = slice_eq(input, state, pos, "use");
-            match seq_res {
-                Matched(pos, _) => {
+            let choice_res =
+                {
+                    let start_pos = pos;
                     {
-                        let seq_res = parse___(input, state, pos);
+                        let seq_res = parse_returns(input, state, pos);
                         match seq_res {
                             Matched(pos, _) => {
                                 {
                                     let seq_res =
-                                        parse_rust_path(input, state, pos);
-                                    match seq_res {
-                                        Matched(pos, p) => {
+                                        {
+                                            let start_pos = pos;
                                             {
                                                 let seq_res =
-                                                    parse___(input, state,
-                                                             pos);
+                                                    parse_rust_type(input,
+                                                                    state,
+                                                                    pos);
                                                 match seq_res {
                                                     Matched(pos, _) => {
                                                         {
-                                                            let seq_res =
+                                                            let match_str =
+                                                                &input[start_pos..pos];
+                                                            Matched(pos,
+                                                                    {
+                                                                        match_str.trim().to_string()
+                                                                    })
+                                                        }
+                                                    }
+                                                    Failed => Failed,
+                                                }
+                                            }
+                                        };
+                                    match seq_res {
+                                        Matched(pos, tp) => {
+                                            {
+                                                let match_str =
+                                                    &input[start_pos..pos];
+                                                Matched(pos, { tp })
+                                            }
+                                        }
+                                        Failed => Failed,
+                                    }
+                                }
+                            }
+                            Failed => Failed,
+                        }
+                    }
+                };
+            match choice_res {
+                Matched(pos, value) => Matched(pos, value),
+                Failed => {
+                    let start_pos = pos;
+                    {
+                        let match_str = &input[start_pos..pos];
+                        Matched(pos, { "()".to_string() })
+                    }
+                }
+            }
+        }
+    }
+}
+fn parse_rust_use<'input>(input: &'input str, state: &mut ParseState,
+                          pos: usize) -> RuleResult<RustUse> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "rust_use" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res = slice_eq(input, state, pos, "use");
+                    match seq_res {
+                        Matched(pos, _) => {
+                            {
+                                let seq_res = parse___(input, state, pos);
+                                match seq_res {
+                                    Matched(pos, _) => {
+                                        {
+                                            let seq_res =
+                                                parse_rust_path(input, state,
+                                                                pos);
+                                            match seq_res {
+                                                Matched(pos, p) => {
+                                                    {
+                                                        let seq_res =
+                                                            parse___(input,
+                                                                     state,
+                                                                     pos);
+                                                        match seq_res {
+                                                            Matched(pos, _) =>
+                                                            {
                                                                 {
-                                                                    let choice_res =
-                                                                        {
-                                                                            let start_pos =
-                                                                                pos;
-                                                                            {
-                                                                                let seq_res =
-                                                                                    slice_eq(input,
-                                                                                             state,
-                                                                                             pos,
-                                                                                             "::");
-                                                                                match seq_res
-                                                                                    {
-                                                                                    Matched(pos,
-                                                                                            _)
-                                                                                    =>
-                                                                                    {
-                                                                                        {
-                                                                                            let seq_res =
-                                                                                                parse___(input,
-                                                                                                         state,
-                                                                                                         pos);
-                                                                                            match seq_res
-                                                                                                {
-                                                                                                Matched(pos,
-                                                                                                        _)
-                                                                                                =>
-                                                                                                {
-                                                                                                    {
-                                                                                                        let seq_res =
-                                                                                                            slice_eq(input,
-                                                                                                                     state,
-                                                                                                                     pos,
-                                                                                                                     "*");
-                                                                                                        match seq_res
-                                                                                                            {
-                                                                                                            Matched(pos,
-                                                                                                                    _)
-                                                                                                            =>
-                                                                                                            {
-                                                                                                                {
-                                                                                                                    let seq_res =
-                                                                                                                        parse___(input,
-                                                                                                                                 state,
-                                                                                                                                 pos);
-                                                                                                                    match seq_res
-                                                                                                                        {
-                                                                                                                        Matched(pos,
-                                                                                                                                _)
-                                                                                                                        =>
-                                                                                                                        {
-                                                                                                                            {
-                                                                                                                                let match_str =
-                                                                                                                                    &input[start_pos..pos];
-                                                                                                                                Matched(pos,
-                                                                                                                                        {
-                                                                                                                                            RustUseGlob(p.clone())
-                                                                                                                                        })
-                                                                                                                            }
-                                                                                                                        }
-                                                                                                                        Failed
-                                                                                                                        =>
-                                                                                                                        Failed,
-                                                                                                                    }
-                                                                                                                }
-                                                                                                            }
-                                                                                                            Failed
-                                                                                                            =>
-                                                                                                            Failed,
-                                                                                                        }
-                                                                                                    }
-                                                                                                }
-                                                                                                Failed
-                                                                                                =>
-                                                                                                Failed,
-                                                                                            }
-                                                                                        }
-                                                                                    }
-                                                                                    Failed
-                                                                                    =>
-                                                                                    Failed,
-                                                                                }
-                                                                            }
-                                                                        };
-                                                                    match choice_res
+                                                                    let seq_res =
                                                                         {
-                                                                        Matched(pos,
-                                                                                value)
-                                                                        =>
-                                                                        Matched(pos,
-                                                                                value),
-                                                                        Failed
-                                                                        => {
                                                                             let choice_res =
                                                                                 {
                                                                                     let start_pos =
@@ -557,7 +853,7 @@ fn parse_rust_use<'input>(input: &'input str, state: &mut ParseState,
                                                                                                                     slice_eq(input,
                                                                                                                              state,
                                                                                                                              pos,
-                                                                                                                             "{");
+                                                                                                                             "*");
                                                                                                                 match seq_res
                                                                                                                     {
                                                                                                                     Matched(pos,
@@ -576,147 +872,12 @@ fn parse_rust_use<'input>(input: &'input str, state: &mut ParseState,
                                                                                                                                 =>
                                                                                                                                 {
                                                                                                                                     {
-                                                                                                                                        let seq_res =
-                                                                                                                                            {
-                                                                                                                                                let mut repeat_pos =
-                                                                                                                                                    pos;
-                                                                                                                                                let mut repeat_value =
-                                                                                                                                                    vec!();
-                                                                                                                                                loop 
-                                                                                                                                                     {
-                                                                                                                                                    let pos =
-                                                                                                                                                        repeat_pos;
-                                                                                                                                                    let pos =
-                                                                                                                                                        if repeat_value.len()
-                                                                                                                                                               >
-                                                                                                                                                               0
-                                                                                                                                                           {
-                                                                                                                                                            let sep_res =
-                                                                                                                                                                {
-                                                                                                                                                                    let seq_res =
-                                                                                                                                                                        slice_eq(input,
-                                                                                                                                                                                 state,
-                                                                                                                                                                                 pos,
-                                                                                                                                                                                 ",");
-                                                                                                                                                                    match seq_res
-                                                                                                                                                                        {
-                                                                                                                                                                        Matched(pos,
-                                                                                                                                                                                _)
-                                                                                                                                                                        =>
-                                                                                                                                                                        {
-                                                                                                                                                                            parse___(input,
-                                                                                                                                                                                     state,
-                                                                                                                                                                                     pos)
-                                                                                                                                                                        }
-                                                                                                                                                                        Failed
-                                                                                                                                                                        =>
-                                                                                                                                                                        Failed,
-                                                                                                                                                                    }
-                                                                                                                                                                };
-                                                                                                                                                            match sep_res
-                                                                                                                                                                {
-                                                                                                                                                                Matched(newpos,
-                                                                                                                                                                        _)
-                                                                                                                                                                =>
-                                                                                                                                                                {
-                                                                                                                                                                    newpos
-                                                                                                                                                                }
-                                                                                                                                                                Failed
-                                                                                                                                                                =>
-                                                                                                                                                                break
-                                                                                                                                                                    ,
-                                                                                                                                                            }
-                                                                                                                                                        } else {
-                                                                                                                                                            pos
-                                                                                                                                                        };
-                                                                                                                                                    let step_res =
-                                                                                                                                                        parse_identifier(input,
-                                                                                                                                                                         state,
-                                                                                                                                                                         pos);
-                                                                                                                                                    match step_res
-                                                                                                                                                        {
-                                                                                                                                                        Matched(newpos,
-                                                                                                                                                                value)
-                                                                                                                                                        =>
-                                                                                                                                                        {
-                                                                                                                                                            repeat_pos
-                                                                                                                                                                =
-                                                                                                                                                                newpos;
-                                                                                                                                                            repeat_value.push(value);
-                                                                                                                                                        }
-                                                                                                                                                        Failed
-                                                                                                                                                        =>
-                                                                                                                                                        {
-                                                                                                                                                            break
-                                                                                                                                                                ;
-                                                                                                                                                        }
-                                                                                                                                                    }
-                                                                                                                                                }
-                                                                                                                                                if repeat_value.len()
-                                                                                                                                                       >=
-                                                                                                                                                       1usize
-                                                                                                                                                   {
-                                                                                                                                                    Matched(repeat_pos,
-                                                                                                                                                            repeat_value)
-                                                                                                                                                } else {
-                                                                                                                                                    Failed
-                                                                                                                                                }
-                                                                                                                                            };
-                                                                                                                                        match seq_res
-                                                                                                                                            {
-                                                                                                                                            Matched(pos,
-                                                                                                                                                    names)
-                                                                                                                                            =>
-                                                                                                                                            {
+                                                                                                                                        let match_str =
+                                                                                                                                            &input[start_pos..pos];
+                                                                                                                                        Matched(pos,
                                                                                                                                                 {
-                                                                                                                                                    let seq_res =
-                                                                                                                                                        slice_eq(input,
-                                                                                                                                                                 state,
-                                                                                                                                                                 pos,
-                                                                                                                                                                 "}");
-                                                                                                                                                    match seq_res
-                                                                                                                                                        {
-                                                                                                                                                        Matched(pos,
-                                                                                                                                                                _)
-                                                                                                                                                        =>
-                                                                                                                                                        {
-                                                                                                                                                            {
-                                                                                                                                                                let seq_res =
-                                                                                                                                                                    parse___(input,
-                                                                                                                                                                             state,
-                                                                                                                                                                             pos);
-                                                                                                                                                                match seq_res
-                                                                                                                                                                    {
-                                                                                                                                                                    Matched(pos,
-                                                                                                                                                                            _)
-                                                                                                                                                                    =>
-                                                                                                                                                                    {
-                                                                                                                                                                        {
-                                                                                                                                                                            let match_str =
-                                                                                                                                                                                &input[start_pos..pos];
-                                                                                                                                                                            Matched(pos,
-                                                                                                                                                                                    {
-                                                                                                                                                                                        RustUseList(p.clone(),
-                                                                                                                                                                                                    names)
-                                                                                                                                                                                    })
-                                                                                                                                                                        }
-                                                                                                                                                                    }
-                                                                                                                                                                    Failed
-                                                                                                                                                                    =>
-                                                                                                                                                                    Failed,
-                                                                                                                                                                }
-                                                                                                                                                            }
-                                                                                                                                                        }
-                                                                                                                                                        Failed
-                                                                                                                                                        =>
-                                                                                                                                                        Failed,
-                                                                                                                                                    }
-                                                                                                                                                }
-                                                                                                                                            }
-                                                                                                                                            Failed
-                                                                                                                                            =>
-                                                                                                                                            Failed,
-                                                                                                                                        }
+                                                                                                                                                    RustUseGlob(p.clone())
+                                                                                                                                                })
                                                                                                                                     }
                                                                                                                                 }
                                                                                                                                 Failed
@@ -753,353 +914,477 @@ fn parse_rust_use<'input>(input: &'input str, state: &mut ParseState,
                                                                                 Failed
                                                                                 =>
                                                                                 {
-                                                                                    let start_pos =
-                                                                                        pos;
-                                                                                    {
-                                                                                        let seq_res =
-                                                                                            slice_eq(input,
-                                                                                                     state,
-                                                                                                     pos,
-                                                                                                     "");
-                                                                                        match seq_res
-                                                                                            {
-                                                                                            Matched(pos,
-                                                                                                    _)
-                                                                                            =>
+                                                                                    let choice_res =
+                                                                                        {
+                                                                                            let start_pos =
+                                                                                                pos;
                                                                                             {
-                                                                                                {
-                                                                                                    let match_str =
-                                                                                                        &input[start_pos..pos];
+                                                                                                let seq_res =
+                                                                                                    slice_eq(input,
+                                                                                                             state,
+                                                                                                             pos,
+                                                                                                             "::");
+                                                                                                match seq_res
+                                                                                                    {
                                                                                                     Matched(pos,
-                                                                                                            {
-                                                                                                                RustUseSimple(p.clone())
-                                                                                                            })
-                                                                                                }
-                                                                                            }
-                                                                                            Failed
-                                                                                            =>
-                                                                                            Failed,
-                                                                                        }
-                                                                                    }
-                                                                                }
-                                                                            }
-                                                                        }
-                                                                    }
-                                                                };
-                                                            match seq_res {
-                                                                Matched(pos,
-                                                                        v) =>
-                                                                {
-                                                                    {
-                                                                        let seq_res =
-                                                                            slice_eq(input,
-                                                                                     state,
-                                                                                     pos,
-                                                                                     ";");
-                                                                        match seq_res
-                                                                            {
-                                                                            Matched(pos,
-                                                                                    _)
-                                                                            =>
-                                                                            {
-                                                                                {
-                                                                                    let seq_res =
-                                                                                        parse___(input,
-                                                                                                 state,
-                                                                                                 pos);
-                                                                                    match seq_res
+                                                                                                            _)
+                                                                                                    =>
+                                                                                                    {
+                                                                                                        {
+                                                                                                            let seq_res =
+                                                                                                                parse___(input,
+                                                                                                                         state,
+                                                                                                                         pos);
+                                                                                                            match seq_res
+                                                                                                                {
+                                                                                                                Matched(pos,
+                                                                                                                        _)
+                                                                                                                =>
+                                                                                                                {
+                                                                                                                    {
+                                                                                                                        let seq_res =
+                                                                                                                            slice_eq(input,
+                                                                                                                                     state,
+                                                                                                                                     pos,
+                                                                                                                                     "{");
+                                                                                                                        match seq_res
+                                                                                                                            {
+                                                                                                                            Matched(pos,
+                                                                                                                                    _)
+                                                                                                                            =>
+                                                                                                                            {
+                                                                                                                                {
+                                                                                                                                    let seq_res =
+                                                                                                                                        parse___(input,
+                                                                                                                                                 state,
+                                                                                                                                                 pos);
+                                                                                                                                    match seq_res
+                                                                                                                                        {
+                                                                                                                                        Matched(pos,
+                                                                                                                                                _)
+                                                                                                                                        =>
+                                                                                                                                        {
+                                                                                                                                            {
+                                                                                                                                                let seq_res =
+                                                                                                                                                    {
+                                                                                                                                                        let mut repeat_pos =
+                                                                                                                                                            pos;
+                                                                                                                                                        let mut repeat_value =
+                                                                                                                                                            vec!();
+                                                                                                                                                        loop 
+                                                                                                                                                             {
+                                                                                                                                                            let pos =
+                                                                                                                                                                repeat_pos;
+                                                                                                                                                            let pos =
+                                                                                                                                                                if repeat_value.len()
+                                                                                                                                                                       >
+                                                                                                                                                                       0
+                                                                                                                                                                   {
+                                                                                                                                                                    let sep_res =
+                                                                                                                                                                        {
+                                                                                                                                                                            let seq_res =
+                                                                                                                                                                                slice_eq(input,
+                                                                                                                                                                                         state,
+                                                                                                                                                                                         pos,
+                                                                                                                                                                                         ",");
+                                                                                                                                                                            match seq_res
+                                                                                                                                                                                {
+                                                                                                                                                                                Matched(pos,
+                                                                                                                                                                                        _)
+                                                                                                                                                                                =>
+                                                                                                                                                                                {
+                                                                                                                                                                                    parse___(input,
+                                                                                                                                                                                             state,
+                                                                                                                                                                                             pos)
+                                                                                                                                                                                }
+                                                                                                                                                                                Failed
+                                                                                                                                                                                =>
+                                                                                                                                                                                Failed,
+                                                                                                                                                                            }
+                                                                                                                                                                        };
+                                                                                                                                                                    match sep_res
+                                                                                                                                                                        {
+                                                                                                                                                                        Matched(newpos,
+                                                                                                                                                                                _)
+                                                                                                                                                                        =>
+                                                                                                                                                                        {
+                                                                                                                                                                            newpos
+                                                                                                                                                                        }
+                                                                                                                                                                        Failed
+                                                                                                                                                                        =>
+                                                                                                                                                                        break
+                                                                                                                                                                            ,
+                                                                                                                                                                    }
+                                                                                                                                                                } else {
+                                                                                                                                                                    pos
+                                                                                                                                                                };
+                                                                                                                                                            let step_res =
+                                                                                                                                                                parse_identifier(input,
+                                                                                                                                                                                 state,
+                                                                                                                                                                                 pos);
+                                                                                                                                                            match step_res
+                                                                                                                                                                {
+                                                                                                                                                                Matched(newpos,
+                                                                                                                                                                        value)
+                                                                                                                                                                =>
+                                                                                                                                                                {
+                                                                                                                                                                    repeat_pos
+                                                                                                                                                                        =
+                                                                                                                                                                        newpos;
+                                                                                                                                                                    repeat_value.push(value);
+                                                                                                                                                                }
+                                                                                                                                                                Failed
+                                                                                                                                                                =>
+                                                                                                                                                                {
+                                                                                                                                                                    break
+                                                                                                                                                                        ;
+                                                                                                                                                                }
+                                                                                                                                                            }
+                                                                                                                                                        }
+                                                                                                                                                        if repeat_value.len()
+                                                                                                                                                               >=
+                                                                                                                                                               1usize
+                                                                                                                                                           {
+                                                                                                                                                            Matched(repeat_pos,
+                                                                                                                                                                    repeat_value)
+                                                                                                                                                        } else {
+                                                                                                                                                            Failed
+                                                                                                                                                        }
+                                                                                                                                                    };
+                                                                                                                                                match seq_res
+                                                                                                                                                    {
+                                                                                                                                                    Matched(pos,
+                                                                                                                                                            names)
+                                                                                                                                                    =>
+                                                                                                                                                    {
+                                                                                                                                                        {
+                                                                                                                                                            let seq_res =
+                                                                                                                                                                slice_eq(input,
+                                                                                                                                                                         state,
+                                                                                                                                                                         pos,
+                                                                                                                                                                         "}");
+                                                                                                                                                            match seq_res
+                                                                                                                                                                {
+                                                                                                                                                                Matched(pos,
+                                                                                                                                                                        _)
+                                                                                                                                                                =>
+                                                                                                                                                                {
+                                                                                                                                                                    {
+                                                                                                                                                                        let seq_res =
+                                                                                                                                                                            parse___(input,
+                                                                                                                                                                                     state,
+                                                                                                                                                                                     pos);
+                                                                                                                                                                        match seq_res
+                                                                                                                                                                            {
+                                                                                                                                                                            Matched(pos,
+                                                                                                                                                                                    _)
+                                                                                                                                                                            =>
+                                                                                                                                                                            {
+                                                                                                                                                                                {
+                                                                                                                                                                                    let match_str =
+                                                                                                                                                                                        &input[start_pos..pos];
+                                                                                                                                                                                    Matched(pos,
+                                                                                                                                                                                            {
+                                                                                                                                                                                                RustUseList(p.clone(),
+                                                                                                                                                                                                            names)
+                                                                                                                                                                                            })
+                                                                                                                                                                                }
+                                                                                                                                                                            }
+                                                                                                                                                                            Failed
+                                                                                                                                                                            =>
+                                                                                                                                                                            Failed,
+                                                                                                                                                                        }
+                                                                                                                                                                    }
+                                                                                                                                                                }
+                                                                                                                                                                Failed
+                                                                                                                                                                =>
+                                                                                                                                                                Failed,
+                                                                                                                                                            }
+                                                                                                                                                        }
+                                                                                                                                                    }
+                                                                                                                                                    Failed
+                                                                                                                                                    =>
+                                                                                                                                                    Failed,
+                                                                                                                                                }
+                                                                                                                                            }
+                                                                                                                                        }
+                                                                                                                                        Failed
+                                                                                                                                        =>
+                                                                                                                                        Failed,
+                                                                                                                                    }
+                                                                                                                                }
+                                                                                                                            }
+                                                                                                                            Failed
+                                                                                                                            =>
+                                                                                                                            Failed,
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                }
+                                                                                                                Failed
+                                                                                                                =>
+                                                                                                                Failed,
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                    Failed
+                                                                                                    =>
+                                                                                                    Failed,
+                                                                                                }
+                                                                                            }
+                                                                                        };
+                                                                                    match choice_res
                                                                                         {
                                                                                         Matched(pos,
-                                                                                                _)
+                                                                                                value)
+                                                                                        =>
+                                                                                        Matched(pos,
+                                                                                                value),
+                                                                                        Failed
                                                                                         =>
                                                                                         {
+                                                                                            let start_pos =
+                                                                                                pos;
                                                                                             {
-                                                                                                let match_str =
-                                                                                                    &input[start_pos..pos];
-                                                                                                Matched(pos,
+                                                                                                let seq_res =
+                                                                                                    slice_eq(input,
+                                                                                                             state,
+                                                                                                             pos,
+                                                                                                             "");
+                                                                                                match seq_res
+                                                                                                    {
+                                                                                                    Matched(pos,
+                                                                                                            _)
+                                                                                                    =>
+                                                                                                    {
                                                                                                         {
-                                                                                                            v
-                                                                                                        })
+                                                                                                            let match_str =
+                                                                                                                &input[start_pos..pos];
+                                                                                                            Matched(pos,
+                                                                                                                    {
+                                                                                                                        RustUseSimple(p.clone())
+                                                                                                                    })
+                                                                                                        }
+                                                                                                    }
+                                                                                                    Failed
+                                                                                                    =>
+                                                                                                    Failed,
+                                                                                                }
                                                                                             }
                                                                                         }
-                                                                                        Failed
-                                                                                        =>
-                                                                                        Failed,
                                                                                     }
                                                                                 }
                                                                             }
-                                                                            Failed
-                                                                            =>
-                                                                            Failed,
+                                                                        };
+                                                                    match seq_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                v)
+                                                                        => {
+                                                                            {
+                                                                                let seq_res =
+                                                                                    slice_eq(input,
+                                                                                             state,
+                                                                                             pos,
+                                                                                             ";");
+                                                                                match seq_res
+                                                                                    {
+                                                                                    Matched(pos,
+                                                                                            _)
+                                                                                    =>
+                                                                                    {
+                                                                                        {
+                                                                                            let seq_res =
+                                                                                                parse___(input,
+                                                                                                         state,
+                                                                                                         pos);
+                                                                                            match seq_res
+                                                                                                {
+                                                                                                Matched(pos,
+                                                                                                        _)
+                                                                                                =>
+                                                                                                {
+                                                                                                    {
+                                                                                                        let match_str =
+                                                                                                            &input[start_pos..pos];
+                                                                                                        Matched(pos,
+                                                                                                                {
+                                                                                                                    v
+                                                                                                                })
+                                                                                                    }
+                                                                                                }
+                                                                                                Failed
+                                                                                                =>
+                                                                                                Failed,
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                    Failed
+                                                                                    =>
+                                                                                    Failed,
+                                                                                }
+                                                                            }
                                                                         }
+                                                                        Failed
+                                                                        =>
+                                                                        Failed,
                                                                     }
                                                                 }
-                                                                Failed =>
-                                                                Failed,
                                                             }
+                                                            Failed => Failed,
                                                         }
                                                     }
-                                                    Failed => Failed,
                                                 }
+                                                Failed => Failed,
                                             }
                                         }
-                                        Failed => Failed,
                                     }
+                                    Failed => Failed,
                                 }
                             }
-                            Failed => Failed,
                         }
+                        Failed => Failed,
                     }
                 }
-                Failed => Failed,
-            }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "rust_use" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "rust_use" , line , col),
         }
-    }
-}
-fn parse_rust_path<'input>(input: &'input str, state: &mut ParseState,
-                           pos: usize) -> RuleResult<String> {
-    {
-        let start_pos = pos;
+        __peg_result
+    } else {
         {
-            let seq_res =
-                {
-                    let mut repeat_pos = pos;
-                    let mut repeat_value = vec!();
-                    loop  {
-                        let pos = repeat_pos;
-                        let pos =
-                            if repeat_value.len() > 0 {
-                                let sep_res =
+            let start_pos = pos;
+            {
+                let seq_res = slice_eq(input, state, pos, "use");
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res = parse___(input, state, pos);
+                            match seq_res {
+                                Matched(pos, _) => {
                                     {
                                         let seq_res =
-                                            slice_eq(input, state, pos, "::");
+                                            parse_rust_path(input, state,
+                                                            pos);
                                         match seq_res {
-                                            Matched(pos, _) => {
-                                                parse___(input, state, pos)
-                                            }
-                                            Failed => Failed,
-                                        }
-                                    };
-                                match sep_res {
-                                    Matched(newpos, _) => { newpos }
-                                    Failed => break ,
-                                }
-                            } else { pos };
-                        let step_res = parse_identifier(input, state, pos);
-                        match step_res {
-                            Matched(newpos, value) => {
-                                repeat_pos = newpos;
-                                repeat_value.push(value);
-                            }
-                            Failed => { break ; }
-                        }
-                    }
-                    if repeat_value.len() >= 1usize {
-                        Matched(repeat_pos, ())
-                    } else { Failed }
-                };
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let match_str = &input[start_pos..pos];
-                        Matched(pos, { match_str.to_string() })
-                    }
-                }
-                Failed => Failed,
-            }
-        }
-    }
-}
-fn parse_rust_type<'input>(input: &'input str, state: &mut ParseState,
-                           pos: usize) -> RuleResult<()> {
-    {
-        let choice_res =
-            {
-                let seq_res = slice_eq(input, state, pos, "()");
-                match seq_res {
-                    Matched(pos, _) => { parse___(input, state, pos) }
-                    Failed => Failed,
-                }
-            };
-        match choice_res {
-            Matched(pos, value) => Matched(pos, value),
-            Failed => {
-                let choice_res =
-                    {
-                        let seq_res = slice_eq(input, state, pos, "[");
-                        match seq_res {
-                            Matched(pos, _) => {
-                                {
-                                    let seq_res =
-                                        parse_rust_type(input, state, pos);
-                                    match seq_res {
-                                        Matched(pos, _) => {
-                                            {
-                                                let seq_res =
-                                                    slice_eq(input, state,
-                                                             pos, "]");
-                                                match seq_res {
-                                                    Matched(pos, _) => {
-                                                        parse___(input, state,
-                                                                 pos)
-                                                    }
-                                                    Failed => Failed,
-                                                }
-                                            }
-                                        }
-                                        Failed => Failed,
-                                    }
-                                }
-                            }
-                            Failed => Failed,
-                        }
-                    };
-                match choice_res {
-                    Matched(pos, value) => Matched(pos, value),
-                    Failed => {
-                        let choice_res =
-                            {
-                                let seq_res =
-                                    slice_eq(input, state, pos, "&");
-                                match seq_res {
-                                    Matched(pos, _) => {
-                                        {
-                                            let seq_res =
-                                                match {
-                                                          let seq_res =
-                                                              slice_eq(input,
-                                                                       state,
-                                                                       pos,
-                                                                       "\'");
-                                                          match seq_res {
-                                                              Matched(pos, _)
-                                                              => {
-                                                                  parse_identifier(input,
-                                                                                   state,
-                                                                                   pos)
-                                                              }
-                                                              Failed =>
-                                                              Failed,
-                                                          }
-                                                      } {
-                                                    Matched(newpos, value) =>
-                                                    {
-                                                        Matched(newpos,
-                                                                Some(value))
-                                                    }
-                                                    Failed => {
-                                                        Matched(pos, None)
-                                                    }
-                                                };
-                                            match seq_res {
-                                                Matched(pos, _) => {
-                                                    parse_rust_type(input,
-                                                                    state,
-                                                                    pos)
-                                                }
-                                                Failed => Failed,
-                                            }
-                                        }
-                                    }
-                                    Failed => Failed,
-                                }
-                            };
-                        match choice_res {
-                            Matched(pos, value) => Matched(pos, value),
-                            Failed => {
-                                let choice_res =
-                                    {
-                                        let seq_res =
-                                            parse_identifier(input, state,
-                                                             pos);
-                                        match seq_res {
-                                            Matched(pos, _) => {
+                                            Matched(pos, p) => {
                                                 {
                                                     let seq_res =
-                                                        slice_eq(input, state,
-                                                                 pos, "<");
+                                                        parse___(input, state,
+                                                                 pos);
                                                     match seq_res {
                                                         Matched(pos, _) => {
                                                             {
                                                                 let seq_res =
                                                                     {
-                                                                        let mut repeat_pos =
-                                                                            pos;
-                                                                        let mut repeat_value =
-                                                                            vec!();
-                                                                        loop 
-                                                                             {
-                                                                            let pos =
-                                                                                repeat_pos;
-                                                                            let pos =
-                                                                                if repeat_value.len()
-                                                                                       >
-                                                                                       0
-                                                                                   {
-                                                                                    let sep_res =
+                                                                        let choice_res =
+                                                                            {
+                                                                                let start_pos =
+                                                                                    pos;
+                                                                                {
+                                                                                    let seq_res =
+                                                                                        slice_eq(input,
+                                                                                                 state,
+                                                                                                 pos,
+                                                                                                 "::");
+                                                                                    match seq_res
                                                                                         {
-                                                                                            let seq_res =
-                                                                                                parse___(input,
-                                                                                                         state,
-                                                                                                         pos);
-                                                                                            match seq_res
-                                                                                                {
-                                                                                                Matched(pos,
-                                                                                                        _)
-                                                                                                =>
-                                                                                                {
+                                                                                        Matched(pos,
+                                                                                                _)
+                                                                                        =>
+                                                                                        {
+                                                                                            {
+                                                                                                let seq_res =
+                                                                                                    parse___(input,
+                                                                                                             state,
+                                                                                                             pos);
+                                                                                                match seq_res
                                                                                                     {
-                                                                                                        let seq_res =
-                                                                                                            slice_eq(input,
-                                                                                                                     state,
-                                                                                                                     pos,
-                                                                                                                     ",");
-                                                                                                        match seq_res
-                                                                                                            {
-                                                                                                            Matched(pos,
-                                                                                                                    _)
-                                                                                                            =>
-                                                                                                            {
-                                                                                                                parse___(input,
+                                                                                                    Matched(pos,
+                                                                                                            _)
+                                                                                                    =>
+                                                                                                    {
+                                                                                                        {
+                                                                                                            let seq_res =
+                                                                                                                slice_eq(input,
                                                                                                                          state,
-                                                                                                                         pos)
+                                                                                                                         pos,
+                                                                                                                         "*");
+                                                                                                            match seq_res
+                                                                                                                {
+                                                                                                                Matched(pos,
+                                                                                                                        _)
+                                                                                                                =>
+                                                                                                                {
+                                                                                                                    {
+                                                                                                                        let seq_res =
+                                                                                                                            parse___(input,
+                                                                                                                                     state,
+                                                                                                                                     pos);
+                                                                                                                        match seq_res
+                                                                                                                            {
+                                                                                                                            Matched(pos,
+                                                                                                                                    _)
+                                                                                                                            =>
+                                                                                                                            {
+                                                                                                                                {
+                                                                                                                                    let match_str =
+                                                                                                                                        &input[start_pos..pos];
+                                                                                                                                    Matched(pos,
+                                                                                                                                            {
+                                                                                                                                                RustUseGlob(p.clone())
+                                                                                                                                            })
+                                                                                                                                }
+                                                                                                                            }
+                                                                                                                            Failed
+                                                                                                                            =>
+                                                                                                                            Failed,
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                }
+                                                                                                                Failed
+                                                                                                                =>
+                                                                                                                Failed,
                                                                                                             }
-                                                                                                            Failed
-                                                                                                            =>
-                                                                                                            Failed,
                                                                                                         }
                                                                                                     }
+                                                                                                    Failed
+                                                                                                    =>
+                                                                                                    Failed,
                                                                                                 }
-                                                                                                Failed
-                                                                                                =>
-                                                                                                Failed,
                                                                                             }
-                                                                                        };
-                                                                                    match sep_res
-                                                                                        {
-                                                                                        Matched(newpos,
-                                                                                                _)
-                                                                                        =>
-                                                                                        {
-                                                                                            newpos
                                                                                         }
                                                                                         Failed
                                                                                         =>
-                                                                                        break
-                                                                                            ,
+                                                                                        Failed,
                                                                                     }
-                                                                                } else {
-                                                                                    pos
-                                                                                };
-                                                                            let step_res =
-                                                                                {
-                                                                                    let choice_res =
+                                                                                }
+                                                                            };
+                                                                        match choice_res
+                                                                            {
+                                                                            Matched(pos,
+                                                                                    value)
+                                                                            =>
+                                                                            Matched(pos,
+                                                                                    value),
+                                                                            Failed
+                                                                            =>
+                                                                            {
+                                                                                let choice_res =
+                                                                                    {
+                                                                                        let start_pos =
+                                                                                            pos;
                                                                                         {
                                                                                             let seq_res =
                                                                                                 slice_eq(input,
                                                                                                          state,
                                                                                                          pos,
-                                                                                                         "\'");
+                                                                                                         "::");
                                                                                             match seq_res
                                                                                                 {
                                                                                                 Matched(pos,
@@ -1108,418 +1393,328 @@ fn parse_rust_type<'input>(input: &'input str, state: &mut ParseState,
                                                                                                 {
                                                                                                     {
                                                                                                         let seq_res =
-                                                                                                            parse_identifier(input,
-                                                                                                                             state,
-                                                                                                                             pos);
+                                                                                                            parse___(input,
+                                                                                                                     state,
+                                                                                                                     pos);
                                                                                                         match seq_res
                                                                                                             {
                                                                                                             Matched(pos,
                                                                                                                     _)
                                                                                                             =>
                                                                                                             {
-                                                                                                                slice_eq(input,
-                                                                                                                         state,
-                                                                                                                         pos,
-                                                                                                                         "")
-                                                                                                            }
-                                                                                                            Failed
-                                                                                                            =>
-                                                                                                            Failed,
-                                                                                                        }
-                                                                                                    }
-                                                                                                }
-                                                                                                Failed
-                                                                                                =>
-                                                                                                Failed,
-                                                                                            }
-                                                                                        };
-                                                                                    match choice_res
-                                                                                        {
-                                                                                        Matched(pos,
-                                                                                                value)
-                                                                                        =>
-                                                                                        Matched(pos,
-                                                                                                value),
-                                                                                        Failed
-                                                                                        =>
-                                                                                        parse_rust_type(input,
-                                                                                                        state,
-                                                                                                        pos),
-                                                                                    }
-                                                                                };
-                                                                            match step_res
-                                                                                {
-                                                                                Matched(newpos,
-                                                                                        value)
-                                                                                =>
-                                                                                {
-                                                                                    repeat_pos
-                                                                                        =
-                                                                                        newpos;
-                                                                                    repeat_value.push(value);
-                                                                                }
-                                                                                Failed
-                                                                                =>
-                                                                                {
-                                                                                    break
-                                                                                        ;
-                                                                                }
-                                                                            }
-                                                                        }
-                                                                        Matched(repeat_pos,
-                                                                                ())
-                                                                    };
-                                                                match seq_res
-                                                                    {
-                                                                    Matched(pos,
-                                                                            _)
-                                                                    => {
-                                                                        {
-                                                                            let seq_res =
-                                                                                slice_eq(input,
-                                                                                         state,
-                                                                                         pos,
-                                                                                         ">");
-                                                                            match seq_res
-                                                                                {
-                                                                                Matched(pos,
-                                                                                        _)
-                                                                                =>
-                                                                                {
-                                                                                    parse___(input,
-                                                                                             state,
-                                                                                             pos)
-                                                                                }
-                                                                                Failed
-                                                                                =>
-                                                                                Failed,
-                                                                            }
-                                                                        }
-                                                                    }
-                                                                    Failed =>
-                                                                    Failed,
-                                                                }
-                                                            }
-                                                        }
-                                                        Failed => Failed,
-                                                    }
-                                                }
-                                            }
-                                            Failed => Failed,
-                                        }
-                                    };
-                                match choice_res {
-                                    Matched(pos, value) =>
-                                    Matched(pos, value),
-                                    Failed => {
-                                        let choice_res =
-                                            {
-                                                let seq_res =
-                                                    parse_identifier(input,
-                                                                     state,
-                                                                     pos);
-                                                match seq_res {
-                                                    Matched(pos, _) => {
-                                                        {
-                                                            let seq_res =
-                                                                slice_eq(input,
-                                                                         state,
-                                                                         pos,
-                                                                         "::");
-                                                            match seq_res {
-                                                                Matched(pos,
-                                                                        _) =>
-                                                                {
-                                                                    parse_rust_type(input,
-                                                                                    state,
-                                                                                    pos)
-                                                                }
-                                                                Failed =>
-                                                                Failed,
-                                                            }
-                                                        }
-                                                    }
-                                                    Failed => Failed,
-                                                }
-                                            };
-                                        match choice_res {
-                                            Matched(pos, value) =>
-                                            Matched(pos, value),
-                                            Failed => {
-                                                let choice_res =
-                                                    {
-                                                        let seq_res =
-                                                            slice_eq(input,
-                                                                     state,
-                                                                     pos,
-                                                                     "(");
-                                                        match seq_res {
-                                                            Matched(pos, _) =>
-                                                            {
-                                                                {
-                                                                    let seq_res =
-                                                                        {
-                                                                            let mut repeat_pos =
-                                                                                pos;
-                                                                            let mut repeat_value =
-                                                                                vec!();
-                                                                            loop 
-                                                                                 {
-                                                                                let pos =
-                                                                                    repeat_pos;
-                                                                                let pos =
-                                                                                    if repeat_value.len()
-                                                                                           >
-                                                                                           0
-                                                                                       {
-                                                                                        let sep_res =
-                                                                                            {
-                                                                                                let seq_res =
-                                                                                                    parse___(input,
-                                                                                                             state,
-                                                                                                             pos);
-                                                                                                match seq_res
-                                                                                                    {
-                                                                                                    Matched(pos,
-                                                                                                            _)
-                                                                                                    =>
-                                                                                                    {
-                                                                                                        {
-                                                                                                            let seq_res =
-                                                                                                                slice_eq(input,
-                                                                                                                         state,
-                                                                                                                         pos,
-                                                                                                                         ",");
-                                                                                                            match seq_res
-                                                                                                                {
-                                                                                                                Matched(pos,
-                                                                                                                        _)
-                                                                                                                =>
                                                                                                                 {
-                                                                                                                    parse___(input,
-                                                                                                                             state,
-                                                                                                                             pos)
+                                                                                                                    let seq_res =
+                                                                                                                        slice_eq(input,
+                                                                                                                                 state,
+                                                                                                                                 pos,
+                                                                                                                                 "{");
+                                                                                                                    match seq_res
+                                                                                                                        {
+                                                                                                                        Matched(pos,
+                                                                                                                                _)
+                                                                                                                        =>
+                                                                                                                        {
+                                                                                                                            {
+                                                                                                                                let seq_res =
+                                                                                                                                    parse___(input,
+                                                                                                                                             state,
+                                                                                                                                             pos);
+                                                                                                                                match seq_res
+                                                                                                                                    {
+                                                                                                                                    Matched(pos,
+                                                                                                                                            _)
+                                                                                                                                    =>
+                                                                                                                                    {
+                                                                                                                                        {
+                                                                                                                                            let seq_res =
+                                                                                                                                                {
+                                                                                                                                                    let mut repeat_pos =
+                                                                                                                                                        pos;
+                                                                                                                                                    let mut repeat_value =
+                                                                                                                                                        vec!();
+                                                                                                                                                    loop 
+                                                                                                                                                         {
+                                                                                                                                                        let pos =
+                                                                                                                                                            repeat_pos;
+                                                                                                                                                        let pos =
+                                                                                                                                                            if repeat_value.len()
+                                                                                                                                                                   >
+                                                                                                                                                                   0
+                                                                                                                                                               {
+                                                                                                                                                                let sep_res =
+                                                                                                                                                                    {
+                                                                                                                                                                        let seq_res =
+                                                                                                                                                                            slice_eq(input,
+                                                                                                                                                                                     state,
+                                                                                                                                                                                     pos,
+                                                                                                                                                                                     ",");
+                                                                                                                                                                        match seq_res
+                                                                                                                                                                            {
+                                                                                                                                                                            Matched(pos,
+                                                                                                                                                                                    _)
+                                                                                                                                                                            =>
+                                                                                                                                                                            {
+                                                                                                                                                                                parse___(input,
+                                                                                                                                                                                         state,
+                                                                                                                                                                                         pos)
+                                                                                                                                                                            }
+                                                                                                                                                                            Failed
+                                                                                                                                                                            =>
+                                                                                                                                                                            Failed,
+                                                                                                                                                                        }
+                                                                                                                                                                    };
+                                                                                                                                                                match sep_res
+                                                                                                                                                                    {
+                                                                                                                                                                    Matched(newpos,
+                                                                                                                                                                            _)
+                                                                                                                                                                    =>
+                                                                                                                                                                    {
+                                                                                                                                                                        newpos
+                                                                                                                                                                    }
+                                                                                                                                                                    Failed
+                                                                                                                                                                    =>
+                                                                                                                                                                    break
+                                                                                                                                                                        ,
+                                                                                                                                                                }
+                                                                                                                                                            } else {
+                                                                                                                                                                pos
+                                                                                                                                                            };
+                                                                                                                                                        let step_res =
+                                                                                                                                                            parse_identifier(input,
+                                                                                                                                                                             state,
+                                                                                                                                                                             pos);
+                                                                                                                                                        match step_res
+                                                                                                                                                            {
+                                                                                                                                                            Matched(newpos,
+                                                                                                                                                                    value)
+                                                                                                                                                            =>
+                                                                                                                                                            {
+                                                                                                                                                                repeat_pos
+                                                                                                                                                                    =
+                                                                                                                                                                    newpos;
+                                                                                                                                                                repeat_value.push(value);
+                                                                                                                                                            }
+                                                                                                                                                            Failed
+                                                                                                                                                            =>
+                                                                                                                                                            {
+                                                                                                                                                                break
+                                                                                                                                                                    ;
+                                                                                                                                                            }
+                                                                                                                                                        }
+                                                                                                                                                    }
+                                                                                                                                                    if repeat_value.len()
+                                                                                                                                                           >=
+                                                                                                                                                           1usize
+                                                                                                                                                       {
+                                                                                                                                                        Matched(repeat_pos,
+                                                                                                                                                                repeat_value)
+                                                                                                                                                    } else {
+                                                                                                                                                        Failed
+                                                                                                                                                    }
+                                                                                                                                                };
+                                                                                                                                            match seq_res
+                                                                                                                                                {
+                                                                                                                                                Matched(pos,
+                                                                                                                                                        names)
+                                                                                                                                                =>
+                                                                                                                                                {
+                                                                                                                                                    {
+                                                                                                                                                        let seq_res =
+                                                                                                                                                            slice_eq(input,
+                                                                                                                                                                     state,
+                                                                                                                                                                     pos,
+                                                                                                                                                                     "}");
+                                                                                                                                                        match seq_res
+                                                                                                                                                            {
+                                                                                                                                                            Matched(pos,
+                                                                                                                                                                    _)
+                                                                                                                                                            =>
+                                                                                                                                                            {
+                                                                                                                                                                {
+                                                                                                                                                                    let seq_res =
+                                                                                                                                                                        parse___(input,
+                                                                                                                                                                                 state,
+                                                                                                                                                                                 pos);
+                                                                                                                                                                    match seq_res
+                                                                                                                                                                        {
+                                                                                                                                                                        Matched(pos,
+                                                                                                                                                                                _)
+                                                                                                                                                                        =>
+                                                                                                                                                                        {
+                                                                                                                                                                            {
+                                                                                                                                                                                let match_str =
+                                                                                                                                                                                    &input[start_pos..pos];
+                                                                                                                                                                                Matched(pos,
+                                                                                                                                                                                        {
+                                                                                                                                                                                            RustUseList(p.clone(),
+                                                                                                                                                                                                        names)
+                                                                                                                                                                                        })
+                                                                                                                                                                            }
+                                                                                                                                                                        }
+                                                                                                                                                                        Failed
+                                                                                                                                                                        =>
+                                                                                                                                                                        Failed,
+                                                                                                                                                                    }
+                                                                                                                                                                }
+                                                                                                                                                            }
+                                                                                                                                                            Failed
+                                                                                                                                                            =>
+                                                                                                                                                            Failed,
+                                                                                                                                                        }
+                                                                                                                                                    }
+                                                                                                                                                }
+                                                                                                                                                Failed
+                                                                                                                                                =>
+                                                                                                                                                Failed,
+                                                                                                                                            }
+                                                                                                                                        }
+                                                                                                                                    }
+                                                                                                                                    Failed
+                                                                                                                                    =>
+                                                                                                                                    Failed,
+                                                                                                                                }
+                                                                                                                            }
+                                                                                                                        }
+                                                                                                                        Failed
+                                                                                                                        =>
+                                                                                                                        Failed,
+                                                                                                                    }
                                                                                                                 }
-                                                                                                                Failed
-                                                                                                                =>
-                                                                                                                Failed,
                                                                                                             }
+                                                                                                            Failed
+                                                                                                            =>
+                                                                                                            Failed,
                                                                                                         }
                                                                                                     }
-                                                                                                    Failed
-                                                                                                    =>
-                                                                                                    Failed,
                                                                                                 }
-                                                                                            };
-                                                                                        match sep_res
-                                                                                            {
-                                                                                            Matched(newpos,
-                                                                                                    _)
-                                                                                            =>
-                                                                                            {
-                                                                                                newpos
+                                                                                                Failed
+                                                                                                =>
+                                                                                                Failed,
                                                                                             }
-                                                                                            Failed
-                                                                                            =>
-                                                                                            break
-                                                                                                ,
                                                                                         }
-                                                                                    } else {
-                                                                                        pos
                                                                                     };
-                                                                                let step_res =
-                                                                                    parse_rust_type(input,
-                                                                                                    state,
-                                                                                                    pos);
-                                                                                match step_res
+                                                                                match choice_res
                                                                                     {
-                                                                                    Matched(newpos,
+                                                                                    Matched(pos,
                                                                                             value)
                                                                                     =>
-                                                                                    {
-                                                                                        repeat_pos
-                                                                                            =
-                                                                                            newpos;
-                                                                                        repeat_value.push(value);
-                                                                                    }
+                                                                                    Matched(pos,
+                                                                                            value),
                                                                                     Failed
                                                                                     =>
                                                                                     {
-                                                                                        break
-                                                                                            ;
+                                                                                        let start_pos =
+                                                                                            pos;
+                                                                                        {
+                                                                                            let seq_res =
+                                                                                                slice_eq(input,
+                                                                                                         state,
+                                                                                                         pos,
+                                                                                                         "");
+                                                                                            match seq_res
+                                                                                                {
+                                                                                                Matched(pos,
+                                                                                                        _)
+                                                                                                =>
+                                                                                                {
+                                                                                                    {
+                                                                                                        let match_str =
+                                                                                                            &input[start_pos..pos];
+                                                                                                        Matched(pos,
+                                                                                                                {
+                                                                                                                    RustUseSimple(p.clone())
+                                                                                                                })
+                                                                                                    }
+                                                                                                }
+                                                                                                Failed
+                                                                                                =>
+                                                                                                Failed,
+                                                                                            }
+                                                                                        }
                                                                                     }
                                                                                 }
                                                                             }
-                                                                            if repeat_value.len()
-                                                                                   >=
-                                                                                   1usize
-                                                                               {
-                                                                                Matched(repeat_pos,
-                                                                                        ())
-                                                                            } else {
-                                                                                Failed
-                                                                            }
-                                                                        };
-                                                                    match seq_res
+                                                                        }
+                                                                    };
+                                                                match seq_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            v)
+                                                                    => {
                                                                         {
-                                                                        Matched(pos,
-                                                                                _)
-                                                                        => {
-                                                                            {
-                                                                                let seq_res =
-                                                                                    slice_eq(input,
-                                                                                             state,
-                                                                                             pos,
-                                                                                             ")");
-                                                                                match seq_res
+                                                                            let seq_res =
+                                                                                slice_eq(input,
+                                                                                         state,
+                                                                                         pos,
+                                                                                         ";");
+                                                                            match seq_res
+                                                                                {
+                                                                                Matched(pos,
+                                                                                        _)
+                                                                                =>
+                                                                                {
                                                                                     {
-                                                                                    Matched(pos,
-                                                                                            _)
-                                                                                    =>
-                                                                                    {
-                                                                                        parse___(input,
-                                                                                                 state,
-                                                                                                 pos)
+                                                                                        let seq_res =
+                                                                                            parse___(input,
+                                                                                                     state,
+                                                                                                     pos);
+                                                                                        match seq_res
+                                                                                            {
+                                                                                            Matched(pos,
+                                                                                                    _)
+                                                                                            =>
+                                                                                            {
+                                                                                                {
+                                                                                                    let match_str =
+                                                                                                        &input[start_pos..pos];
+                                                                                                    Matched(pos,
+                                                                                                            {
+                                                                                                                v
+                                                                                                            })
+                                                                                                }
+                                                                                            }
+                                                                                            Failed
+                                                                                            =>
+                                                                                            Failed,
+                                                                                        }
                                                                                     }
-                                                                                    Failed
-                                                                                    =>
-                                                                                    Failed,
                                                                                 }
+                                                                                Failed
+                                                                                =>
+                                                                                Failed,
                                                                             }
                                                                         }
-                                                                        Failed
-                                                                        =>
-                                                                        Failed,
-                                                                    }
-                                                                }
-                                                            }
-                                                            Failed => Failed,
-                                                        }
-                                                    };
-                                                match choice_res {
-                                                    Matched(pos, value) =>
-                                                    Matched(pos, value),
-                                                    Failed => {
-                                                        let seq_res =
-                                                            parse_identifier(input,
-                                                                             state,
-                                                                             pos);
-                                                        match seq_res {
-                                                            Matched(pos, _) =>
-                                                            {
-                                                                slice_eq(input,
-                                                                         state,
-                                                                         pos,
-                                                                         "")
-                                                            }
-                                                            Failed => Failed,
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-fn parse_expression<'input>(input: &'input str, state: &mut ParseState,
-                            pos: usize) -> RuleResult<Expr> {
-    parse_choice(input, state, pos)
-}
-fn parse_choice<'input>(input: &'input str, state: &mut ParseState,
-                        pos: usize) -> RuleResult<Expr> {
-    {
-        let start_pos = pos;
-        {
-            let seq_res = parse_sequence(input, state, pos);
-            match seq_res {
-                Matched(pos, head) => {
-                    {
-                        let seq_res =
-                            {
-                                let mut repeat_pos = pos;
-                                let mut repeat_value = vec!();
-                                loop  {
-                                    let pos = repeat_pos;
-                                    let step_res =
-                                        {
-                                            let start_pos = pos;
-                                            {
-                                                let seq_res =
-                                                    parse_slash(input, state,
-                                                                pos);
-                                                match seq_res {
-                                                    Matched(pos, _) => {
-                                                        {
-                                                            let seq_res =
-                                                                parse_sequence(input,
-                                                                               state,
-                                                                               pos);
-                                                            match seq_res {
-                                                                Matched(pos,
-                                                                        s) =>
-                                                                {
-                                                                    {
-                                                                        let match_str =
-                                                                            &input[start_pos..pos];
-                                                                        Matched(pos,
-                                                                                {
-                                                                                    s
-                                                                                })
                                                                     }
+                                                                    Failed =>
+                                                                    Failed,
                                                                 }
-                                                                Failed =>
-                                                                Failed,
                                                             }
                                                         }
+                                                        Failed => Failed,
                                                     }
-                                                    Failed => Failed,
                                                 }
                                             }
-                                        };
-                                    match step_res {
-                                        Matched(newpos, value) => {
-                                            repeat_pos = newpos;
-                                            repeat_value.push(value);
+                                            Failed => Failed,
                                         }
-                                        Failed => { break ; }
                                     }
                                 }
-                                Matched(repeat_pos, repeat_value)
-                            };
-                        match seq_res {
-                            Matched(pos, tail) => {
-                                {
-                                    let match_str = &input[start_pos..pos];
-                                    Matched(pos,
-                                            {
-                                                if tail.len() > 0 {
-                                                    let mut list = tail;
-                                                    list.insert(0, head);
-                                                    ChoiceExpr(list)
-                                                } else { head }
-                                            })
-                                }
+                                Failed => Failed,
                             }
-                            Failed => Failed,
                         }
                     }
+                    Failed => Failed,
                 }
-                Failed => Failed,
             }
         }
     }
 }
-fn parse_sequence<'input>(input: &'input str, state: &mut ParseState,
-                          pos: usize) -> RuleResult<Expr> {
-    {
-        let choice_res =
+fn parse_rust_path<'input>(input: &'input str, state: &mut ParseState,
+                           pos: usize) -> RuleResult<String> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "rust_path" , line , col);
+        let mut __peg_closure = move || {
             {
                 let start_pos = pos;
                 {
@@ -1529,8 +1724,28 @@ fn parse_sequence<'input>(input: &'input str, state: &mut ParseState,
                             let mut repeat_value = vec!();
                             loop  {
                                 let pos = repeat_pos;
+                                let pos =
+                                    if repeat_value.len() > 0 {
+                                        let sep_res =
+                                            {
+                                                let seq_res =
+                                                    slice_eq(input, state,
+                                                             pos, "::");
+                                                match seq_res {
+                                                    Matched(pos, _) => {
+                                                        parse___(input, state,
+                                                                 pos)
+                                                    }
+                                                    Failed => Failed,
+                                                }
+                                            };
+                                        match sep_res {
+                                            Matched(newpos, _) => { newpos }
+                                            Failed => break ,
+                                        }
+                                    } else { pos };
                                 let step_res =
-                                    parse_labeled(input, state, pos);
+                                    parse_identifier(input, state, pos);
                                 match step_res {
                                     Matched(newpos, value) => {
                                         repeat_pos = newpos;
@@ -1539,107 +1754,134 @@ fn parse_sequence<'input>(input: &'input str, state: &mut ParseState,
                                     Failed => { break ; }
                                 }
                             }
-                            Matched(repeat_pos, repeat_value)
+                            if repeat_value.len() >= 1usize {
+                                Matched(repeat_pos, ())
+                            } else { Failed }
                         };
                     match seq_res {
-                        Matched(pos, elements) => {
+                        Matched(pos, _) => {
                             {
-                                let seq_res = parse_action(input, state, pos);
-                                match seq_res {
-                                    Matched(pos, code) => {
-                                        {
-                                            let match_str =
-                                                &input[start_pos..pos];
-                                            Matched(pos,
-                                                    {
-                                                        ActionExpr(elements,
-                                                                   code.0,
-                                                                   code.1)
-                                                    })
-                                        }
-                                    }
-                                    Failed => Failed,
-                                }
+                                let match_str = &input[start_pos..pos];
+                                Matched(pos, { match_str.to_string() })
                             }
                         }
                         Failed => Failed,
                     }
                 }
-            };
-        match choice_res {
-            Matched(pos, value) => Matched(pos, value),
-            Failed => {
-                let start_pos = pos;
-                {
-                    let seq_res =
-                        {
-                            let mut repeat_pos = pos;
-                            let mut repeat_value = vec!();
-                            loop  {
-                                let pos = repeat_pos;
-                                let step_res =
-                                    parse_prefixed(input, state, pos);
-                                match step_res {
-                                    Matched(newpos, value) => {
-                                        repeat_pos = newpos;
-                                        repeat_value.push(value);
-                                    }
-                                    Failed => { break ; }
-                                }
-                            }
-                            Matched(repeat_pos, repeat_value)
-                        };
-                    match seq_res {
-                        Matched(pos, elements) => {
-                            {
-                                let match_str = &input[start_pos..pos];
-                                Matched(pos,
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "rust_path" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "rust_path" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
+            {
+                let seq_res =
+                    {
+                        let mut repeat_pos = pos;
+                        let mut repeat_value = vec!();
+                        loop  {
+                            let pos = repeat_pos;
+                            let pos =
+                                if repeat_value.len() > 0 {
+                                    let sep_res =
                                         {
-                                            if elements.len() != 1 {
-                                                SequenceExpr(elements)
-                                            } else {
-                                                elements.into_iter().next().unwrap()
+                                            let seq_res =
+                                                slice_eq(input, state, pos,
+                                                         "::");
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    parse___(input, state,
+                                                             pos)
+                                                }
+                                                Failed => Failed,
                                             }
-                                        })
+                                        };
+                                    match sep_res {
+                                        Matched(newpos, _) => { newpos }
+                                        Failed => break ,
+                                    }
+                                } else { pos };
+                            let step_res =
+                                parse_identifier(input, state, pos);
+                            match step_res {
+                                Matched(newpos, value) => {
+                                    repeat_pos = newpos;
+                                    repeat_value.push(value);
+                                }
+                                Failed => { break ; }
                             }
                         }
-                        Failed => Failed,
+                        if repeat_value.len() >= 1usize {
+                            Matched(repeat_pos, ())
+                        } else { Failed }
+                    };
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let match_str = &input[start_pos..pos];
+                            Matched(pos, { match_str.to_string() })
+                        }
                     }
+                    Failed => Failed,
                 }
             }
         }
     }
 }
-fn parse_labeled<'input>(input: &'input str, state: &mut ParseState,
-                         pos: usize) -> RuleResult<TaggedExpr> {
-    {
-        let choice_res =
+fn parse_rust_type<'input>(input: &'input str, state: &mut ParseState,
+                           pos: usize) -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "rust_type" , line , col);
+        let mut __peg_closure = move || {
             {
-                let start_pos = pos;
-                {
-                    let seq_res = parse_identifier(input, state, pos);
-                    match seq_res {
-                        Matched(pos, label) => {
+                let choice_res =
+                    {
+                        let seq_res = slice_eq(input, state, pos, "()");
+                        match seq_res {
+                            Matched(pos, _) => { parse___(input, state, pos) }
+                            Failed => Failed,
+                        }
+                    };
+                match choice_res {
+                    Matched(pos, value) => Matched(pos, value),
+                    Failed => {
+                        let choice_res =
                             {
-                                let seq_res = parse_colon(input, state, pos);
+                                let seq_res =
+                                    slice_eq(input, state, pos, "[");
                                 match seq_res {
                                     Matched(pos, _) => {
                                         {
                                             let seq_res =
-                                                parse_prefixed(input, state,
-                                                               pos);
+                                                parse_rust_type(input, state,
+                                                                pos);
                                             match seq_res {
-                                                Matched(pos, expression) => {
+                                                Matched(pos, _) => {
                                                     {
-                                                        let match_str =
-                                                            &input[start_pos..pos];
-                                                        Matched(pos,
-                                                                {
-                                                                    TaggedExpr{name:
-                                                                                   Some(label),
-                                                                               expr:
-                                                                                   box() expression,}
-                                                                })
+                                                        let seq_res =
+                                                            slice_eq(input,
+                                                                     state,
+                                                                     pos,
+                                                                     "]");
+                                                        match seq_res {
+                                                            Matched(pos, _) =>
+                                                            {
+                                                                parse___(input,
+                                                                         state,
+                                                                         pos)
+                                                            }
+                                                            Failed => Failed,
+                                                        }
                                                     }
                                                 }
                                                 Failed => Failed,
@@ -1648,208 +1890,54 @@ fn parse_labeled<'input>(input: &'input str, state: &mut ParseState,
                                     }
                                     Failed => Failed,
                                 }
-                            }
-                        }
-                        Failed => Failed,
-                    }
-                }
-            };
-        match choice_res {
-            Matched(pos, value) => Matched(pos, value),
-            Failed => {
-                let start_pos = pos;
-                {
-                    let seq_res = parse_prefixed(input, state, pos);
-                    match seq_res {
-                        Matched(pos, expr) => {
-                            {
-                                let match_str = &input[start_pos..pos];
-                                Matched(pos,
-                                        {
-                                            TaggedExpr{name: None,
-                                                       expr: box() expr,}
-                                        })
-                            }
-                        }
-                        Failed => Failed,
-                    }
-                }
-            }
-        }
-    }
-}
-fn parse_prefixed<'input>(input: &'input str, state: &mut ParseState,
-                          pos: usize) -> RuleResult<Expr> {
-    {
-        let choice_res =
-            {
-                let start_pos = pos;
-                {
-                    let seq_res = parse_dollar(input, state, pos);
-                    match seq_res {
-                        Matched(pos, _) => {
-                            {
-                                let seq_res =
-                                    parse_suffixed(input, state, pos);
-                                match seq_res {
-                                    Matched(pos, expression) => {
-                                        {
-                                            let match_str =
-                                                &input[start_pos..pos];
-                                            Matched(pos, { expression })
-                                        }
-                                    }
-                                    Failed => Failed,
-                                }
-                            }
-                        }
-                        Failed => Failed,
-                    }
-                }
-            };
-        match choice_res {
-            Matched(pos, value) => Matched(pos, value),
-            Failed => {
-                let choice_res =
-                    {
-                        let start_pos = pos;
-                        {
-                            let seq_res = parse_and(input, state, pos);
-                            match seq_res {
-                                Matched(pos, _) => {
-                                    {
-                                        let seq_res =
-                                            parse_suffixed(input, state, pos);
-                                        match seq_res {
-                                            Matched(pos, expression) => {
-                                                {
-                                                    let match_str =
-                                                        &input[start_pos..pos];
-                                                    Matched(pos,
-                                                            {
-                                                                PosAssertExpr(box() expression)
-                                                            })
-                                                }
-                                            }
-                                            Failed => Failed,
-                                        }
-                                    }
-                                }
-                                Failed => Failed,
-                            }
-                        }
-                    };
-                match choice_res {
-                    Matched(pos, value) => Matched(pos, value),
-                    Failed => {
-                        let choice_res =
-                            {
-                                let start_pos = pos;
-                                {
-                                    let seq_res =
-                                        parse_not(input, state, pos);
-                                    match seq_res {
-                                        Matched(pos, _) => {
-                                            {
-                                                let seq_res =
-                                                    parse_suffixed(input,
-                                                                   state,
-                                                                   pos);
-                                                match seq_res {
-                                                    Matched(pos, expression)
-                                                    => {
-                                                        {
-                                                            let match_str =
-                                                                &input[start_pos..pos];
-                                                            Matched(pos,
-                                                                    {
-                                                                        NegAssertExpr(box() expression)
-                                                                    })
-                                                        }
-                                                    }
-                                                    Failed => Failed,
-                                                }
-                                            }
-                                        }
-                                        Failed => Failed,
-                                    }
-                                }
                             };
                         match choice_res {
                             Matched(pos, value) => Matched(pos, value),
-                            Failed => parse_suffixed(input, state, pos),
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-fn parse_suffixed<'input>(input: &'input str, state: &mut ParseState,
-                          pos: usize) -> RuleResult<Expr> {
-    {
-        let choice_res =
-            {
-                let start_pos = pos;
-                {
-                    let seq_res = parse_primary(input, state, pos);
-                    match seq_res {
-                        Matched(pos, expression) => {
-                            {
-                                let seq_res =
-                                    parse_question(input, state, pos);
-                                match seq_res {
-                                    Matched(pos, _) => {
-                                        {
-                                            let match_str =
-                                                &input[start_pos..pos];
-                                            Matched(pos,
-                                                    {
-                                                        OptionalExpr(box() expression)
-                                                    })
-                                        }
-                                    }
-                                    Failed => Failed,
-                                }
-                            }
-                        }
-                        Failed => Failed,
-                    }
-                }
-            };
-        match choice_res {
-            Matched(pos, value) => Matched(pos, value),
-            Failed => {
-                let choice_res =
-                    {
-                        let start_pos = pos;
-                        {
-                            let seq_res = parse_primary(input, state, pos);
-                            match seq_res {
-                                Matched(pos, expression) => {
+                            Failed => {
+                                let choice_res =
                                     {
                                         let seq_res =
-                                            parse_starstar(input, state, pos);
+                                            slice_eq(input, state, pos, "&");
                                         match seq_res {
                                             Matched(pos, _) => {
                                                 {
                                                     let seq_res =
-                                                        parse_primary(input,
-                                                                      state,
-                                                                      pos);
-                                                    match seq_res {
-                                                        Matched(pos, sep) => {
+                                                        match {
+                                                                  let seq_res =
+                                                                      slice_eq(input,
+                                                                               state,
+                                                                               pos,
+                                                                               "\'");
+                                                                  match seq_res
+                                                                      {
+                                                                      Matched(pos,
+                                                                              _)
+                                                                      => {
+                                                                          parse_identifier(input,
+                                                                                           state,
+                                                                                           pos)
+                                                                      }
+                                                                      Failed
+                                                                      =>
+                                                                      Failed,
+                                                                  }
+                                                              } {
+                                                            Matched(newpos,
+                                                                    value) =>
                                                             {
-                                                                let match_str =
-                                                                    &input[start_pos..pos];
+                                                                Matched(newpos,
+                                                                        Some(value))
+                                                            }
+                                                            Failed => {
                                                                 Matched(pos,
-                                                                        {
-                                                                            Repeat(box() expression,
-                                                                                   0,
-                                                                                   None,
-                                                                                   Some(box() sep))
-                                                                        })
+                                                                        None)
                                                             }
+                                                        };
+                                                    match seq_res {
+                                                        Matched(pos, _) => {
+                                                            parse_rust_type(input,
+                                                                            state,
+                                                                            pos)
                                                         }
                                                         Failed => Failed,
                                                     }
@@ -1857,172 +1945,178 @@ fn parse_suffixed<'input>(input: &'input str, state: &mut ParseState,
                                             }
                                             Failed => Failed,
                                         }
-                                    }
-                                }
-                                Failed => Failed,
-                            }
-                        }
-                    };
-                match choice_res {
-                    Matched(pos, value) => Matched(pos, value),
-                    Failed => {
-                        let choice_res =
-                            {
-                                let start_pos = pos;
-                                {
-                                    let seq_res =
-                                        parse_primary(input, state, pos);
-                                    match seq_res {
-                                        Matched(pos, expression) => {
+                                    };
+                                match choice_res {
+                                    Matched(pos, value) =>
+                                    Matched(pos, value),
+                                    Failed => {
+                                        let choice_res =
                                             {
                                                 let seq_res =
-                                                    parse_plusplus(input,
-                                                                   state,
-                                                                   pos);
+                                                    parse_identifier(input,
+                                                                     state,
+                                                                     pos);
                                                 match seq_res {
                                                     Matched(pos, _) => {
                                                         {
                                                             let seq_res =
-                                                                parse_primary(input,
-                                                                              state,
-                                                                              pos);
+                                                                slice_eq(input,
+                                                                         state,
+                                                                         pos,
+                                                                         "<");
                                                             match seq_res {
                                                                 Matched(pos,
-                                                                        sep)
-                                                                => {
-                                                                    {
-                                                                        let match_str =
-                                                                            &input[start_pos..pos];
-                                                                        Matched(pos,
-                                                                                {
-                                                                                    Repeat(box() expression,
-                                                                                           1,
-                                                                                           None,
-                                                                                           Some(box() sep))
-                                                                                })
-                                                                    }
-                                                                }
-                                                                Failed =>
-                                                                Failed,
-                                                            }
-                                                        }
-                                                    }
-                                                    Failed => Failed,
-                                                }
-                                            }
-                                        }
-                                        Failed => Failed,
-                                    }
-                                }
-                            };
-                        match choice_res {
-                            Matched(pos, value) => Matched(pos, value),
-                            Failed => {
-                                let choice_res =
-                                    {
-                                        let start_pos = pos;
-                                        {
-                                            let seq_res =
-                                                parse_primary(input, state,
-                                                              pos);
-                                            match seq_res {
-                                                Matched(pos, expression) => {
-                                                    {
-                                                        let seq_res =
-                                                            parse_star(input,
-                                                                       state,
-                                                                       pos);
-                                                        match seq_res {
-                                                            Matched(pos, _) =>
-                                                            {
+                                                                        _) =>
                                                                 {
-                                                                    let match_str =
-                                                                        &input[start_pos..pos];
-                                                                    Matched(pos,
+                                                                    {
+                                                                        let seq_res =
                                                                             {
-                                                                                Repeat(box() expression,
-                                                                                       0,
-                                                                                       None,
-                                                                                       None)
-                                                                            })
-                                                                }
-                                                            }
-                                                            Failed => Failed,
-                                                        }
-                                                    }
-                                                }
-                                                Failed => Failed,
-                                            }
-                                        }
-                                    };
-                                match choice_res {
-                                    Matched(pos, value) =>
-                                    Matched(pos, value),
-                                    Failed => {
-                                        let choice_res =
-                                            {
-                                                let start_pos = pos;
-                                                {
-                                                    let seq_res =
-                                                        parse_primary(input,
-                                                                      state,
-                                                                      pos);
-                                                    match seq_res {
-                                                        Matched(pos,
-                                                                expression) =>
-                                                        {
-                                                            {
-                                                                let seq_res =
-                                                                    parse_plus(input,
-                                                                               state,
-                                                                               pos);
-                                                                match seq_res
-                                                                    {
-                                                                    Matched(pos,
-                                                                            _)
-                                                                    => {
-                                                                        {
-                                                                            let match_str =
-                                                                                &input[start_pos..pos];
-                                                                            Matched(pos,
-                                                                                    {
-                                                                                        Repeat(box() expression,
-                                                                                               1,
-                                                                                               None,
-                                                                                               None)
-                                                                                    })
-                                                                        }
-                                                                    }
-                                                                    Failed =>
-                                                                    Failed,
-                                                                }
-                                                            }
-                                                        }
-                                                        Failed => Failed,
-                                                    }
-                                                }
-                                            };
-                                        match choice_res {
-                                            Matched(pos, value) =>
-                                            Matched(pos, value),
-                                            Failed => {
-                                                let choice_res =
-                                                    {
-                                                        let start_pos = pos;
-                                                        {
-                                                            let seq_res =
-                                                                parse_primary(input,
-                                                                              state,
-                                                                              pos);
-                                                            match seq_res {
-                                                                Matched(pos,
-                                                                        expression)
-                                                                => {
-                                                                    {
-                                                                        let seq_res =
-                                                                            parse_lbrace(input,
-                                                                                         state,
-                                                                                         pos);
+                                                                                let mut repeat_pos =
+                                                                                    pos;
+                                                                                let mut repeat_value =
+                                                                                    vec!();
+                                                                                loop 
+                                                                                     {
+                                                                                    let pos =
+                                                                                        repeat_pos;
+                                                                                    let pos =
+                                                                                        if repeat_value.len()
+                                                                                               >
+                                                                                               0
+                                                                                           {
+                                                                                            let sep_res =
+                                                                                                {
+                                                                                                    let seq_res =
+                                                                                                        parse___(input,
+                                                                                                                 state,
+                                                                                                                 pos);
+                                                                                                    match seq_res
+                                                                                                        {
+                                                                                                        Matched(pos,
+                                                                                                                _)
+                                                                                                        =>
+                                                                                                        {
+                                                                                                            {
+                                                                                                                let seq_res =
+                                                                                                                    slice_eq(input,
+                                                                                                                             state,
+                                                                                                                             pos,
+                                                                                                                             ",");
+                                                                                                                match seq_res
+                                                                                                                    {
+                                                                                                                    Matched(pos,
+                                                                                                                            _)
+                                                                                                                    =>
+                                                                                                                    {
+                                                                                                                        parse___(input,
+                                                                                                                                 state,
+                                                                                                                                 pos)
+                                                                                                                    }
+                                                                                                                    Failed
+                                                                                                                    =>
+                                                                                                                    Failed,
+                                                                                                                }
+                                                                                                            }
+                                                                                                        }
+                                                                                                        Failed
+                                                                                                        =>
+                                                                                                        Failed,
+                                                                                                    }
+                                                                                                };
+                                                                                            match sep_res
+                                                                                                {
+                                                                                                Matched(newpos,
+                                                                                                        _)
+                                                                                                =>
+                                                                                                {
+                                                                                                    newpos
+                                                                                                }
+                                                                                                Failed
+                                                                                                =>
+                                                                                                break
+                                                                                                    ,
+                                                                                            }
+                                                                                        } else {
+                                                                                            pos
+                                                                                        };
+                                                                                    let step_res =
+                                                                                        {
+                                                                                            let choice_res =
+                                                                                                {
+                                                                                                    let seq_res =
+                                                                                                        slice_eq(input,
+                                                                                                                 state,
+                                                                                                                 pos,
+                                                                                                                 "\'");
+                                                                                                    match seq_res
+                                                                                                        {
+                                                                                                        Matched(pos,
+                                                                                                                _)
+                                                                                                        =>
+                                                                                                        {
+                                                                                                            {
+                                                                                                                let seq_res =
+                                                                                                                    parse_identifier(input,
+                                                                                                                                     state,
+                                                                                                                                     pos);
+                                                                                                                match seq_res
+                                                                                                                    {
+                                                                                                                    Matched(pos,
+                                                                                                                            _)
+                                                                                                                    =>
+                                                                                                                    {
+                                                                                                                        slice_eq(input,
+                                                                                                                                 state,
+                                                                                                                                 pos,
+                                                                                                                                 "")
+                                                                                                                    }
+                                                                                                                    Failed
+                                                                                                                    =>
+                                                                                                                    Failed,
+                                                                                                                }
+                                                                                                            }
+                                                                                                        }
+                                                                                                        Failed
+                                                                                                        =>
+                                                                                                        Failed,
+                                                                                                    }
+                                                                                                };
+                                                                                            match choice_res
+                                                                                                {
+                                                                                                Matched(pos,
+                                                                                                        value)
+                                                                                                =>
+                                                                                                Matched(pos,
+                                                                                                        value),
+                                                                                                Failed
+                                                                                                =>
+                                                                                                parse_rust_type(input,
+                                                                                                                state,
+                                                                                                                pos),
+                                                                                            }
+                                                                                        };
+                                                                                    match step_res
+                                                                                        {
+                                                                                        Matched(newpos,
+                                                                                                value)
+                                                                                        =>
+                                                                                        {
+                                                                                            repeat_pos
+                                                                                                =
+                                                                                                newpos;
+                                                                                            repeat_value.push(value);
+                                                                                        }
+                                                                                        Failed
+                                                                                        =>
+                                                                                        {
+                                                                                            break
+                                                                                                ;
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                                Matched(repeat_pos,
+                                                                                        ())
+                                                                            };
                                                                         match seq_res
                                                                             {
                                                                             Matched(pos,
@@ -2031,43 +2125,19 @@ fn parse_suffixed<'input>(input: &'input str, state: &mut ParseState,
                                                                             {
                                                                                 {
                                                                                     let seq_res =
-                                                                                        parse_integer(input,
-                                                                                                      state,
-                                                                                                      pos);
+                                                                                        slice_eq(input,
+                                                                                                 state,
+                                                                                                 pos,
+                                                                                                 ">");
                                                                                     match seq_res
                                                                                         {
                                                                                         Matched(pos,
-                                                                                                n)
+                                                                                                _)
                                                                                         =>
                                                                                         {
-                                                                                            {
-                                                                                                let seq_res =
-                                                                                                    parse_rbrace(input,
-                                                                                                                 state,
-                                                                                                                 pos);
-                                                                                                match seq_res
-                                                                                                    {
-                                                                                                    Matched(pos,
-                                                                                                            _)
-                                                                                                    =>
-                                                                                                    {
-                                                                                                        {
-                                                                                                            let match_str =
-                                                                                                                &input[start_pos..pos];
-                                                                                                            Matched(pos,
-                                                                                                                    {
-                                                                                                                        Repeat(box() expression,
-                                                                                                                               n,
-                                                                                                                               Some(n),
-                                                                                                                               None)
-                                                                                                                    })
-                                                                                                        }
-                                                                                                    }
-                                                                                                    Failed
-                                                                                                    =>
-                                                                                                    Failed,
-                                                                                                }
-                                                                                            }
+                                                                                            parse___(input,
+                                                                                                     state,
+                                                                                                     pos)
                                                                                         }
                                                                                         Failed
                                                                                         =>
@@ -2085,6 +2155,46 @@ fn parse_suffixed<'input>(input: &'input str, state: &mut ParseState,
                                                                 Failed,
                                                             }
                                                         }
+                                                    }
+                                                    Failed => Failed,
+                                                }
+                                            };
+                                        match choice_res {
+                                            Matched(pos, value) =>
+                                            Matched(pos, value),
+                                            Failed => {
+                                                let choice_res =
+                                                    {
+                                                        let seq_res =
+                                                            parse_identifier(input,
+                                                                             state,
+                                                                             pos);
+                                                        match seq_res {
+                                                            Matched(pos, _) =>
+                                                            {
+                                                                {
+                                                                    let seq_res =
+                                                                        slice_eq(input,
+                                                                                 state,
+                                                                                 pos,
+                                                                                 "::");
+                                                                    match seq_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                _)
+                                                                        => {
+                                                                            parse_rust_type(input,
+                                                                                            state,
+                                                                                            pos)
+                                                                        }
+                                                                        Failed
+                                                                        =>
+                                                                        Failed,
+                                                                    }
+                                                                }
+                                                            }
+                                                            Failed => Failed,
+                                                        }
                                                     };
                                                 match choice_res {
                                                     Matched(pos, value) =>
@@ -2092,45 +2202,38 @@ fn parse_suffixed<'input>(input: &'input str, state: &mut ParseState,
                                                     Failed => {
                                                         let choice_res =
                                                             {
-                                                                let start_pos =
-                                                                    pos;
-                                                                {
-                                                                    let seq_res =
-                                                                        parse_primary(input,
-                                                                                      state,
-                                                                                      pos);
-                                                                    match seq_res
+                                                                let seq_res =
+                                                                    slice_eq(input,
+                                                                             state,
+                                                                             pos,
+                                                                             "(");
+                                                                match seq_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            _)
+                                                                    => {
                                                                         {
-                                                                        Matched(pos,
-                                                                                expression)
-                                                                        => {
-                                                                            {
-                                                                                let seq_res =
-                                                                                    parse_lbrace(input,
-                                                                                                 state,
-                                                                                                 pos);
-                                                                                match seq_res
-                                                                                    {
-                                                                                    Matched(pos,
-                                                                                            _)
-                                                                                    =>
-                                                                                    {
-                                                                                        {
-                                                                                            let seq_res =
-                                                                                                parse_integer(input,
-                                                                                                              state,
-                                                                                                              pos);
-                                                                                            match seq_res
-                                                                                                {
-                                                                                                Matched(pos,
-                                                                                                        min)
-                                                                                                =>
-                                                                                                {
+                                                                            let seq_res =
+                                                                                {
+                                                                                    let mut repeat_pos =
+                                                                                        pos;
+                                                                                    let mut repeat_value =
+                                                                                        vec!();
+                                                                                    loop 
+                                                                                         {
+                                                                                        let pos =
+                                                                                            repeat_pos;
+                                                                                        let pos =
+                                                                                            if repeat_value.len()
+                                                                                                   >
+                                                                                                   0
+                                                                                               {
+                                                                                                let sep_res =
                                                                                                     {
                                                                                                         let seq_res =
-                                                                                                            parse_comma(input,
-                                                                                                                        state,
-                                                                                                                        pos);
+                                                                                                            parse___(input,
+                                                                                                                     state,
+                                                                                                                     pos);
                                                                                                         match seq_res
                                                                                                             {
                                                                                                             Matched(pos,
@@ -2139,58 +2242,19 @@ fn parse_suffixed<'input>(input: &'input str, state: &mut ParseState,
                                                                                                             {
                                                                                                                 {
                                                                                                                     let seq_res =
-                                                                                                                        match parse_integer(input,
-                                                                                                                                            state,
-                                                                                                                                            pos)
-                                                                                                                            {
-                                                                                                                            Matched(newpos,
-                                                                                                                                    value)
-                                                                                                                            =>
-                                                                                                                            {
-                                                                                                                                Matched(newpos,
-                                                                                                                                        Some(value))
-                                                                                                                            }
-                                                                                                                            Failed
-                                                                                                                            =>
-                                                                                                                            {
-                                                                                                                                Matched(pos,
-                                                                                                                                        None)
-                                                                                                                            }
-                                                                                                                        };
+                                                                                                                        slice_eq(input,
+                                                                                                                                 state,
+                                                                                                                                 pos,
+                                                                                                                                 ",");
                                                                                                                     match seq_res
                                                                                                                         {
                                                                                                                         Matched(pos,
-                                                                                                                                max)
+                                                                                                                                _)
                                                                                                                         =>
                                                                                                                         {
-                                                                                                                            {
-                                                                                                                                let seq_res =
-                                                                                                                                    parse_rbrace(input,
-                                                                                                                                                 state,
-                                                                                                                                                 pos);
-                                                                                                                                match seq_res
-                                                                                                                                    {
-                                                                                                                                    Matched(pos,
-                                                                                                                                            _)
-                                                                                                                                    =>
-                                                                                                                                    {
-                                                                                                                                        {
-                                                                                                                                            let match_str =
-                                                                                                                                                &input[start_pos..pos];
-                                                                                                                                            Matched(pos,
-                                                                                                                                                    {
-                                                                                                                                                        Repeat(box() expression,
-                                                                                                                                                               min,
-                                                                                                                                                               max,
-                                                                                                                                                               None)
-                                                                                                                                                    })
-                                                                                                                                        }
-                                                                                                                                    }
-                                                                                                                                    Failed
-                                                                                                                                    =>
-                                                                                                                                    Failed,
-                                                                                                                                }
-                                                                                                                            }
+                                                                                                                            parse___(input,
+                                                                                                                                     state,
+                                                                                                                                     pos)
                                                                                                                         }
                                                                                                                         Failed
                                                                                                                         =>
@@ -2202,135 +2266,77 @@ fn parse_suffixed<'input>(input: &'input str, state: &mut ParseState,
                                                                                                             =>
                                                                                                             Failed,
                                                                                                         }
+                                                                                                    };
+                                                                                                match sep_res
+                                                                                                    {
+                                                                                                    Matched(newpos,
+                                                                                                            _)
+                                                                                                    =>
+                                                                                                    {
+                                                                                                        newpos
                                                                                                     }
+                                                                                                    Failed
+                                                                                                    =>
+                                                                                                    break
+                                                                                                        ,
                                                                                                 }
-                                                                                                Failed
-                                                                                                =>
-                                                                                                Failed,
+                                                                                            } else {
+                                                                                                pos
+                                                                                            };
+                                                                                        let step_res =
+                                                                                            parse_rust_type(input,
+                                                                                                            state,
+                                                                                                            pos);
+                                                                                        match step_res
+                                                                                            {
+                                                                                            Matched(newpos,
+                                                                                                    value)
+                                                                                            =>
+                                                                                            {
+                                                                                                repeat_pos
+                                                                                                    =
+                                                                                                    newpos;
+                                                                                                repeat_value.push(value);
+                                                                                            }
+                                                                                            Failed
+                                                                                            =>
+                                                                                            {
+                                                                                                break
+                                                                                                    ;
                                                                                             }
                                                                                         }
                                                                                     }
-                                                                                    Failed
-                                                                                    =>
-                                                                                    Failed,
-                                                                                }
-                                                                            }
-                                                                        }
-                                                                        Failed
-                                                                        =>
-                                                                        Failed,
-                                                                    }
-                                                                }
-                                                            };
-                                                        match choice_res {
-                                                            Matched(pos,
-                                                                    value) =>
-                                                            Matched(pos,
-                                                                    value),
-                                                            Failed => {
-                                                                let choice_res =
-                                                                    {
-                                                                        let start_pos =
-                                                                            pos;
-                                                                        {
-                                                                            let seq_res =
-                                                                                parse_primary(input,
-                                                                                              state,
-                                                                                              pos);
+                                                                                    if repeat_value.len()
+                                                                                           >=
+                                                                                           1usize
+                                                                                       {
+                                                                                        Matched(repeat_pos,
+                                                                                                ())
+                                                                                    } else {
+                                                                                        Failed
+                                                                                    }
+                                                                                };
                                                                             match seq_res
                                                                                 {
                                                                                 Matched(pos,
-                                                                                        expression)
+                                                                                        _)
                                                                                 =>
                                                                                 {
                                                                                     {
                                                                                         let seq_res =
-                                                                                            parse_lbrace(input,
-                                                                                                         state,
-                                                                                                         pos);
+                                                                                            slice_eq(input,
+                                                                                                     state,
+                                                                                                     pos,
+                                                                                                     ")");
                                                                                         match seq_res
                                                                                             {
                                                                                             Matched(pos,
                                                                                                     _)
                                                                                             =>
                                                                                             {
-                                                                                                {
-                                                                                                    let seq_res =
-                                                                                                        parse_comma(input,
-                                                                                                                    state,
-                                                                                                                    pos);
-                                                                                                    match seq_res
-                                                                                                        {
-                                                                                                        Matched(pos,
-                                                                                                                _)
-                                                                                                        =>
-                                                                                                        {
-                                                                                                            {
-                                                                                                                let seq_res =
-                                                                                                                    match parse_integer(input,
-                                                                                                                                        state,
-                                                                                                                                        pos)
-                                                                                                                        {
-                                                                                                                        Matched(newpos,
-                                                                                                                                value)
-                                                                                                                        =>
-                                                                                                                        {
-                                                                                                                            Matched(newpos,
-                                                                                                                                    Some(value))
-                                                                                                                        }
-                                                                                                                        Failed
-                                                                                                                        =>
-                                                                                                                        {
-                                                                                                                            Matched(pos,
-                                                                                                                                    None)
-                                                                                                                        }
-                                                                                                                    };
-                                                                                                                match seq_res
-                                                                                                                    {
-                                                                                                                    Matched(pos,
-                                                                                                                            max)
-                                                                                                                    =>
-                                                                                                                    {
-                                                                                                                        {
-                                                                                                                            let seq_res =
-                                                                                                                                parse_rbrace(input,
-                                                                                                                                             state,
-                                                                                                                                             pos);
-                                                                                                                            match seq_res
-                                                                                                                                {
-                                                                                                                                Matched(pos,
-                                                                                                                                        _)
-                                                                                                                                =>
-                                                                                                                                {
-                                                                                                                                    {
-                                                                                                                                        let match_str =
-                                                                                                                                            &input[start_pos..pos];
-                                                                                                                                        Matched(pos,
-                                                                                                                                                {
-                                                                                                                                                    Repeat(box() expression,
-                                                                                                                                                           0,
-                                                                                                                                                           max,
-                                                                                                                                                           None)
-                                                                                                                                                })
-                                                                                                                                    }
-                                                                                                                                }
-                                                                                                                                Failed
-                                                                                                                                =>
-                                                                                                                                Failed,
-                                                                                                                            }
-                                                                                                                        }
-                                                                                                                    }
-                                                                                                                    Failed
-                                                                                                                    =>
-                                                                                                                    Failed,
-                                                                                                                }
-                                                                                                            }
-                                                                                                        }
-                                                                                                        Failed
-                                                                                                        =>
-                                                                                                        Failed,
-                                                                                                    }
-                                                                                                }
+                                                                                                parse___(input,
+                                                                                                         state,
+                                                                                                         pos)
                                                                                             }
                                                                                             Failed
                                                                                             =>
@@ -2343,7 +2349,4424 @@ fn parse_suffixed<'input>(input: &'input str, state: &mut ParseState,
                                                                                 Failed,
                                                                             }
                                                                         }
-                                                                    };
+                                                                    }
+                                                                    Failed =>
+                                                                    Failed,
+                                                                }
+                                                            };
+                                                        match choice_res {
+                                                            Matched(pos,
+                                                                    value) =>
+                                                            Matched(pos,
+                                                                    value),
+                                                            Failed => {
+                                                                let seq_res =
+                                                                    parse_identifier(input,
+                                                                                     state,
+                                                                                     pos);
+                                                                match seq_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            _)
+                                                                    => {
+                                                                        slice_eq(input,
+                                                                                 state,
+                                                                                 pos,
+                                                                                 "")
+                                                                    }
+                                                                    Failed =>
+                                                                    Failed,
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "rust_type" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "rust_type" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let choice_res =
+                {
+                    let seq_res = slice_eq(input, state, pos, "()");
+                    match seq_res {
+                        Matched(pos, _) => { parse___(input, state, pos) }
+                        Failed => Failed,
+                    }
+                };
+            match choice_res {
+                Matched(pos, value) => Matched(pos, value),
+                Failed => {
+                    let choice_res =
+                        {
+                            let seq_res = slice_eq(input, state, pos, "[");
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    {
+                                        let seq_res =
+                                            parse_rust_type(input, state,
+                                                            pos);
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let seq_res =
+                                                        slice_eq(input, state,
+                                                                 pos, "]");
+                                                    match seq_res {
+                                                        Matched(pos, _) => {
+                                                            parse___(input,
+                                                                     state,
+                                                                     pos)
+                                                        }
+                                                        Failed => Failed,
+                                                    }
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        };
+                    match choice_res {
+                        Matched(pos, value) => Matched(pos, value),
+                        Failed => {
+                            let choice_res =
+                                {
+                                    let seq_res =
+                                        slice_eq(input, state, pos, "&");
+                                    match seq_res {
+                                        Matched(pos, _) => {
+                                            {
+                                                let seq_res =
+                                                    match {
+                                                              let seq_res =
+                                                                  slice_eq(input,
+                                                                           state,
+                                                                           pos,
+                                                                           "\'");
+                                                              match seq_res {
+                                                                  Matched(pos,
+                                                                          _)
+                                                                  => {
+                                                                      parse_identifier(input,
+                                                                                       state,
+                                                                                       pos)
+                                                                  }
+                                                                  Failed =>
+                                                                  Failed,
+                                                              }
+                                                          } {
+                                                        Matched(newpos, value)
+                                                        => {
+                                                            Matched(newpos,
+                                                                    Some(value))
+                                                        }
+                                                        Failed => {
+                                                            Matched(pos, None)
+                                                        }
+                                                    };
+                                                match seq_res {
+                                                    Matched(pos, _) => {
+                                                        parse_rust_type(input,
+                                                                        state,
+                                                                        pos)
+                                                    }
+                                                    Failed => Failed,
+                                                }
+                                            }
+                                        }
+                                        Failed => Failed,
+                                    }
+                                };
+                            match choice_res {
+                                Matched(pos, value) => Matched(pos, value),
+                                Failed => {
+                                    let choice_res =
+                                        {
+                                            let seq_res =
+                                                parse_identifier(input, state,
+                                                                 pos);
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    {
+                                                        let seq_res =
+                                                            slice_eq(input,
+                                                                     state,
+                                                                     pos,
+                                                                     "<");
+                                                        match seq_res {
+                                                            Matched(pos, _) =>
+                                                            {
+                                                                {
+                                                                    let seq_res =
+                                                                        {
+                                                                            let mut repeat_pos =
+                                                                                pos;
+                                                                            let mut repeat_value =
+                                                                                vec!();
+                                                                            loop 
+                                                                                 {
+                                                                                let pos =
+                                                                                    repeat_pos;
+                                                                                let pos =
+                                                                                    if repeat_value.len()
+                                                                                           >
+                                                                                           0
+                                                                                       {
+                                                                                        let sep_res =
+                                                                                            {
+                                                                                                let seq_res =
+                                                                                                    parse___(input,
+                                                                                                             state,
+                                                                                                             pos);
+                                                                                                match seq_res
+                                                                                                    {
+                                                                                                    Matched(pos,
+                                                                                                            _)
+                                                                                                    =>
+                                                                                                    {
+                                                                                                        {
+                                                                                                            let seq_res =
+                                                                                                                slice_eq(input,
+                                                                                                                         state,
+                                                                                                                         pos,
+                                                                                                                         ",");
+                                                                                                            match seq_res
+                                                                                                                {
+                                                                                                                Matched(pos,
+                                                                                                                        _)
+                                                                                                                =>
+                                                                                                                {
+                                                                                                                    parse___(input,
+                                                                                                                             state,
+                                                                                                                             pos)
+                                                                                                                }
+                                                                                                                Failed
+                                                                                                                =>
+                                                                                                                Failed,
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                    Failed
+                                                                                                    =>
+                                                                                                    Failed,
+                                                                                                }
+                                                                                            };
+                                                                                        match sep_res
+                                                                                            {
+                                                                                            Matched(newpos,
+                                                                                                    _)
+                                                                                            =>
+                                                                                            {
+                                                                                                newpos
+                                                                                            }
+                                                                                            Failed
+                                                                                            =>
+                                                                                            break
+                                                                                                ,
+                                                                                        }
+                                                                                    } else {
+                                                                                        pos
+                                                                                    };
+                                                                                let step_res =
+                                                                                    {
+                                                                                        let choice_res =
+                                                                                            {
+                                                                                                let seq_res =
+                                                                                                    slice_eq(input,
+                                                                                                             state,
+                                                                                                             pos,
+                                                                                                             "\'");
+                                                                                                match seq_res
+                                                                                                    {
+                                                                                                    Matched(pos,
+                                                                                                            _)
+                                                                                                    =>
+                                                                                                    {
+                                                                                                        {
+                                                                                                            let seq_res =
+                                                                                                                parse_identifier(input,
+                                                                                                                                 state,
+                                                                                                                                 pos);
+                                                                                                            match seq_res
+                                                                                                                {
+                                                                                                                Matched(pos,
+                                                                                                                        _)
+                                                                                                                =>
+                                                                                                                {
+                                                                                                                    slice_eq(input,
+                                                                                                                             state,
+                                                                                                                             pos,
+                                                                                                                             "")
+                                                                                                                }
+                                                                                                                Failed
+                                                                                                                =>
+                                                                                                                Failed,
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                    Failed
+                                                                                                    =>
+                                                                                                    Failed,
+                                                                                                }
+                                                                                            };
+                                                                                        match choice_res
+                                                                                            {
+                                                                                            Matched(pos,
+                                                                                                    value)
+                                                                                            =>
+                                                                                            Matched(pos,
+                                                                                                    value),
+                                                                                            Failed
+                                                                                            =>
+                                                                                            parse_rust_type(input,
+                                                                                                            state,
+                                                                                                            pos),
+                                                                                        }
+                                                                                    };
+                                                                                match step_res
+                                                                                    {
+                                                                                    Matched(newpos,
+                                                                                            value)
+                                                                                    =>
+                                                                                    {
+                                                                                        repeat_pos
+                                                                                            =
+                                                                                            newpos;
+                                                                                        repeat_value.push(value);
+                                                                                    }
+                                                                                    Failed
+                                                                                    =>
+                                                                                    {
+                                                                                        break
+                                                                                            ;
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                            Matched(repeat_pos,
+                                                                                    ())
+                                                                        };
+                                                                    match seq_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                _)
+                                                                        => {
+                                                                            {
+                                                                                let seq_res =
+                                                                                    slice_eq(input,
+                                                                                             state,
+                                                                                             pos,
+                                                                                             ">");
+                                                                                match seq_res
+                                                                                    {
+                                                                                    Matched(pos,
+                                                                                            _)
+                                                                                    =>
+                                                                                    {
+                                                                                        parse___(input,
+                                                                                                 state,
+                                                                                                 pos)
+                                                                                    }
+                                                                                    Failed
+                                                                                    =>
+                                                                                    Failed,
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                        Failed
+                                                                        =>
+                                                                        Failed,
+                                                                    }
+                                                                }
+                                                            }
+                                                            Failed => Failed,
+                                                        }
+                                                    }
+                                                }
+                                                Failed => Failed,
+                                            }
+                                        };
+                                    match choice_res {
+                                        Matched(pos, value) =>
+                                        Matched(pos, value),
+                                        Failed => {
+                                            let choice_res =
+                                                {
+                                                    let seq_res =
+                                                        parse_identifier(input,
+                                                                         state,
+                                                                         pos);
+                                                    match seq_res {
+                                                        Matched(pos, _) => {
+                                                            {
+                                                                let seq_res =
+                                                                    slice_eq(input,
+                                                                             state,
+                                                                             pos,
+                                                                             "::");
+                                                                match seq_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            _)
+                                                                    => {
+                                                                        parse_rust_type(input,
+                                                                                        state,
+                                                                                        pos)
+                                                                    }
+                                                                    Failed =>
+                                                                    Failed,
+                                                                }
+                                                            }
+                                                        }
+                                                        Failed => Failed,
+                                                    }
+                                                };
+                                            match choice_res {
+                                                Matched(pos, value) =>
+                                                Matched(pos, value),
+                                                Failed => {
+                                                    let choice_res =
+                                                        {
+                                                            let seq_res =
+                                                                slice_eq(input,
+                                                                         state,
+                                                                         pos,
+                                                                         "(");
+                                                            match seq_res {
+                                                                Matched(pos,
+                                                                        _) =>
+                                                                {
+                                                                    {
+                                                                        let seq_res =
+                                                                            {
+                                                                                let mut repeat_pos =
+                                                                                    pos;
+                                                                                let mut repeat_value =
+                                                                                    vec!();
+                                                                                loop 
+                                                                                     {
+                                                                                    let pos =
+                                                                                        repeat_pos;
+                                                                                    let pos =
+                                                                                        if repeat_value.len()
+                                                                                               >
+                                                                                               0
+                                                                                           {
+                                                                                            let sep_res =
+                                                                                                {
+                                                                                                    let seq_res =
+                                                                                                        parse___(input,
+                                                                                                                 state,
+                                                                                                                 pos);
+                                                                                                    match seq_res
+                                                                                                        {
+                                                                                                        Matched(pos,
+                                                                                                                _)
+                                                                                                        =>
+                                                                                                        {
+                                                                                                            {
+                                                                                                                let seq_res =
+                                                                                                                    slice_eq(input,
+                                                                                                                             state,
+                                                                                                                             pos,
+                                                                                                                             ",");
+                                                                                                                match seq_res
+                                                                                                                    {
+                                                                                                                    Matched(pos,
+                                                                                                                            _)
+                                                                                                                    =>
+                                                                                                                    {
+                                                                                                                        parse___(input,
+                                                                                                                                 state,
+                                                                                                                                 pos)
+                                                                                                                    }
+                                                                                                                    Failed
+                                                                                                                    =>
+                                                                                                                    Failed,
+                                                                                                                }
+                                                                                                            }
+                                                                                                        }
+                                                                                                        Failed
+                                                                                                        =>
+                                                                                                        Failed,
+                                                                                                    }
+                                                                                                };
+                                                                                            match sep_res
+                                                                                                {
+                                                                                                Matched(newpos,
+                                                                                                        _)
+                                                                                                =>
+                                                                                                {
+                                                                                                    newpos
+                                                                                                }
+                                                                                                Failed
+                                                                                                =>
+                                                                                                break
+                                                                                                    ,
+                                                                                            }
+                                                                                        } else {
+                                                                                            pos
+                                                                                        };
+                                                                                    let step_res =
+                                                                                        parse_rust_type(input,
+                                                                                                        state,
+                                                                                                        pos);
+                                                                                    match step_res
+                                                                                        {
+                                                                                        Matched(newpos,
+                                                                                                value)
+                                                                                        =>
+                                                                                        {
+                                                                                            repeat_pos
+                                                                                                =
+                                                                                                newpos;
+                                                                                            repeat_value.push(value);
+                                                                                        }
+                                                                                        Failed
+                                                                                        =>
+                                                                                        {
+                                                                                            break
+                                                                                                ;
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                                if repeat_value.len()
+                                                                                       >=
+                                                                                       1usize
+                                                                                   {
+                                                                                    Matched(repeat_pos,
+                                                                                            ())
+                                                                                } else {
+                                                                                    Failed
+                                                                                }
+                                                                            };
+                                                                        match seq_res
+                                                                            {
+                                                                            Matched(pos,
+                                                                                    _)
+                                                                            =>
+                                                                            {
+                                                                                {
+                                                                                    let seq_res =
+                                                                                        slice_eq(input,
+                                                                                                 state,
+                                                                                                 pos,
+                                                                                                 ")");
+                                                                                    match seq_res
+                                                                                        {
+                                                                                        Matched(pos,
+                                                                                                _)
+                                                                                        =>
+                                                                                        {
+                                                                                            parse___(input,
+                                                                                                     state,
+                                                                                                     pos)
+                                                                                        }
+                                                                                        Failed
+                                                                                        =>
+                                                                                        Failed,
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                            Failed
+                                                                            =>
+                                                                            Failed,
+                                                                        }
+                                                                    }
+                                                                }
+                                                                Failed =>
+                                                                Failed,
+                                                            }
+                                                        };
+                                                    match choice_res {
+                                                        Matched(pos, value) =>
+                                                        Matched(pos, value),
+                                                        Failed => {
+                                                            let seq_res =
+                                                                parse_identifier(input,
+                                                                                 state,
+                                                                                 pos);
+                                                            match seq_res {
+                                                                Matched(pos,
+                                                                        _) =>
+                                                                {
+                                                                    slice_eq(input,
+                                                                             state,
+                                                                             pos,
+                                                                             "")
+                                                                }
+                                                                Failed =>
+                                                                Failed,
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+fn parse_expression<'input>(input: &'input str, state: &mut ParseState,
+                            pos: usize) -> RuleResult<Expr> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "expression" , line , col);
+        let mut __peg_closure = move || { parse_choice(input, state, pos) };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "expression" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "expression" , line , col),
+        }
+        __peg_result
+    } else { parse_choice(input, state, pos) }
+}
+fn parse_choice<'input>(input: &'input str, state: &mut ParseState,
+                        pos: usize) -> RuleResult<Expr> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "choice"
+                 , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res = parse_sequence(input, state, pos);
+                    match seq_res {
+                        Matched(pos, head) => {
+                            {
+                                let seq_res =
+                                    {
+                                        let mut repeat_pos = pos;
+                                        let mut repeat_value = vec!();
+                                        loop  {
+                                            let pos = repeat_pos;
+                                            let step_res =
+                                                {
+                                                    let start_pos = pos;
+                                                    {
+                                                        let seq_res =
+                                                            parse_slash(input,
+                                                                        state,
+                                                                        pos);
+                                                        match seq_res {
+                                                            Matched(pos, _) =>
+                                                            {
+                                                                {
+                                                                    let seq_res =
+                                                                        parse_sequence(input,
+                                                                                       state,
+                                                                                       pos);
+                                                                    match seq_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                s)
+                                                                        => {
+                                                                            {
+                                                                                let match_str =
+                                                                                    &input[start_pos..pos];
+                                                                                Matched(pos,
+                                                                                        {
+                                                                                            s
+                                                                                        })
+                                                                            }
+                                                                        }
+                                                                        Failed
+                                                                        =>
+                                                                        Failed,
+                                                                    }
+                                                                }
+                                                            }
+                                                            Failed => Failed,
+                                                        }
+                                                    }
+                                                };
+                                            match step_res {
+                                                Matched(newpos, value) => {
+                                                    repeat_pos = newpos;
+                                                    repeat_value.push(value);
+                                                }
+                                                Failed => { break ; }
+                                            }
+                                        }
+                                        Matched(repeat_pos, repeat_value)
+                                    };
+                                match seq_res {
+                                    Matched(pos, tail) => {
+                                        {
+                                            let match_str =
+                                                &input[start_pos..pos];
+                                            Matched(pos,
+                                                    {
+                                                        if tail.len() > 0 {
+                                                            let mut list =
+                                                                tail;
+                                                            list.insert(0,
+                                                                        head);
+                                                            ChoiceExpr(list)
+                                                        } else { head }
+                                                    })
+                                        }
+                                    }
+                                    Failed => Failed,
+                                }
+                            }
+                        }
+                        Failed => Failed,
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "choice" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "choice"
+                     , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
+            {
+                let seq_res = parse_sequence(input, state, pos);
+                match seq_res {
+                    Matched(pos, head) => {
+                        {
+                            let seq_res =
+                                {
+                                    let mut repeat_pos = pos;
+                                    let mut repeat_value = vec!();
+                                    loop  {
+                                        let pos = repeat_pos;
+                                        let step_res =
+                                            {
+                                                let start_pos = pos;
+                                                {
+                                                    let seq_res =
+                                                        parse_slash(input,
+                                                                    state,
+                                                                    pos);
+                                                    match seq_res {
+                                                        Matched(pos, _) => {
+                                                            {
+                                                                let seq_res =
+                                                                    parse_sequence(input,
+                                                                                   state,
+                                                                                   pos);
+                                                                match seq_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            s)
+                                                                    => {
+                                                                        {
+                                                                            let match_str =
+                                                                                &input[start_pos..pos];
+                                                                            Matched(pos,
+                                                                                    {
+                                                                                        s
+                                                                                    })
+                                                                        }
+                                                                    }
+                                                                    Failed =>
+                                                                    Failed,
+                                                                }
+                                                            }
+                                                        }
+                                                        Failed => Failed,
+                                                    }
+                                                }
+                                            };
+                                        match step_res {
+                                            Matched(newpos, value) => {
+                                                repeat_pos = newpos;
+                                                repeat_value.push(value);
+                                            }
+                                            Failed => { break ; }
+                                        }
+                                    }
+                                    Matched(repeat_pos, repeat_value)
+                                };
+                            match seq_res {
+                                Matched(pos, tail) => {
+                                    {
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos,
+                                                {
+                                                    if tail.len() > 0 {
+                                                        let mut list = tail;
+                                                        list.insert(0, head);
+                                                        ChoiceExpr(list)
+                                                    } else { head }
+                                                })
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    }
+                    Failed => Failed,
+                }
+            }
+        }
+    }
+}
+fn parse_sequence<'input>(input: &'input str, state: &mut ParseState,
+                          pos: usize) -> RuleResult<Expr> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "sequence" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let choice_res =
+                    {
+                        let start_pos = pos;
+                        {
+                            let seq_res =
+                                {
+                                    let mut repeat_pos = pos;
+                                    let mut repeat_value = vec!();
+                                    loop  {
+                                        let pos = repeat_pos;
+                                        let step_res =
+                                            parse_labeled(input, state, pos);
+                                        match step_res {
+                                            Matched(newpos, value) => {
+                                                repeat_pos = newpos;
+                                                repeat_value.push(value);
+                                            }
+                                            Failed => { break ; }
+                                        }
+                                    }
+                                    Matched(repeat_pos, repeat_value)
+                                };
+                            match seq_res {
+                                Matched(pos, elements) => {
+                                    {
+                                        let seq_res =
+                                            parse_action(input, state, pos);
+                                        match seq_res {
+                                            Matched(pos, code) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos,
+                                                            {
+                                                                ActionExpr(elements,
+                                                                           code.0,
+                                                                           code.1)
+                                                            })
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    };
+                match choice_res {
+                    Matched(pos, value) => Matched(pos, value),
+                    Failed => {
+                        let start_pos = pos;
+                        {
+                            let seq_res =
+                                {
+                                    let mut repeat_pos = pos;
+                                    let mut repeat_value = vec!();
+                                    loop  {
+                                        let pos = repeat_pos;
+                                        let step_res =
+                                            parse_prefixed(input, state, pos);
+                                        match step_res {
+                                            Matched(newpos, value) => {
+                                                repeat_pos = newpos;
+                                                repeat_value.push(value);
+                                            }
+                                            Failed => { break ; }
+                                        }
+                                    }
+                                    Matched(repeat_pos, repeat_value)
+                                };
+                            match seq_res {
+                                Matched(pos, elements) => {
+                                    {
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos,
+                                                {
+                                                    if elements.len() != 1 {
+                                                        SequenceExpr(elements)
+                                                    } else {
+                                                        elements.into_iter().next().unwrap()
+                                                    }
+                                                })
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "sequence" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "sequence" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let choice_res =
+                {
+                    let start_pos = pos;
+                    {
+                        let seq_res =
+                            {
+                                let mut repeat_pos = pos;
+                                let mut repeat_value = vec!();
+                                loop  {
+                                    let pos = repeat_pos;
+                                    let step_res =
+                                        parse_labeled(input, state, pos);
+                                    match step_res {
+                                        Matched(newpos, value) => {
+                                            repeat_pos = newpos;
+                                            repeat_value.push(value);
+                                        }
+                                        Failed => { break ; }
+                                    }
+                                }
+                                Matched(repeat_pos, repeat_value)
+                            };
+                        match seq_res {
+                            Matched(pos, elements) => {
+                                {
+                                    let seq_res =
+                                        parse_action(input, state, pos);
+                                    match seq_res {
+                                        Matched(pos, code) => {
+                                            {
+                                                let match_str =
+                                                    &input[start_pos..pos];
+                                                Matched(pos,
+                                                        {
+                                                            ActionExpr(elements,
+                                                                       code.0,
+                                                                       code.1)
+                                                        })
+                                            }
+                                        }
+                                        Failed => Failed,
+                                    }
+                                }
+                            }
+                            Failed => Failed,
+                        }
+                    }
+                };
+            match choice_res {
+                Matched(pos, value) => Matched(pos, value),
+                Failed => {
+                    let start_pos = pos;
+                    {
+                        let seq_res =
+                            {
+                                let mut repeat_pos = pos;
+                                let mut repeat_value = vec!();
+                                loop  {
+                                    let pos = repeat_pos;
+                                    let step_res =
+                                        parse_prefixed(input, state, pos);
+                                    match step_res {
+                                        Matched(newpos, value) => {
+                                            repeat_pos = newpos;
+                                            repeat_value.push(value);
+                                        }
+                                        Failed => { break ; }
+                                    }
+                                }
+                                Matched(repeat_pos, repeat_value)
+                            };
+                        match seq_res {
+                            Matched(pos, elements) => {
+                                {
+                                    let match_str = &input[start_pos..pos];
+                                    Matched(pos,
+                                            {
+                                                if elements.len() != 1 {
+                                                    SequenceExpr(elements)
+                                                } else {
+                                                    elements.into_iter().next().unwrap()
+                                                }
+                                            })
+                                }
+                            }
+                            Failed => Failed,
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+fn parse_labeled<'input>(input: &'input str, state: &mut ParseState,
+                         pos: usize) -> RuleResult<TaggedExpr> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "labeled" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let choice_res =
+                    {
+                        let start_pos = pos;
+                        {
+                            let seq_res = parse_identifier(input, state, pos);
+                            match seq_res {
+                                Matched(pos, label) => {
+                                    {
+                                        let seq_res =
+                                            parse_colon(input, state, pos);
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let seq_res =
+                                                        parse_prefixed(input,
+                                                                       state,
+                                                                       pos);
+                                                    match seq_res {
+                                                        Matched(pos,
+                                                                expression) =>
+                                                        {
+                                                            {
+                                                                let match_str =
+                                                                    &input[start_pos..pos];
+                                                                Matched(pos,
+                                                                        {
+                                                                            TaggedExpr{name:
+                                                                                           Some(label),
+                                                                                       expr:
+                                                                                           box() expression,}
+                                                                        })
+                                                            }
+                                                        }
+                                                        Failed => Failed,
+                                                    }
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    };
+                match choice_res {
+                    Matched(pos, value) => Matched(pos, value),
+                    Failed => {
+                        let start_pos = pos;
+                        {
+                            let seq_res = parse_prefixed(input, state, pos);
+                            match seq_res {
+                                Matched(pos, expr) => {
+                                    {
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos,
+                                                {
+                                                    TaggedExpr{name: None,
+                                                               expr:
+                                                                   box() expr,}
+                                                })
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "labeled" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "labeled" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let choice_res =
+                {
+                    let start_pos = pos;
+                    {
+                        let seq_res = parse_identifier(input, state, pos);
+                        match seq_res {
+                            Matched(pos, label) => {
+                                {
+                                    let seq_res =
+                                        parse_colon(input, state, pos);
+                                    match seq_res {
+                                        Matched(pos, _) => {
+                                            {
+                                                let seq_res =
+                                                    parse_prefixed(input,
+                                                                   state,
+                                                                   pos);
+                                                match seq_res {
+                                                    Matched(pos, expression)
+                                                    => {
+                                                        {
+                                                            let match_str =
+                                                                &input[start_pos..pos];
+                                                            Matched(pos,
+                                                                    {
+                                                                        TaggedExpr{name:
+                                                                                       Some(label),
+                                                                                   expr:
+                                                                                       box() expression,}
+                                                                    })
+                                                        }
+                                                    }
+                                                    Failed => Failed,
+                                                }
+                                            }
+                                        }
+                                        Failed => Failed,
+                                    }
+                                }
+                            }
+                            Failed => Failed,
+                        }
+                    }
+                };
+            match choice_res {
+                Matched(pos, value) => Matched(pos, value),
+                Failed => {
+                    let start_pos = pos;
+                    {
+                        let seq_res = parse_prefixed(input, state, pos);
+                        match seq_res {
+                            Matched(pos, expr) => {
+                                {
+                                    let match_str = &input[start_pos..pos];
+                                    Matched(pos,
+                                            {
+                                                TaggedExpr{name: None,
+                                                           expr: box() expr,}
+                                            })
+                                }
+                            }
+                            Failed => Failed,
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+fn parse_prefixed<'input>(input: &'input str, state: &mut ParseState,
+                          pos: usize) -> RuleResult<Expr> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "prefixed" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let choice_res =
+                    {
+                        let start_pos = pos;
+                        {
+                            let seq_res = parse_dollar(input, state, pos);
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    {
+                                        let seq_res =
+                                            parse_suffixed(input, state, pos);
+                                        match seq_res {
+                                            Matched(pos, expression) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos,
+                                                            { expression })
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    };
+                match choice_res {
+                    Matched(pos, value) => Matched(pos, value),
+                    Failed => {
+                        let choice_res =
+                            {
+                                let start_pos = pos;
+                                {
+                                    let seq_res =
+                                        parse_and(input, state, pos);
+                                    match seq_res {
+                                        Matched(pos, _) => {
+                                            {
+                                                let seq_res =
+                                                    parse_suffixed(input,
+                                                                   state,
+                                                                   pos);
+                                                match seq_res {
+                                                    Matched(pos, expression)
+                                                    => {
+                                                        {
+                                                            let match_str =
+                                                                &input[start_pos..pos];
+                                                            Matched(pos,
+                                                                    {
+                                                                        PosAssertExpr(box() expression)
+                                                                    })
+                                                        }
+                                                    }
+                                                    Failed => Failed,
+                                                }
+                                            }
+                                        }
+                                        Failed => Failed,
+                                    }
+                                }
+                            };
+                        match choice_res {
+                            Matched(pos, value) => Matched(pos, value),
+                            Failed => {
+                                let choice_res =
+                                    {
+                                        let start_pos = pos;
+                                        {
+                                            let seq_res =
+                                                parse_not(input, state, pos);
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    {
+                                                        let seq_res =
+                                                            parse_suffixed(input,
+                                                                           state,
+                                                                           pos);
+                                                        match seq_res {
+                                                            Matched(pos,
+                                                                    expression)
+                                                            => {
+                                                                {
+                                                                    let match_str =
+                                                                        &input[start_pos..pos];
+                                                                    Matched(pos,
+                                                                            {
+                                                                                NegAssertExpr(box() expression)
+                                                                            })
+                                                                }
+                                                            }
+                                                            Failed => Failed,
+                                                        }
+                                                    }
+                                                }
+                                                Failed => Failed,
+                                            }
+                                        }
+                                    };
+                                match choice_res {
+                                    Matched(pos, value) =>
+                                    Matched(pos, value),
+                                    Failed =>
+                                    parse_suffixed(input, state, pos),
+                                }
+                            }
+                        }
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "prefixed" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "prefixed" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let choice_res =
+                {
+                    let start_pos = pos;
+                    {
+                        let seq_res = parse_dollar(input, state, pos);
+                        match seq_res {
+                            Matched(pos, _) => {
+                                {
+                                    let seq_res =
+                                        parse_suffixed(input, state, pos);
+                                    match seq_res {
+                                        Matched(pos, expression) => {
+                                            {
+                                                let match_str =
+                                                    &input[start_pos..pos];
+                                                Matched(pos, { expression })
+                                            }
+                                        }
+                                        Failed => Failed,
+                                    }
+                                }
+                            }
+                            Failed => Failed,
+                        }
+                    }
+                };
+            match choice_res {
+                Matched(pos, value) => Matched(pos, value),
+                Failed => {
+                    let choice_res =
+                        {
+                            let start_pos = pos;
+                            {
+                                let seq_res = parse_and(input, state, pos);
+                                match seq_res {
+                                    Matched(pos, _) => {
+                                        {
+                                            let seq_res =
+                                                parse_suffixed(input, state,
+                                                               pos);
+                                            match seq_res {
+                                                Matched(pos, expression) => {
+                                                    {
+                                                        let match_str =
+                                                            &input[start_pos..pos];
+                                                        Matched(pos,
+                                                                {
+                                                                    PosAssertExpr(box() expression)
+                                                                })
+                                                    }
+                                                }
+                                                Failed => Failed,
+                                            }
+                                        }
+                                    }
+                                    Failed => Failed,
+                                }
+                            }
+                        };
+                    match choice_res {
+                        Matched(pos, value) => Matched(pos, value),
+                        Failed => {
+                            let choice_res =
+                                {
+                                    let start_pos = pos;
+                                    {
+                                        let seq_res =
+                                            parse_not(input, state, pos);
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let seq_res =
+                                                        parse_suffixed(input,
+                                                                       state,
+                                                                       pos);
+                                                    match seq_res {
+                                                        Matched(pos,
+                                                                expression) =>
+                                                        {
+                                                            {
+                                                                let match_str =
+                                                                    &input[start_pos..pos];
+                                                                Matched(pos,
+                                                                        {
+                                                                            NegAssertExpr(box() expression)
+                                                                        })
+                                                            }
+                                                        }
+                                                        Failed => Failed,
+                                                    }
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
+                                };
+                            match choice_res {
+                                Matched(pos, value) => Matched(pos, value),
+                                Failed => parse_suffixed(input, state, pos),
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+fn parse_suffixed<'input>(input: &'input str, state: &mut ParseState,
+                          pos: usize) -> RuleResult<Expr> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "suffixed" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let choice_res =
+                    {
+                        let start_pos = pos;
+                        {
+                            let seq_res = parse_primary(input, state, pos);
+                            match seq_res {
+                                Matched(pos, expression) => {
+                                    {
+                                        let seq_res =
+                                            parse_question(input, state, pos);
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos,
+                                                            {
+                                                                OptionalExpr(box() expression)
+                                                            })
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    };
+                match choice_res {
+                    Matched(pos, value) => Matched(pos, value),
+                    Failed => {
+                        let choice_res =
+                            {
+                                let start_pos = pos;
+                                {
+                                    let seq_res =
+                                        parse_primary(input, state, pos);
+                                    match seq_res {
+                                        Matched(pos, expression) => {
+                                            {
+                                                let seq_res =
+                                                    parse_starstar(input,
+                                                                   state,
+                                                                   pos);
+                                                match seq_res {
+                                                    Matched(pos, _) => {
+                                                        {
+                                                            let seq_res =
+                                                                parse_primary(input,
+                                                                              state,
+                                                                              pos);
+                                                            match seq_res {
+                                                                Matched(pos,
+                                                                        sep)
+                                                                => {
+                                                                    {
+                                                                        let match_str =
+                                                                            &input[start_pos..pos];
+                                                                        Matched(pos,
+                                                                                {
+                                                                                    Repeat(box() expression,
+                                                                                           0,
+                                                                                           None,
+                                                                                           Some(box() sep))
+                                                                                })
+                                                                    }
+                                                                }
+                                                                Failed =>
+                                                                Failed,
+                                                            }
+                                                        }
+                                                    }
+                                                    Failed => Failed,
+                                                }
+                                            }
+                                        }
+                                        Failed => Failed,
+                                    }
+                                }
+                            };
+                        match choice_res {
+                            Matched(pos, value) => Matched(pos, value),
+                            Failed => {
+                                let choice_res =
+                                    {
+                                        let start_pos = pos;
+                                        {
+                                            let seq_res =
+                                                parse_primary(input, state,
+                                                              pos);
+                                            match seq_res {
+                                                Matched(pos, expression) => {
+                                                    {
+                                                        let seq_res =
+                                                            parse_plusplus(input,
+                                                                           state,
+                                                                           pos);
+                                                        match seq_res {
+                                                            Matched(pos, _) =>
+                                                            {
+                                                                {
+                                                                    let seq_res =
+                                                                        parse_primary(input,
+                                                                                      state,
+                                                                                      pos);
+                                                                    match seq_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                sep)
+                                                                        => {
+                                                                            {
+                                                                                let match_str =
+                                                                                    &input[start_pos..pos];
+                                                                                Matched(pos,
+                                                                                        {
+                                                                                            Repeat(box() expression,
+                                                                                                   1,
+                                                                                                   None,
+                                                                                                   Some(box() sep))
+                                                                                        })
+                                                                            }
+                                                                        }
+                                                                        Failed
+                                                                        =>
+                                                                        Failed,
+                                                                    }
+                                                                }
+                                                            }
+                                                            Failed => Failed,
+                                                        }
+                                                    }
+                                                }
+                                                Failed => Failed,
+                                            }
+                                        }
+                                    };
+                                match choice_res {
+                                    Matched(pos, value) =>
+                                    Matched(pos, value),
+                                    Failed => {
+                                        let choice_res =
+                                            {
+                                                let start_pos = pos;
+                                                {
+                                                    let seq_res =
+                                                        parse_primary(input,
+                                                                      state,
+                                                                      pos);
+                                                    match seq_res {
+                                                        Matched(pos,
+                                                                expression) =>
+                                                        {
+                                                            {
+                                                                let seq_res =
+                                                                    parse_star(input,
+                                                                               state,
+                                                                               pos);
+                                                                match seq_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            _)
+                                                                    => {
+                                                                        {
+                                                                            let match_str =
+                                                                                &input[start_pos..pos];
+                                                                            Matched(pos,
+                                                                                    {
+                                                                                        Repeat(box() expression,
+                                                                                               0,
+                                                                                               None,
+                                                                                               None)
+                                                                                    })
+                                                                        }
+                                                                    }
+                                                                    Failed =>
+                                                                    Failed,
+                                                                }
+                                                            }
+                                                        }
+                                                        Failed => Failed,
+                                                    }
+                                                }
+                                            };
+                                        match choice_res {
+                                            Matched(pos, value) =>
+                                            Matched(pos, value),
+                                            Failed => {
+                                                let choice_res =
+                                                    {
+                                                        let start_pos = pos;
+                                                        {
+                                                            let seq_res =
+                                                                parse_primary(input,
+                                                                              state,
+                                                                              pos);
+                                                            match seq_res {
+                                                                Matched(pos,
+                                                                        expression)
+                                                                => {
+                                                                    {
+                                                                        let seq_res =
+                                                                            parse_plus(input,
+                                                                                       state,
+                                                                                       pos);
+                                                                        match seq_res
+                                                                            {
+                                                                            Matched(pos,
+                                                                                    _)
+                                                                            =>
+                                                                            {
+                                                                                {
+                                                                                    let match_str =
+                                                                                        &input[start_pos..pos];
+                                                                                    Matched(pos,
+                                                                                            {
+                                                                                                Repeat(box() expression,
+                                                                                                       1,
+                                                                                                       None,
+                                                                                                       None)
+                                                                                            })
+                                                                                }
+                                                                            }
+                                                                            Failed
+                                                                            =>
+                                                                            Failed,
+                                                                        }
+                                                                    }
+                                                                }
+                                                                Failed =>
+                                                                Failed,
+                                                            }
+                                                        }
+                                                    };
+                                                match choice_res {
+                                                    Matched(pos, value) =>
+                                                    Matched(pos, value),
+                                                    Failed => {
+                                                        let choice_res =
+                                                            {
+                                                                let start_pos =
+                                                                    pos;
+                                                                {
+                                                                    let seq_res =
+                                                                        parse_primary(input,
+                                                                                      state,
+                                                                                      pos);
+                                                                    match seq_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                expression)
+                                                                        => {
+                                                                            {
+                                                                                let seq_res =
+                                                                                    parse_lbrace(input,
+                                                                                                 state,
+                                                                                                 pos);
+                                                                                match seq_res
+                                                                                    {
+                                                                                    Matched(pos,
+                                                                                            _)
+                                                                                    =>
+                                                                                    {
+                                                                                        {
+                                                                                            let seq_res =
+                                                                                                parse_integer(input,
+                                                                                                              state,
+                                                                                                              pos);
+                                                                                            match seq_res
+                                                                                                {
+                                                                                                Matched(pos,
+                                                                                                        n)
+                                                                                                =>
+                                                                                                {
+                                                                                                    {
+                                                                                                        let seq_res =
+                                                                                                            parse_rbrace(input,
+                                                                                                                         state,
+                                                                                                                         pos);
+                                                                                                        match seq_res
+                                                                                                            {
+                                                                                                            Matched(pos,
+                                                                                                                    _)
+                                                                                                            =>
+                                                                                                            {
+                                                                                                                {
+                                                                                                                    let match_str =
+                                                                                                                        &input[start_pos..pos];
+                                                                                                                    Matched(pos,
+                                                                                                                            {
+                                                                                                                                Repeat(box() expression,
+                                                                                                                                       n,
+                                                                                                                                       Some(n),
+                                                                                                                                       None)
+                                                                                                                            })
+                                                                                                                }
+                                                                                                            }
+                                                                                                            Failed
+                                                                                                            =>
+                                                                                                            Failed,
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                                Failed
+                                                                                                =>
+                                                                                                Failed,
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                    Failed
+                                                                                    =>
+                                                                                    Failed,
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                        Failed
+                                                                        =>
+                                                                        Failed,
+                                                                    }
+                                                                }
+                                                            };
+                                                        match choice_res {
+                                                            Matched(pos,
+                                                                    value) =>
+                                                            Matched(pos,
+                                                                    value),
+                                                            Failed => {
+                                                                let choice_res =
+                                                                    {
+                                                                        let start_pos =
+                                                                            pos;
+                                                                        {
+                                                                            let seq_res =
+                                                                                parse_primary(input,
+                                                                                              state,
+                                                                                              pos);
+                                                                            match seq_res
+                                                                                {
+                                                                                Matched(pos,
+                                                                                        expression)
+                                                                                =>
+                                                                                {
+                                                                                    {
+                                                                                        let seq_res =
+                                                                                            parse_lbrace(input,
+                                                                                                         state,
+                                                                                                         pos);
+                                                                                        match seq_res
+                                                                                            {
+                                                                                            Matched(pos,
+                                                                                                    _)
+                                                                                            =>
+                                                                                            {
+                                                                                                {
+                                                                                                    let seq_res =
+                                                                                                        parse_integer(input,
+                                                                                                                      state,
+                                                                                                                      pos);
+                                                                                                    match seq_res
+                                                                                                        {
+                                                                                                        Matched(pos,
+                                                                                                                min)
+                                                                                                        =>
+                                                                                                        {
+                                                                                                            {
+                                                                                                                let seq_res =
+                                                                                                                    parse_comma(input,
+                                                                                                                                state,
+                                                                                                                                pos);
+                                                                                                                match seq_res
+                                                                                                                    {
+                                                                                                                    Matched(pos,
+                                                                                                                            _)
+                                                                                                                    =>
+                                                                                                                    {
+                                                                                                                        {
+                                                                                                                            let seq_res =
+                                                                                                                                match parse_integer(input,
+                                                                                                                                                    state,
+                                                                                                                                                    pos)
+                                                                                                                                    {
+                                                                                                                                    Matched(newpos,
+                                                                                                                                            value)
+                                                                                                                                    =>
+                                                                                                                                    {
+                                                                                                                                        Matched(newpos,
+                                                                                                                                                Some(value))
+                                                                                                                                    }
+                                                                                                                                    Failed
+                                                                                                                                    =>
+                                                                                                                                    {
+                                                                                                                                        Matched(pos,
+                                                                                                                                                None)
+                                                                                                                                    }
+                                                                                                                                };
+                                                                                                                            match seq_res
+                                                                                                                                {
+                                                                                                                                Matched(pos,
+                                                                                                                                        max)
+                                                                                                                                =>
+                                                                                                                                {
+                                                                                                                                    {
+                                                                                                                                        let seq_res =
+                                                                                                                                            parse_rbrace(input,
+                                                                                                                                                         state,
+                                                                                                                                                         pos);
+                                                                                                                                        match seq_res
+                                                                                                                                            {
+                                                                                                                                            Matched(pos,
+                                                                                                                                                    _)
+                                                                                                                                            =>
+                                                                                                                                            {
+                                                                                                                                                {
+                                                                                                                                                    let match_str =
+                                                                                                                                                        &input[start_pos..pos];
+                                                                                                                                                    Matched(pos,
+                                                                                                                                                            {
+                                                                                                                                                                Repeat(box() expression,
+                                                                                                                                                                       min,
+                                                                                                                                                                       max,
+                                                                                                                                                                       None)
+                                                                                                                                                            })
+                                                                                                                                                }
+                                                                                                                                            }
+                                                                                                                                            Failed
+                                                                                                                                            =>
+                                                                                                                                            Failed,
+                                                                                                                                        }
+                                                                                                                                    }
+                                                                                                                                }
+                                                                                                                                Failed
+                                                                                                                                =>
+                                                                                                                                Failed,
+                                                                                                                            }
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                    Failed
+                                                                                                                    =>
+                                                                                                                    Failed,
+                                                                                                                }
+                                                                                                            }
+                                                                                                        }
+                                                                                                        Failed
+                                                                                                        =>
+                                                                                                        Failed,
+                                                                                                    }
+                                                                                                }
+                                                                                            }
+                                                                                            Failed
+                                                                                            =>
+                                                                                            Failed,
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                                Failed
+                                                                                =>
+                                                                                Failed,
+                                                                            }
+                                                                        }
+                                                                    };
+                                                                match choice_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            value)
+                                                                    =>
+                                                                    Matched(pos,
+                                                                            value),
+                                                                    Failed =>
+                                                                    {
+                                                                        let choice_res =
+                                                                            {
+                                                                                let start_pos =
+                                                                                    pos;
+                                                                                {
+                                                                                    let seq_res =
+                                                                                        parse_primary(input,
+                                                                                                      state,
+                                                                                                      pos);
+                                                                                    match seq_res
+                                                                                        {
+                                                                                        Matched(pos,
+                                                                                                expression)
+                                                                                        =>
+                                                                                        {
+                                                                                            {
+                                                                                                let seq_res =
+                                                                                                    parse_lbrace(input,
+                                                                                                                 state,
+                                                                                                                 pos);
+                                                                                                match seq_res
+                                                                                                    {
+                                                                                                    Matched(pos,
+                                                                                                            _)
+                                                                                                    =>
+                                                                                                    {
+                                                                                                        {
+                                                                                                            let seq_res =
+                                                                                                                parse_comma(input,
+                                                                                                                            state,
+                                                                                                                            pos);
+                                                                                                            match seq_res
+                                                                                                                {
+                                                                                                                Matched(pos,
+                                                                                                                        _)
+                                                                                                                =>
+                                                                                                                {
+                                                                                                                    {
+                                                                                                                        let seq_res =
+                                                                                                                            match parse_integer(input,
+                                                                                                                                                state,
+                                                                                                                                                pos)
+                                                                                                                                {
+                                                                                                                                Matched(newpos,
+                                                                                                                                        value)
+                                                                                                                                =>
+                                                                                                                                {
+                                                                                                                                    Matched(newpos,
+                                                                                                                                            Some(value))
+                                                                                                                                }
+                                                                                                                                Failed
+                                                                                                                                =>
+                                                                                                                                {
+                                                                                                                                    Matched(pos,
+                                                                                                                                            None)
+                                                                                                                                }
+                                                                                                                            };
+                                                                                                                        match seq_res
+                                                                                                                            {
+                                                                                                                            Matched(pos,
+                                                                                                                                    max)
+                                                                                                                            =>
+                                                                                                                            {
+                                                                                                                                {
+                                                                                                                                    let seq_res =
+                                                                                                                                        parse_rbrace(input,
+                                                                                                                                                     state,
+                                                                                                                                                     pos);
+                                                                                                                                    match seq_res
+                                                                                                                                        {
+                                                                                                                                        Matched(pos,
+                                                                                                                                                _)
+                                                                                                                                        =>
+                                                                                                                                        {
+                                                                                                                                            {
+                                                                                                                                                let match_str =
+                                                                                                                                                    &input[start_pos..pos];
+                                                                                                                                                Matched(pos,
+                                                                                                                                                        {
+                                                                                                                                                            Repeat(box() expression,
+                                                                                                                                                                   0,
+                                                                                                                                                                   max,
+                                                                                                                                                                   None)
+                                                                                                                                                        })
+                                                                                                                                            }
+                                                                                                                                        }
+                                                                                                                                        Failed
+                                                                                                                                        =>
+                                                                                                                                        Failed,
+                                                                                                                                    }
+                                                                                                                                }
+                                                                                                                            }
+                                                                                                                            Failed
+                                                                                                                            =>
+                                                                                                                            Failed,
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                }
+                                                                                                                Failed
+                                                                                                                =>
+                                                                                                                Failed,
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                    Failed
+                                                                                                    =>
+                                                                                                    Failed,
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                        Failed
+                                                                                        =>
+                                                                                        Failed,
+                                                                                    }
+                                                                                }
+                                                                            };
+                                                                        match choice_res
+                                                                            {
+                                                                            Matched(pos,
+                                                                                    value)
+                                                                            =>
+                                                                            Matched(pos,
+                                                                                    value),
+                                                                            Failed
+                                                                            =>
+                                                                            parse_primary(input,
+                                                                                          state,
+                                                                                          pos),
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "suffixed" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "suffixed" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let choice_res =
+                {
+                    let start_pos = pos;
+                    {
+                        let seq_res = parse_primary(input, state, pos);
+                        match seq_res {
+                            Matched(pos, expression) => {
+                                {
+                                    let seq_res =
+                                        parse_question(input, state, pos);
+                                    match seq_res {
+                                        Matched(pos, _) => {
+                                            {
+                                                let match_str =
+                                                    &input[start_pos..pos];
+                                                Matched(pos,
+                                                        {
+                                                            OptionalExpr(box() expression)
+                                                        })
+                                            }
+                                        }
+                                        Failed => Failed,
+                                    }
+                                }
+                            }
+                            Failed => Failed,
+                        }
+                    }
+                };
+            match choice_res {
+                Matched(pos, value) => Matched(pos, value),
+                Failed => {
+                    let choice_res =
+                        {
+                            let start_pos = pos;
+                            {
+                                let seq_res =
+                                    parse_primary(input, state, pos);
+                                match seq_res {
+                                    Matched(pos, expression) => {
+                                        {
+                                            let seq_res =
+                                                parse_starstar(input, state,
+                                                               pos);
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    {
+                                                        let seq_res =
+                                                            parse_primary(input,
+                                                                          state,
+                                                                          pos);
+                                                        match seq_res {
+                                                            Matched(pos, sep)
+                                                            => {
+                                                                {
+                                                                    let match_str =
+                                                                        &input[start_pos..pos];
+                                                                    Matched(pos,
+                                                                            {
+                                                                                Repeat(box() expression,
+                                                                                       0,
+                                                                                       None,
+                                                                                       Some(box() sep))
+                                                                            })
+                                                                }
+                                                            }
+                                                            Failed => Failed,
+                                                        }
+                                                    }
+                                                }
+                                                Failed => Failed,
+                                            }
+                                        }
+                                    }
+                                    Failed => Failed,
+                                }
+                            }
+                        };
+                    match choice_res {
+                        Matched(pos, value) => Matched(pos, value),
+                        Failed => {
+                            let choice_res =
+                                {
+                                    let start_pos = pos;
+                                    {
+                                        let seq_res =
+                                            parse_primary(input, state, pos);
+                                        match seq_res {
+                                            Matched(pos, expression) => {
+                                                {
+                                                    let seq_res =
+                                                        parse_plusplus(input,
+                                                                       state,
+                                                                       pos);
+                                                    match seq_res {
+                                                        Matched(pos, _) => {
+                                                            {
+                                                                let seq_res =
+                                                                    parse_primary(input,
+                                                                                  state,
+                                                                                  pos);
+                                                                match seq_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            sep)
+                                                                    => {
+                                                                        {
+                                                                            let match_str =
+                                                                                &input[start_pos..pos];
+                                                                            Matched(pos,
+                                                                                    {
+                                                                                        Repeat(box() expression,
+                                                                                               1,
+                                                                                               None,
+                                                                                               Some(box() sep))
+                                                                                    })
+                                                                        }
+                                                                    }
+                                                                    Failed =>
+                                                                    Failed,
+                                                                }
+                                                            }
+                                                        }
+                                                        Failed => Failed,
+                                                    }
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
+                                };
+                            match choice_res {
+                                Matched(pos, value) => Matched(pos, value),
+                                Failed => {
+                                    let choice_res =
+                                        {
+                                            let start_pos = pos;
+                                            {
+                                                let seq_res =
+                                                    parse_primary(input,
+                                                                  state, pos);
+                                                match seq_res {
+                                                    Matched(pos, expression)
+                                                    => {
+                                                        {
+                                                            let seq_res =
+                                                                parse_star(input,
+                                                                           state,
+                                                                           pos);
+                                                            match seq_res {
+                                                                Matched(pos,
+                                                                        _) =>
+                                                                {
+                                                                    {
+                                                                        let match_str =
+                                                                            &input[start_pos..pos];
+                                                                        Matched(pos,
+                                                                                {
+                                                                                    Repeat(box() expression,
+                                                                                           0,
+                                                                                           None,
+                                                                                           None)
+                                                                                })
+                                                                    }
+                                                                }
+                                                                Failed =>
+                                                                Failed,
+                                                            }
+                                                        }
+                                                    }
+                                                    Failed => Failed,
+                                                }
+                                            }
+                                        };
+                                    match choice_res {
+                                        Matched(pos, value) =>
+                                        Matched(pos, value),
+                                        Failed => {
+                                            let choice_res =
+                                                {
+                                                    let start_pos = pos;
+                                                    {
+                                                        let seq_res =
+                                                            parse_primary(input,
+                                                                          state,
+                                                                          pos);
+                                                        match seq_res {
+                                                            Matched(pos,
+                                                                    expression)
+                                                            => {
+                                                                {
+                                                                    let seq_res =
+                                                                        parse_plus(input,
+                                                                                   state,
+                                                                                   pos);
+                                                                    match seq_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                _)
+                                                                        => {
+                                                                            {
+                                                                                let match_str =
+                                                                                    &input[start_pos..pos];
+                                                                                Matched(pos,
+                                                                                        {
+                                                                                            Repeat(box() expression,
+                                                                                                   1,
+                                                                                                   None,
+                                                                                                   None)
+                                                                                        })
+                                                                            }
+                                                                        }
+                                                                        Failed
+                                                                        =>
+                                                                        Failed,
+                                                                    }
+                                                                }
+                                                            }
+                                                            Failed => Failed,
+                                                        }
+                                                    }
+                                                };
+                                            match choice_res {
+                                                Matched(pos, value) =>
+                                                Matched(pos, value),
+                                                Failed => {
+                                                    let choice_res =
+                                                        {
+                                                            let start_pos =
+                                                                pos;
+                                                            {
+                                                                let seq_res =
+                                                                    parse_primary(input,
+                                                                                  state,
+                                                                                  pos);
+                                                                match seq_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            expression)
+                                                                    => {
+                                                                        {
+                                                                            let seq_res =
+                                                                                parse_lbrace(input,
+                                                                                             state,
+                                                                                             pos);
+                                                                            match seq_res
+                                                                                {
+                                                                                Matched(pos,
+                                                                                        _)
+                                                                                =>
+                                                                                {
+                                                                                    {
+                                                                                        let seq_res =
+                                                                                            parse_integer(input,
+                                                                                                          state,
+                                                                                                          pos);
+                                                                                        match seq_res
+                                                                                            {
+                                                                                            Matched(pos,
+                                                                                                    n)
+                                                                                            =>
+                                                                                            {
+                                                                                                {
+                                                                                                    let seq_res =
+                                                                                                        parse_rbrace(input,
+                                                                                                                     state,
+                                                                                                                     pos);
+                                                                                                    match seq_res
+                                                                                                        {
+                                                                                                        Matched(pos,
+                                                                                                                _)
+                                                                                                        =>
+                                                                                                        {
+                                                                                                            {
+                                                                                                                let match_str =
+                                                                                                                    &input[start_pos..pos];
+                                                                                                                Matched(pos,
+                                                                                                                        {
+                                                                                                                            Repeat(box() expression,
+                                                                                                                                   n,
+                                                                                                                                   Some(n),
+                                                                                                                                   None)
+                                                                                                                        })
+                                                                                                            }
+                                                                                                        }
+                                                                                                        Failed
+                                                                                                        =>
+                                                                                                        Failed,
+                                                                                                    }
+                                                                                                }
+                                                                                            }
+                                                                                            Failed
+                                                                                            =>
+                                                                                            Failed,
+                                                                                        }
+                                                                                    }
+                                                                                }
+                                                                                Failed
+                                                                                =>
+                                                                                Failed,
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                    Failed =>
+                                                                    Failed,
+                                                                }
+                                                            }
+                                                        };
+                                                    match choice_res {
+                                                        Matched(pos, value) =>
+                                                        Matched(pos, value),
+                                                        Failed => {
+                                                            let choice_res =
+                                                                {
+                                                                    let start_pos =
+                                                                        pos;
+                                                                    {
+                                                                        let seq_res =
+                                                                            parse_primary(input,
+                                                                                          state,
+                                                                                          pos);
+                                                                        match seq_res
+                                                                            {
+                                                                            Matched(pos,
+                                                                                    expression)
+                                                                            =>
+                                                                            {
+                                                                                {
+                                                                                    let seq_res =
+                                                                                        parse_lbrace(input,
+                                                                                                     state,
+                                                                                                     pos);
+                                                                                    match seq_res
+                                                                                        {
+                                                                                        Matched(pos,
+                                                                                                _)
+                                                                                        =>
+                                                                                        {
+                                                                                            {
+                                                                                                let seq_res =
+                                                                                                    parse_integer(input,
+                                                                                                                  state,
+                                                                                                                  pos);
+                                                                                                match seq_res
+                                                                                                    {
+                                                                                                    Matched(pos,
+                                                                                                            min)
+                                                                                                    =>
+                                                                                                    {
+                                                                                                        {
+                                                                                                            let seq_res =
+                                                                                                                parse_comma(input,
+                                                                                                                            state,
+                                                                                                                            pos);
+                                                                                                            match seq_res
+                                                                                                                {
+                                                                                                                Matched(pos,
+                                                                                                                        _)
+                                                                                                                =>
+                                                                                                                {
+                                                                                                                    {
+                                                                                                                        let seq_res =
+                                                                                                                            match parse_integer(input,
+                                                                                                                                                state,
+                                                                                                                                                pos)
+                                                                                                                                {
+                                                                                                                                Matched(newpos,
+                                                                                                                                        value)
+                                                                                                                                =>
+                                                                                                                                {
+                                                                                                                                    Matched(newpos,
+                                                                                                                                            Some(value))
+                                                                                                                                }
+                                                                                                                                Failed
+                                                                                                                                =>
+                                                                                                                                {
+                                                                                                                                    Matched(pos,
+                                                                                                                                            None)
+                                                                                                                                }
+                                                                                                                            };
+                                                                                                                        match seq_res
+                                                                                                                            {
+                                                                                                                            Matched(pos,
+                                                                                                                                    max)
+                                                                                                                            =>
+                                                                                                                            {
+                                                                                                                                {
+                                                                                                                                    let seq_res =
+                                                                                                                                        parse_rbrace(input,
+                                                                                                                                                     state,
+                                                                                                                                                     pos);
+                                                                                                                                    match seq_res
+                                                                                                                                        {
+                                                                                                                                        Matched(pos,
+                                                                                                                                                _)
+                                                                                                                                        =>
+                                                                                                                                        {
+                                                                                                                                            {
+                                                                                                                                                let match_str =
+                                                                                                                                                    &input[start_pos..pos];
+                                                                                                                                                Matched(pos,
+                                                                                                                                                        {
+                                                                                                                                                            Repeat(box() expression,
+                                                                                                                                                                   min,
+                                                                                                                                                                   max,
+                                                                                                                                                                   None)
+                                                                                                                                                        })
+                                                                                                                                            }
+                                                                                                                                        }
+                                                                                                                                        Failed
+                                                                                                                                        =>
+                                                                                                                                        Failed,
+                                                                                                                                    }
+                                                                                                                                }
+                                                                                                                            }
+                                                                                                                            Failed
+                                                                                                                            =>
+                                                                                                                            Failed,
+                                                                                                                        }
+                                                                                                                    }
+                                                                                                                }
+                                                                                                                Failed
+                                                                                                                =>
+                                                                                                                Failed,
+                                                                                                            }
+                                                                                                        }
+                                                                                                    }
+                                                                                                    Failed
+                                                                                                    =>
+                                                                                                    Failed,
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                        Failed
+                                                                                        =>
+                                                                                        Failed,
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                            Failed
+                                                                            =>
+                                                                            Failed,
+                                                                        }
+                                                                    }
+                                                                };
+                                                            match choice_res {
+                                                                Matched(pos,
+                                                                        value)
+                                                                =>
+                                                                Matched(pos,
+                                                                        value),
+                                                                Failed => {
+                                                                    let choice_res =
+                                                                        {
+                                                                            let start_pos =
+                                                                                pos;
+                                                                            {
+                                                                                let seq_res =
+                                                                                    parse_primary(input,
+                                                                                                  state,
+                                                                                                  pos);
+                                                                                match seq_res
+                                                                                    {
+                                                                                    Matched(pos,
+                                                                                            expression)
+                                                                                    =>
+                                                                                    {
+                                                                                        {
+                                                                                            let seq_res =
+                                                                                                parse_lbrace(input,
+                                                                                                             state,
+                                                                                                             pos);
+                                                                                            match seq_res
+                                                                                                {
+                                                                                                Matched(pos,
+                                                                                                        _)
+                                                                                                =>
+                                                                                                {
+                                                                                                    {
+                                                                                                        let seq_res =
+                                                                                                            parse_comma(input,
+                                                                                                                        state,
+                                                                                                                        pos);
+                                                                                                        match seq_res
+                                                                                                            {
+                                                                                                            Matched(pos,
+                                                                                                                    _)
+                                                                                                            =>
+                                                                                                            {
+                                                                                                                {
+                                                                                                                    let seq_res =
+                                                                                                                        match parse_integer(input,
+                                                                                                                                            state,
+                                                                                                                                            pos)
+                                                                                                                            {
+                                                                                                                            Matched(newpos,
+                                                                                                                                    value)
+                                                                                                                            =>
+                                                                                                                            {
+                                                                                                                                Matched(newpos,
+                                                                                                                                        Some(value))
+                                                                                                                            }
+                                                                                                                            Failed
+                                                                                                                            =>
+                                                                                                                            {
+                                                                                                                                Matched(pos,
+                                                                                                                                        None)
+                                                                                                                            }
+                                                                                                                        };
+                                                                                                                    match seq_res
+                                                                                                                        {
+                                                                                                                        Matched(pos,
+                                                                                                                                max)
+                                                                                                                        =>
+                                                                                                                        {
+                                                                                                                            {
+                                                                                                                                let seq_res =
+                                                                                                                                    parse_rbrace(input,
+                                                                                                                                                 state,
+                                                                                                                                                 pos);
+                                                                                                                                match seq_res
+                                                                                                                                    {
+                                                                                                                                    Matched(pos,
+                                                                                                                                            _)
+                                                                                                                                    =>
+                                                                                                                                    {
+                                                                                                                                        {
+                                                                                                                                            let match_str =
+                                                                                                                                                &input[start_pos..pos];
+                                                                                                                                            Matched(pos,
+                                                                                                                                                    {
+                                                                                                                                                        Repeat(box() expression,
+                                                                                                                                                               0,
+                                                                                                                                                               max,
+                                                                                                                                                               None)
+                                                                                                                                                    })
+                                                                                                                                        }
+                                                                                                                                    }
+                                                                                                                                    Failed
+                                                                                                                                    =>
+                                                                                                                                    Failed,
+                                                                                                                                }
+                                                                                                                            }
+                                                                                                                        }
+                                                                                                                        Failed
+                                                                                                                        =>
+                                                                                                                        Failed,
+                                                                                                                    }
+                                                                                                                }
+                                                                                                            }
+                                                                                                            Failed
+                                                                                                            =>
+                                                                                                            Failed,
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                                Failed
+                                                                                                =>
+                                                                                                Failed,
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                    Failed
+                                                                                    =>
+                                                                                    Failed,
+                                                                                }
+                                                                            }
+                                                                        };
+                                                                    match choice_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                value)
+                                                                        =>
+                                                                        Matched(pos,
+                                                                                value),
+                                                                        Failed
+                                                                        =>
+                                                                        parse_primary(input,
+                                                                                      state,
+                                                                                      pos),
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+fn parse_primary<'input>(input: &'input str, state: &mut ParseState,
+                         pos: usize) -> RuleResult<Expr> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "primary" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let choice_res =
+                    {
+                        let start_pos = pos;
+                        {
+                            let seq_res = parse_identifier(input, state, pos);
+                            match seq_res {
+                                Matched(pos, name) => {
+                                    {
+                                        let seq_res =
+                                            {
+                                                let assert_res =
+                                                    {
+                                                        let seq_res =
+                                                            match parse_string(input,
+                                                                               state,
+                                                                               pos)
+                                                                {
+                                                                Matched(newpos,
+                                                                        value)
+                                                                => {
+                                                                    Matched(newpos,
+                                                                            Some(value))
+                                                                }
+                                                                Failed => {
+                                                                    Matched(pos,
+                                                                            None)
+                                                                }
+                                                            };
+                                                        match seq_res {
+                                                            Matched(pos, _) =>
+                                                            {
+                                                                {
+                                                                    let seq_res =
+                                                                        parse_returntype(input,
+                                                                                         state,
+                                                                                         pos);
+                                                                    match seq_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                _)
+                                                                        => {
+                                                                            parse_equals(input,
+                                                                                         state,
+                                                                                         pos)
+                                                                        }
+                                                                        Failed
+                                                                        =>
+                                                                        Failed,
+                                                                    }
+                                                                }
+                                                            }
+                                                            Failed => Failed,
+                                                        }
+                                                    };
+                                                match assert_res {
+                                                    Failed =>
+                                                    Matched(pos, ()),
+                                                    Matched(..) => Failed,
+                                                }
+                                            };
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos,
+                                                            {
+                                                                RuleExpr(name)
+                                                            })
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    };
+                match choice_res {
+                    Matched(pos, value) => Matched(pos, value),
+                    Failed => {
+                        let choice_res = parse_literal(input, state, pos);
+                        match choice_res {
+                            Matched(pos, value) => Matched(pos, value),
+                            Failed => {
+                                let choice_res =
+                                    parse_class(input, state, pos);
+                                match choice_res {
+                                    Matched(pos, value) =>
+                                    Matched(pos, value),
+                                    Failed => {
+                                        let choice_res =
+                                            {
+                                                let start_pos = pos;
+                                                {
+                                                    let seq_res =
+                                                        parse_dot(input,
+                                                                  state, pos);
+                                                    match seq_res {
+                                                        Matched(pos, _) => {
+                                                            {
+                                                                let match_str =
+                                                                    &input[start_pos..pos];
+                                                                Matched(pos,
+                                                                        {
+                                                                            AnyCharExpr
+                                                                        })
+                                                            }
+                                                        }
+                                                        Failed => Failed,
+                                                    }
+                                                }
+                                            };
+                                        match choice_res {
+                                            Matched(pos, value) =>
+                                            Matched(pos, value),
+                                            Failed => {
+                                                let start_pos = pos;
+                                                {
+                                                    let seq_res =
+                                                        parse_lparen(input,
+                                                                     state,
+                                                                     pos);
+                                                    match seq_res {
+                                                        Matched(pos, _) => {
+                                                            {
+                                                                let seq_res =
+                                                                    parse_expression(input,
+                                                                                     state,
+                                                                                     pos);
+                                                                match seq_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            expression)
+                                                                    => {
+                                                                        {
+                                                                            let seq_res =
+                                                                                parse_rparen(input,
+                                                                                             state,
+                                                                                             pos);
+                                                                            match seq_res
+                                                                                {
+                                                                                Matched(pos,
+                                                                                        _)
+                                                                                =>
+                                                                                {
+                                                                                    {
+                                                                                        let match_str =
+                                                                                            &input[start_pos..pos];
+                                                                                        Matched(pos,
+                                                                                                {
+                                                                                                    expression
+                                                                                                })
+                                                                                    }
+                                                                                }
+                                                                                Failed
+                                                                                =>
+                                                                                Failed,
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                    Failed =>
+                                                                    Failed,
+                                                                }
+                                                            }
+                                                        }
+                                                        Failed => Failed,
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "primary" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "primary" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let choice_res =
+                {
+                    let start_pos = pos;
+                    {
+                        let seq_res = parse_identifier(input, state, pos);
+                        match seq_res {
+                            Matched(pos, name) => {
+                                {
+                                    let seq_res =
+                                        {
+                                            let assert_res =
+                                                {
+                                                    let seq_res =
+                                                        match parse_string(input,
+                                                                           state,
+                                                                           pos)
+                                                            {
+                                                            Matched(newpos,
+                                                                    value) =>
+                                                            {
+                                                                Matched(newpos,
+                                                                        Some(value))
+                                                            }
+                                                            Failed => {
+                                                                Matched(pos,
+                                                                        None)
+                                                            }
+                                                        };
+                                                    match seq_res {
+                                                        Matched(pos, _) => {
+                                                            {
+                                                                let seq_res =
+                                                                    parse_returntype(input,
+                                                                                     state,
+                                                                                     pos);
+                                                                match seq_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            _)
+                                                                    => {
+                                                                        parse_equals(input,
+                                                                                     state,
+                                                                                     pos)
+                                                                    }
+                                                                    Failed =>
+                                                                    Failed,
+                                                                }
+                                                            }
+                                                        }
+                                                        Failed => Failed,
+                                                    }
+                                                };
+                                            match assert_res {
+                                                Failed => Matched(pos, ()),
+                                                Matched(..) => Failed,
+                                            }
+                                        };
+                                    match seq_res {
+                                        Matched(pos, _) => {
+                                            {
+                                                let match_str =
+                                                    &input[start_pos..pos];
+                                                Matched(pos,
+                                                        { RuleExpr(name) })
+                                            }
+                                        }
+                                        Failed => Failed,
+                                    }
+                                }
+                            }
+                            Failed => Failed,
+                        }
+                    }
+                };
+            match choice_res {
+                Matched(pos, value) => Matched(pos, value),
+                Failed => {
+                    let choice_res = parse_literal(input, state, pos);
+                    match choice_res {
+                        Matched(pos, value) => Matched(pos, value),
+                        Failed => {
+                            let choice_res = parse_class(input, state, pos);
+                            match choice_res {
+                                Matched(pos, value) => Matched(pos, value),
+                                Failed => {
+                                    let choice_res =
+                                        {
+                                            let start_pos = pos;
+                                            {
+                                                let seq_res =
+                                                    parse_dot(input, state,
+                                                              pos);
+                                                match seq_res {
+                                                    Matched(pos, _) => {
+                                                        {
+                                                            let match_str =
+                                                                &input[start_pos..pos];
+                                                            Matched(pos,
+                                                                    {
+                                                                        AnyCharExpr
+                                                                    })
+                                                        }
+                                                    }
+                                                    Failed => Failed,
+                                                }
+                                            }
+                                        };
+                                    match choice_res {
+                                        Matched(pos, value) =>
+                                        Matched(pos, value),
+                                        Failed => {
+                                            let start_pos = pos;
+                                            {
+                                                let seq_res =
+                                                    parse_lparen(input, state,
+                                                                 pos);
+                                                match seq_res {
+                                                    Matched(pos, _) => {
+                                                        {
+                                                            let seq_res =
+                                                                parse_expression(input,
+                                                                                 state,
+                                                                                 pos);
+                                                            match seq_res {
+                                                                Matched(pos,
+                                                                        expression)
+                                                                => {
+                                                                    {
+                                                                        let seq_res =
+                                                                            parse_rparen(input,
+                                                                                         state,
+                                                                                         pos);
+                                                                        match seq_res
+                                                                            {
+                                                                            Matched(pos,
+                                                                                    _)
+                                                                            =>
+                                                                            {
+                                                                                {
+                                                                                    let match_str =
+                                                                                        &input[start_pos..pos];
+                                                                                    Matched(pos,
+                                                                                            {
+                                                                                                expression
+                                                                                            })
+                                                                                }
+                                                                            }
+                                                                            Failed
+                                                                            =>
+                                                                            Failed,
+                                                                        }
+                                                                    }
+                                                                }
+                                                                Failed =>
+                                                                Failed,
+                                                            }
+                                                        }
+                                                    }
+                                                    Failed => Failed,
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+fn parse_action<'input>(input: &'input str, state: &mut ParseState,
+                        pos: usize) -> RuleResult<(String, bool)> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "action"
+                 , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res = slice_eq(input, state, pos, "{");
+                    match seq_res {
+                        Matched(pos, _) => {
+                            {
+                                let seq_res =
+                                    match slice_eq(input, state, pos, "?") {
+                                        Matched(newpos, value) => {
+                                            Matched(newpos, Some(value))
+                                        }
+                                        Failed => { Matched(pos, None) }
+                                    };
+                                match seq_res {
+                                    Matched(pos, cond) => {
+                                        {
+                                            let seq_res =
+                                                {
+                                                    let mut repeat_pos = pos;
+                                                    loop  {
+                                                        let pos = repeat_pos;
+                                                        let step_res =
+                                                            {
+                                                                let choice_res =
+                                                                    {
+                                                                        let seq_res =
+                                                                            parse_braced(input,
+                                                                                         state,
+                                                                                         pos);
+                                                                        match seq_res
+                                                                            {
+                                                                            Matched(pos,
+                                                                                    _)
+                                                                            =>
+                                                                            {
+                                                                                slice_eq(input,
+                                                                                         state,
+                                                                                         pos,
+                                                                                         "")
+                                                                            }
+                                                                            Failed
+                                                                            =>
+                                                                            Failed,
+                                                                        }
+                                                                    };
+                                                                match choice_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            value)
+                                                                    =>
+                                                                    Matched(pos,
+                                                                            value),
+                                                                    Failed =>
+                                                                    parse_nonBraceCharacters(input,
+                                                                                             state,
+                                                                                             pos),
+                                                                }
+                                                            };
+                                                        match step_res {
+                                                            Matched(newpos,
+                                                                    value) =>
+                                                            {
+                                                                repeat_pos =
+                                                                    newpos;
+                                                            }
+                                                            Failed => {
+                                                                break ;
+                                                            }
+                                                        }
+                                                    }
+                                                    Matched(repeat_pos, ())
+                                                };
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    {
+                                                        let seq_res =
+                                                            slice_eq(input,
+                                                                     state,
+                                                                     pos,
+                                                                     "}");
+                                                        match seq_res {
+                                                            Matched(pos, _) =>
+                                                            {
+                                                                {
+                                                                    let seq_res =
+                                                                        parse___(input,
+                                                                                 state,
+                                                                                 pos);
+                                                                    match seq_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                _)
+                                                                        => {
+                                                                            {
+                                                                                let match_str =
+                                                                                    &input[start_pos..pos];
+                                                                                Matched(pos,
+                                                                                        {
+                                                                                            match cond
+                                                                                                {
+                                                                                                Some(_)
+                                                                                                =>
+                                                                                                {
+                                                                                                    let mut cond =
+                                                                                                        String::with_capacity(match_str.len()
+                                                                                                                                  -
+                                                                                                                                  1);
+                                                                                                    cond.push_str("{");
+                                                                                                    cond.push_str(&match_str[2..]);
+                                                                                                    (cond,
+                                                                                                     true)
+                                                                                                }
+                                                                                                None
+                                                                                                =>
+                                                                                                (match_str.to_string(),
+                                                                                                 false),
+                                                                                            }
+                                                                                        })
+                                                                            }
+                                                                        }
+                                                                        Failed
+                                                                        =>
+                                                                        Failed,
+                                                                    }
+                                                                }
+                                                            }
+                                                            Failed => Failed,
+                                                        }
+                                                    }
+                                                }
+                                                Failed => Failed,
+                                            }
+                                        }
+                                    }
+                                    Failed => Failed,
+                                }
+                            }
+                        }
+                        Failed => Failed,
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "action" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "action"
+                     , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
+            {
+                let seq_res = slice_eq(input, state, pos, "{");
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res =
+                                match slice_eq(input, state, pos, "?") {
+                                    Matched(newpos, value) => {
+                                        Matched(newpos, Some(value))
+                                    }
+                                    Failed => { Matched(pos, None) }
+                                };
+                            match seq_res {
+                                Matched(pos, cond) => {
+                                    {
+                                        let seq_res =
+                                            {
+                                                let mut repeat_pos = pos;
+                                                loop  {
+                                                    let pos = repeat_pos;
+                                                    let step_res =
+                                                        {
+                                                            let choice_res =
+                                                                {
+                                                                    let seq_res =
+                                                                        parse_braced(input,
+                                                                                     state,
+                                                                                     pos);
+                                                                    match seq_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                _)
+                                                                        => {
+                                                                            slice_eq(input,
+                                                                                     state,
+                                                                                     pos,
+                                                                                     "")
+                                                                        }
+                                                                        Failed
+                                                                        =>
+                                                                        Failed,
+                                                                    }
+                                                                };
+                                                            match choice_res {
+                                                                Matched(pos,
+                                                                        value)
+                                                                =>
+                                                                Matched(pos,
+                                                                        value),
+                                                                Failed =>
+                                                                parse_nonBraceCharacters(input,
+                                                                                         state,
+                                                                                         pos),
+                                                            }
+                                                        };
+                                                    match step_res {
+                                                        Matched(newpos, value)
+                                                        => {
+                                                            repeat_pos =
+                                                                newpos;
+                                                        }
+                                                        Failed => { break ; }
+                                                    }
+                                                }
+                                                Matched(repeat_pos, ())
+                                            };
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let seq_res =
+                                                        slice_eq(input, state,
+                                                                 pos, "}");
+                                                    match seq_res {
+                                                        Matched(pos, _) => {
+                                                            {
+                                                                let seq_res =
+                                                                    parse___(input,
+                                                                             state,
+                                                                             pos);
+                                                                match seq_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            _)
+                                                                    => {
+                                                                        {
+                                                                            let match_str =
+                                                                                &input[start_pos..pos];
+                                                                            Matched(pos,
+                                                                                    {
+                                                                                        match cond
+                                                                                            {
+                                                                                            Some(_)
+                                                                                            =>
+                                                                                            {
+                                                                                                let mut cond =
+                                                                                                    String::with_capacity(match_str.len()
+                                                                                                                              -
+                                                                                                                              1);
+                                                                                                cond.push_str("{");
+                                                                                                cond.push_str(&match_str[2..]);
+                                                                                                (cond,
+                                                                                                 true)
+                                                                                            }
+                                                                                            None
+                                                                                            =>
+                                                                                            (match_str.to_string(),
+                                                                                             false),
+                                                                                        }
+                                                                                    })
+                                                                        }
+                                                                    }
+                                                                    Failed =>
+                                                                    Failed,
+                                                                }
+                                                            }
+                                                        }
+                                                        Failed => Failed,
+                                                    }
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    }
+                    Failed => Failed,
+                }
+            }
+        }
+    }
+}
+fn parse_braced<'input>(input: &'input str, state: &mut ParseState,
+                        pos: usize) -> RuleResult<String> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "braced"
+                 , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res = slice_eq(input, state, pos, "{");
+                    match seq_res {
+                        Matched(pos, _) => {
+                            {
+                                let seq_res =
+                                    {
+                                        let mut repeat_pos = pos;
+                                        loop  {
+                                            let pos = repeat_pos;
+                                            let step_res =
+                                                {
+                                                    let choice_res =
+                                                        {
+                                                            let seq_res =
+                                                                parse_braced(input,
+                                                                             state,
+                                                                             pos);
+                                                            match seq_res {
+                                                                Matched(pos,
+                                                                        _) =>
+                                                                {
+                                                                    slice_eq(input,
+                                                                             state,
+                                                                             pos,
+                                                                             "")
+                                                                }
+                                                                Failed =>
+                                                                Failed,
+                                                            }
+                                                        };
+                                                    match choice_res {
+                                                        Matched(pos, value) =>
+                                                        Matched(pos, value),
+                                                        Failed =>
+                                                        parse_nonBraceCharacters(input,
+                                                                                 state,
+                                                                                 pos),
+                                                    }
+                                                };
+                                            match step_res {
+                                                Matched(newpos, value) => {
+                                                    repeat_pos = newpos;
+                                                }
+                                                Failed => { break ; }
+                                            }
+                                        }
+                                        Matched(repeat_pos, ())
+                                    };
+                                match seq_res {
+                                    Matched(pos, _) => {
+                                        {
+                                            let seq_res =
+                                                slice_eq(input, state, pos,
+                                                         "}");
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    {
+                                                        let match_str =
+                                                            &input[start_pos..pos];
+                                                        Matched(pos,
+                                                                {
+                                                                    match_str.to_string()
+                                                                })
+                                                    }
+                                                }
+                                                Failed => Failed,
+                                            }
+                                        }
+                                    }
+                                    Failed => Failed,
+                                }
+                            }
+                        }
+                        Failed => Failed,
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "braced" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "braced"
+                     , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
+            {
+                let seq_res = slice_eq(input, state, pos, "{");
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res =
+                                {
+                                    let mut repeat_pos = pos;
+                                    loop  {
+                                        let pos = repeat_pos;
+                                        let step_res =
+                                            {
+                                                let choice_res =
+                                                    {
+                                                        let seq_res =
+                                                            parse_braced(input,
+                                                                         state,
+                                                                         pos);
+                                                        match seq_res {
+                                                            Matched(pos, _) =>
+                                                            {
+                                                                slice_eq(input,
+                                                                         state,
+                                                                         pos,
+                                                                         "")
+                                                            }
+                                                            Failed => Failed,
+                                                        }
+                                                    };
+                                                match choice_res {
+                                                    Matched(pos, value) =>
+                                                    Matched(pos, value),
+                                                    Failed =>
+                                                    parse_nonBraceCharacters(input,
+                                                                             state,
+                                                                             pos),
+                                                }
+                                            };
+                                        match step_res {
+                                            Matched(newpos, value) => {
+                                                repeat_pos = newpos;
+                                            }
+                                            Failed => { break ; }
+                                        }
+                                    }
+                                    Matched(repeat_pos, ())
+                                };
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    {
+                                        let seq_res =
+                                            slice_eq(input, state, pos, "}");
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos,
+                                                            {
+                                                                match_str.to_string()
+                                                            })
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    }
+                    Failed => Failed,
+                }
+            }
+        }
+    }
+}
+fn parse_nonBraceCharacters<'input>(input: &'input str,
+                                    state: &mut ParseState, pos: usize)
+ -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "nonBraceCharacters" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let mut repeat_pos = pos;
+                let mut repeat_value = vec!();
+                loop  {
+                    let pos = repeat_pos;
+                    let step_res = parse_nonBraceCharacter(input, state, pos);
+                    match step_res {
+                        Matched(newpos, value) => {
+                            repeat_pos = newpos;
+                            repeat_value.push(value);
+                        }
+                        Failed => { break ; }
+                    }
+                }
+                if repeat_value.len() >= 1usize {
+                    Matched(repeat_pos, ())
+                } else { Failed }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "nonBraceCharacters" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "nonBraceCharacters" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let mut repeat_pos = pos;
+            let mut repeat_value = vec!();
+            loop  {
+                let pos = repeat_pos;
+                let step_res = parse_nonBraceCharacter(input, state, pos);
+                match step_res {
+                    Matched(newpos, value) => {
+                        repeat_pos = newpos;
+                        repeat_value.push(value);
+                    }
+                    Failed => { break ; }
+                }
+            }
+            if repeat_value.len() >= 1usize {
+                Matched(repeat_pos, ())
+            } else { Failed }
+        }
+    }
+}
+fn parse_nonBraceCharacter<'input>(input: &'input str, state: &mut ParseState,
+                                   pos: usize) -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "nonBraceCharacter" , line , col);
+        let mut __peg_closure = move || {
+            if input.len() > pos {
+                let (ch, next) = char_range_at(input, pos);
+                match ch {
+                    '{' | '}' => state.mark_failure(pos, "[^{}]"),
+                    _ => Matched(next, ()),
+                }
+            } else { state.mark_failure(pos, "[^{}]") } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "nonBraceCharacter" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "nonBraceCharacter" , line , col),
+        }
+        __peg_result
+    } else {
+        if input.len() > pos {
+            let (ch, next) = char_range_at(input, pos);
+            match ch {
+                '{' | '}' => state.mark_failure(pos, "[^{}]"),
+                _ => Matched(next, ()),
+            }
+        } else { state.mark_failure(pos, "[^{}]") }
+    }
+}
+fn parse_equals<'input>(input: &'input str, state: &mut ParseState,
+                        pos: usize) -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "equals"
+                 , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "=");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "equals" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "equals"
+                     , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "=");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_colon<'input>(input: &'input str, state: &mut ParseState, pos: usize)
+ -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "colon"
+                 , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, ":");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "colon" , line ,
+                     col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "colon"
+                     , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, ":");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_semicolon<'input>(input: &'input str, state: &mut ParseState,
+                           pos: usize) -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "semicolon" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, ";");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "semicolon" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "semicolon" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, ";");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_slash<'input>(input: &'input str, state: &mut ParseState, pos: usize)
+ -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "slash"
+                 , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "/");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "slash" , line ,
+                     col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "slash"
+                     , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "/");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_and<'input>(input: &'input str, state: &mut ParseState, pos: usize)
+ -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "and" ,
+                 line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "&");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "and" , line ,
+                     col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "and" ,
+                     line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "&");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_not<'input>(input: &'input str, state: &mut ParseState, pos: usize)
+ -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "not" ,
+                 line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "!");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "not" , line ,
+                     col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "not" ,
+                     line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "!");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_dollar<'input>(input: &'input str, state: &mut ParseState,
+                        pos: usize) -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "dollar"
+                 , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "$");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "dollar" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "dollar"
+                     , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "$");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_question<'input>(input: &'input str, state: &mut ParseState,
+                          pos: usize) -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "question" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "?");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "question" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "question" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "?");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_star<'input>(input: &'input str, state: &mut ParseState, pos: usize)
+ -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "star" ,
+                 line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "*");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "star" , line ,
+                     col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "star" ,
+                     line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "*");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_starstar<'input>(input: &'input str, state: &mut ParseState,
+                          pos: usize) -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "starstar" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "**");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "starstar" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "starstar" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "**");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_plus<'input>(input: &'input str, state: &mut ParseState, pos: usize)
+ -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "plus" ,
+                 line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "+");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "plus" , line ,
+                     col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "plus" ,
+                     line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "+");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_plusplus<'input>(input: &'input str, state: &mut ParseState,
+                          pos: usize) -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "plusplus" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "++");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "plusplus" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "plusplus" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "++");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_lparen<'input>(input: &'input str, state: &mut ParseState,
+                        pos: usize) -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "lparen"
+                 , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "(");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "lparen" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "lparen"
+                     , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "(");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_rparen<'input>(input: &'input str, state: &mut ParseState,
+                        pos: usize) -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "rparen"
+                 , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, ")");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "rparen" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "rparen"
+                     , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, ")");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_dot<'input>(input: &'input str, state: &mut ParseState, pos: usize)
+ -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "dot" ,
+                 line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, ".");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "dot" , line ,
+                     col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "dot" ,
+                     line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, ".");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_returns<'input>(input: &'input str, state: &mut ParseState,
+                         pos: usize) -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "returns" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "->");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "returns" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "returns" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "->");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_lbrace<'input>(input: &'input str, state: &mut ParseState,
+                        pos: usize) -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "lbrace"
+                 , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "{");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "lbrace" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "lbrace"
+                     , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "{");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_rbrace<'input>(input: &'input str, state: &mut ParseState,
+                        pos: usize) -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "rbrace"
+                 , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "}");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "rbrace" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "rbrace"
+                     , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "}");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_comma<'input>(input: &'input str, state: &mut ParseState, pos: usize)
+ -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "comma"
+                 , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, ",");
+                match seq_res {
+                    Matched(pos, _) => { parse___(input, state, pos) }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "comma" , line ,
+                     col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "comma"
+                     , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, ",");
+            match seq_res {
+                Matched(pos, _) => { parse___(input, state, pos) }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_integer<'input>(input: &'input str, state: &mut ParseState,
+                         pos: usize) -> RuleResult<usize> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "integer" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res =
+                        {
+                            let start_pos = pos;
+                            {
+                                let seq_res =
+                                    {
+                                        let mut repeat_pos = pos;
+                                        let mut repeat_value = vec!();
+                                        loop  {
+                                            let pos = repeat_pos;
+                                            let step_res =
+                                                if input.len() > pos {
+                                                    let (ch, next) =
+                                                        char_range_at(input,
+                                                                      pos);
+                                                    match ch {
+                                                        '0' ...'9' =>
+                                                        Matched(next, ()),
+                                                        _ =>
+                                                        state.mark_failure(pos,
+                                                                           "[0-9]"),
+                                                    }
+                                                } else {
+                                                    state.mark_failure(pos,
+                                                                       "[0-9]")
+                                                };
+                                            match step_res {
+                                                Matched(newpos, value) => {
+                                                    repeat_pos = newpos;
+                                                    repeat_value.push(value);
+                                                }
+                                                Failed => { break ; }
+                                            }
+                                        }
+                                        if repeat_value.len() >= 1usize {
+                                            Matched(repeat_pos, ())
+                                        } else { Failed }
+                                    };
+                                match seq_res {
+                                    Matched(pos, _) => {
+                                        {
+                                            let match_str =
+                                                &input[start_pos..pos];
+                                            Matched(pos,
+                                                    {
+                                                        match_str.parse().unwrap()
+                                                    })
+                                        }
+                                    }
+                                    Failed => Failed,
+                                }
+                            }
+                        };
+                    match seq_res {
+                        Matched(pos, i) => {
+                            {
+                                let seq_res = parse___(input, state, pos);
+                                match seq_res {
+                                    Matched(pos, _) => {
+                                        {
+                                            let match_str =
+                                                &input[start_pos..pos];
+                                            Matched(pos, { i })
+                                        }
+                                    }
+                                    Failed => Failed,
+                                }
+                            }
+                        }
+                        Failed => Failed,
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "integer" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "integer" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
+            {
+                let seq_res =
+                    {
+                        let start_pos = pos;
+                        {
+                            let seq_res =
+                                {
+                                    let mut repeat_pos = pos;
+                                    let mut repeat_value = vec!();
+                                    loop  {
+                                        let pos = repeat_pos;
+                                        let step_res =
+                                            if input.len() > pos {
+                                                let (ch, next) =
+                                                    char_range_at(input, pos);
+                                                match ch {
+                                                    '0' ...'9' =>
+                                                    Matched(next, ()),
+                                                    _ =>
+                                                    state.mark_failure(pos,
+                                                                       "[0-9]"),
+                                                }
+                                            } else {
+                                                state.mark_failure(pos,
+                                                                   "[0-9]")
+                                            };
+                                        match step_res {
+                                            Matched(newpos, value) => {
+                                                repeat_pos = newpos;
+                                                repeat_value.push(value);
+                                            }
+                                            Failed => { break ; }
+                                        }
+                                    }
+                                    if repeat_value.len() >= 1usize {
+                                        Matched(repeat_pos, ())
+                                    } else { Failed }
+                                };
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    {
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos,
+                                                {
+                                                    match_str.parse().unwrap()
+                                                })
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    };
+                match seq_res {
+                    Matched(pos, i) => {
+                        {
+                            let seq_res = parse___(input, state, pos);
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    {
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos, { i })
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    }
+                    Failed => Failed,
+                }
+            }
+        }
+    }
+}
+fn parse_identifier<'input>(input: &'input str, state: &mut ParseState,
+                            pos: usize) -> RuleResult<String> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "identifier" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res =
+                        {
+                            let start_pos = pos;
+                            {
+                                let seq_res =
+                                    {
+                                        let choice_res =
+                                            parse_letter(input, state, pos);
+                                        match choice_res {
+                                            Matched(pos, value) =>
+                                            Matched(pos, value),
+                                            Failed =>
+                                            slice_eq(input, state, pos, "_"),
+                                        }
+                                    };
+                                match seq_res {
+                                    Matched(pos, _) => {
+                                        {
+                                            let seq_res =
+                                                {
+                                                    let mut repeat_pos = pos;
+                                                    loop  {
+                                                        let pos = repeat_pos;
+                                                        let step_res =
+                                                            {
+                                                                let choice_res =
+                                                                    parse_letter(input,
+                                                                                 state,
+                                                                                 pos);
                                                                 match choice_res
                                                                     {
                                                                     Matched(pos,
@@ -2352,88 +6775,358 @@ fn parse_suffixed<'input>(input: &'input str, state: &mut ParseState,
                                                                     Matched(pos,
                                                                             value),
                                                                     Failed =>
-                                                                    parse_primary(input,
-                                                                                  state,
-                                                                                  pos),
+                                                                    {
+                                                                        let choice_res =
+                                                                            parse_digit(input,
+                                                                                        state,
+                                                                                        pos);
+                                                                        match choice_res
+                                                                            {
+                                                                            Matched(pos,
+                                                                                    value)
+                                                                            =>
+                                                                            Matched(pos,
+                                                                                    value),
+                                                                            Failed
+                                                                            =>
+                                                                            slice_eq(input,
+                                                                                     state,
+                                                                                     pos,
+                                                                                     "_"),
+                                                                        }
+                                                                    }
                                                                 }
+                                                            };
+                                                        match step_res {
+                                                            Matched(newpos,
+                                                                    value) =>
+                                                            {
+                                                                repeat_pos =
+                                                                    newpos;
+                                                            }
+                                                            Failed => {
+                                                                break ;
                                                             }
                                                         }
                                                     }
+                                                    Matched(repeat_pos, ())
+                                                };
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    {
+                                                        let match_str =
+                                                            &input[start_pos..pos];
+                                                        Matched(pos,
+                                                                {
+                                                                    match_str.to_string()
+                                                                })
+                                                    }
                                                 }
+                                                Failed => Failed,
                                             }
                                         }
                                     }
+                                    Failed => Failed,
+                                }
+                            }
+                        };
+                    match seq_res {
+                        Matched(pos, chars) => {
+                            {
+                                let seq_res = parse___(input, state, pos);
+                                match seq_res {
+                                    Matched(pos, _) => {
+                                        {
+                                            let match_str =
+                                                &input[start_pos..pos];
+                                            Matched(pos, { chars })
+                                        }
+                                    }
+                                    Failed => Failed,
                                 }
                             }
                         }
+                        Failed => Failed,
                     }
                 }
-            }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "identifier" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "identifier" , line , col),
         }
-    }
-}
-fn parse_primary<'input>(input: &'input str, state: &mut ParseState,
-                         pos: usize) -> RuleResult<Expr> {
-    {
-        let choice_res =
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
             {
-                let start_pos = pos;
-                {
-                    let seq_res = parse_identifier(input, state, pos);
-                    match seq_res {
-                        Matched(pos, name) => {
-                            {
-                                let seq_res =
+                let seq_res =
+                    {
+                        let start_pos = pos;
+                        {
+                            let seq_res =
+                                {
+                                    let choice_res =
+                                        parse_letter(input, state, pos);
+                                    match choice_res {
+                                        Matched(pos, value) =>
+                                        Matched(pos, value),
+                                        Failed =>
+                                        slice_eq(input, state, pos, "_"),
+                                    }
+                                };
+                            match seq_res {
+                                Matched(pos, _) => {
                                     {
-                                        let assert_res =
+                                        let seq_res =
                                             {
-                                                let seq_res =
-                                                    match parse_string(input,
-                                                                       state,
-                                                                       pos) {
-                                                        Matched(newpos, value)
-                                                        => {
-                                                            Matched(newpos,
-                                                                    Some(value))
-                                                        }
-                                                        Failed => {
-                                                            Matched(pos, None)
-                                                        }
-                                                    };
-                                                match seq_res {
-                                                    Matched(pos, _) => {
+                                                let mut repeat_pos = pos;
+                                                loop  {
+                                                    let pos = repeat_pos;
+                                                    let step_res =
                                                         {
-                                                            let seq_res =
-                                                                parse_returntype(input,
-                                                                                 state,
-                                                                                 pos);
-                                                            match seq_res {
+                                                            let choice_res =
+                                                                parse_letter(input,
+                                                                             state,
+                                                                             pos);
+                                                            match choice_res {
                                                                 Matched(pos,
-                                                                        _) =>
-                                                                {
-                                                                    parse_equals(input,
+                                                                        value)
+                                                                =>
+                                                                Matched(pos,
+                                                                        value),
+                                                                Failed => {
+                                                                    let choice_res =
+                                                                        parse_digit(input,
+                                                                                    state,
+                                                                                    pos);
+                                                                    match choice_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                value)
+                                                                        =>
+                                                                        Matched(pos,
+                                                                                value),
+                                                                        Failed
+                                                                        =>
+                                                                        slice_eq(input,
                                                                                  state,
-                                                                                 pos)
+                                                                                 pos,
+                                                                                 "_"),
+                                                                    }
                                                                 }
-                                                                Failed =>
-                                                                Failed,
                                                             }
+                                                        };
+                                                    match step_res {
+                                                        Matched(newpos, value)
+                                                        => {
+                                                            repeat_pos =
+                                                                newpos;
                                                         }
+                                                        Failed => { break ; }
                                                     }
-                                                    Failed => Failed,
                                                 }
+                                                Matched(repeat_pos, ())
                                             };
-                                        match assert_res {
-                                            Failed => Matched(pos, ()),
-                                            Matched(..) => Failed,
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos,
+                                                            {
+                                                                match_str.to_string()
+                                                            })
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    };
+                match seq_res {
+                    Matched(pos, chars) => {
+                        {
+                            let seq_res = parse___(input, state, pos);
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    {
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos, { chars })
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    }
+                    Failed => Failed,
+                }
+            }
+        }
+    }
+}
+fn parse_literal<'input>(input: &'input str, state: &mut ParseState,
+                         pos: usize) -> RuleResult<Expr> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "literal" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res =
+                        {
+                            let choice_res =
+                                parse_doubleQuotedString(input, state, pos);
+                            match choice_res {
+                                Matched(pos, value) => Matched(pos, value),
+                                Failed =>
+                                parse_singleQuotedString(input, state, pos),
+                            }
+                        };
+                    match seq_res {
+                        Matched(pos, value) => {
+                            {
+                                let seq_res =
+                                    match slice_eq(input, state, pos, "i") {
+                                        Matched(newpos, value) => {
+                                            Matched(newpos, Some(value))
                                         }
+                                        Failed => { Matched(pos, None) }
                                     };
+                                match seq_res {
+                                    Matched(pos, case_insensitive) => {
+                                        {
+                                            let seq_res =
+                                                parse___(input, state, pos);
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    {
+                                                        let match_str =
+                                                            &input[start_pos..pos];
+                                                        Matched(pos,
+                                                                {
+                                                                    LiteralExpr(value,
+                                                                                case_insensitive.is_some())
+                                                                })
+                                                    }
+                                                }
+                                                Failed => Failed,
+                                            }
+                                        }
+                                    }
+                                    Failed => Failed,
+                                }
+                            }
+                        }
+                        Failed => Failed,
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "literal" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "literal" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
+            {
+                let seq_res =
+                    {
+                        let choice_res =
+                            parse_doubleQuotedString(input, state, pos);
+                        match choice_res {
+                            Matched(pos, value) => Matched(pos, value),
+                            Failed =>
+                            parse_singleQuotedString(input, state, pos),
+                        }
+                    };
+                match seq_res {
+                    Matched(pos, value) => {
+                        {
+                            let seq_res =
+                                match slice_eq(input, state, pos, "i") {
+                                    Matched(newpos, value) => {
+                                        Matched(newpos, Some(value))
+                                    }
+                                    Failed => { Matched(pos, None) }
+                                };
+                            match seq_res {
+                                Matched(pos, case_insensitive) => {
+                                    {
+                                        let seq_res =
+                                            parse___(input, state, pos);
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos,
+                                                            {
+                                                                LiteralExpr(value,
+                                                                            case_insensitive.is_some())
+                                                            })
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    }
+                    Failed => Failed,
+                }
+            }
+        }
+    }
+}
+fn parse_string<'input>(input: &'input str, state: &mut ParseState,
+                        pos: usize) -> RuleResult<String> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "string"
+                 , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res =
+                        {
+                            let choice_res =
+                                parse_doubleQuotedString(input, state, pos);
+                            match choice_res {
+                                Matched(pos, value) => Matched(pos, value),
+                                Failed =>
+                                parse_singleQuotedString(input, state, pos),
+                            }
+                        };
+                    match seq_res {
+                        Matched(pos, string) => {
+                            {
+                                let seq_res = parse___(input, state, pos);
                                 match seq_res {
                                     Matched(pos, _) => {
                                         {
                                             let match_str =
                                                 &input[start_pos..pos];
-                                            Matched(pos, { RuleExpr(name) })
+                                            Matched(pos, { string })
                                         }
                                     }
                                     Failed => Failed,
@@ -2443,24 +7136,94 @@ fn parse_primary<'input>(input: &'input str, state: &mut ParseState,
                         Failed => Failed,
                     }
                 }
-            };
-        match choice_res {
-            Matched(pos, value) => Matched(pos, value),
-            Failed => {
-                let choice_res = parse_literal(input, state, pos);
-                match choice_res {
-                    Matched(pos, value) => Matched(pos, value),
-                    Failed => {
-                        let choice_res = parse_class(input, state, pos);
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "string" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "string"
+                     , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
+            {
+                let seq_res =
+                    {
+                        let choice_res =
+                            parse_doubleQuotedString(input, state, pos);
                         match choice_res {
                             Matched(pos, value) => Matched(pos, value),
-                            Failed => {
-                                let choice_res =
+                            Failed =>
+                            parse_singleQuotedString(input, state, pos),
+                        }
+                    };
+                match seq_res {
+                    Matched(pos, string) => {
+                        {
+                            let seq_res = parse___(input, state, pos);
+                            match seq_res {
+                                Matched(pos, _) => {
                                     {
-                                        let start_pos = pos;
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos, { string })
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    }
+                    Failed => Failed,
+                }
+            }
+        }
+    }
+}
+fn parse_doubleQuotedString<'input>(input: &'input str,
+                                    state: &mut ParseState, pos: usize)
+ -> RuleResult<String> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "doubleQuotedString" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res = slice_eq(input, state, pos, "\"");
+                    match seq_res {
+                        Matched(pos, _) => {
+                            {
+                                let seq_res =
+                                    {
+                                        let mut repeat_pos = pos;
+                                        let mut repeat_value = vec!();
+                                        loop  {
+                                            let pos = repeat_pos;
+                                            let step_res =
+                                                parse_doubleQuotedCharacter(input,
+                                                                            state,
+                                                                            pos);
+                                            match step_res {
+                                                Matched(newpos, value) => {
+                                                    repeat_pos = newpos;
+                                                    repeat_value.push(value);
+                                                }
+                                                Failed => { break ; }
+                                            }
+                                        }
+                                        Matched(repeat_pos, repeat_value)
+                                    };
+                                match seq_res {
+                                    Matched(pos, s) => {
                                         {
                                             let seq_res =
-                                                parse_dot(input, state, pos);
+                                                slice_eq(input, state, pos,
+                                                         "\"");
                                             match seq_res {
                                                 Matched(pos, _) => {
                                                     {
@@ -2468,616 +7231,556 @@ fn parse_primary<'input>(input: &'input str, state: &mut ParseState,
                                                             &input[start_pos..pos];
                                                         Matched(pos,
                                                                 {
-                                                                    AnyCharExpr
+                                                                    s.into_iter().collect()
                                                                 })
                                                     }
                                                 }
                                                 Failed => Failed,
                                             }
                                         }
-                                    };
-                                match choice_res {
-                                    Matched(pos, value) =>
-                                    Matched(pos, value),
-                                    Failed => {
-                                        let start_pos = pos;
-                                        {
-                                            let seq_res =
-                                                parse_lparen(input, state,
-                                                             pos);
-                                            match seq_res {
-                                                Matched(pos, _) => {
-                                                    {
-                                                        let seq_res =
-                                                            parse_expression(input,
-                                                                             state,
-                                                                             pos);
-                                                        match seq_res {
-                                                            Matched(pos,
-                                                                    expression)
-                                                            => {
-                                                                {
-                                                                    let seq_res =
-                                                                        parse_rparen(input,
-                                                                                     state,
-                                                                                     pos);
-                                                                    match seq_res
-                                                                        {
-                                                                        Matched(pos,
-                                                                                _)
-                                                                        => {
-                                                                            {
-                                                                                let match_str =
-                                                                                    &input[start_pos..pos];
-                                                                                Matched(pos,
-                                                                                        {
-                                                                                            expression
-                                                                                        })
-                                                                            }
-                                                                        }
-                                                                        Failed
-                                                                        =>
-                                                                        Failed,
-                                                                    }
-                                                                }
-                                                            }
-                                                            Failed => Failed,
-                                                        }
-                                                    }
+                                    }
+                                    Failed => Failed,
+                                }
+                            }
+                        }
+                        Failed => Failed,
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "doubleQuotedString" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "doubleQuotedString" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
+            {
+                let seq_res = slice_eq(input, state, pos, "\"");
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res =
+                                {
+                                    let mut repeat_pos = pos;
+                                    let mut repeat_value = vec!();
+                                    loop  {
+                                        let pos = repeat_pos;
+                                        let step_res =
+                                            parse_doubleQuotedCharacter(input,
+                                                                        state,
+                                                                        pos);
+                                        match step_res {
+                                            Matched(newpos, value) => {
+                                                repeat_pos = newpos;
+                                                repeat_value.push(value);
+                                            }
+                                            Failed => { break ; }
+                                        }
+                                    }
+                                    Matched(repeat_pos, repeat_value)
+                                };
+                            match seq_res {
+                                Matched(pos, s) => {
+                                    {
+                                        let seq_res =
+                                            slice_eq(input, state, pos, "\"");
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos,
+                                                            {
+                                                                s.into_iter().collect()
+                                                            })
                                                 }
-                                                Failed => Failed,
                                             }
+                                            Failed => Failed,
                                         }
                                     }
                                 }
+                                Failed => Failed,
                             }
                         }
                     }
+                    Failed => Failed,
                 }
             }
         }
     }
 }
-fn parse_action<'input>(input: &'input str, state: &mut ParseState,
-                        pos: usize) -> RuleResult<(String, bool)> {
-    {
-        let start_pos = pos;
-        {
-            let seq_res = slice_eq(input, state, pos, "{");
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let seq_res =
-                            match slice_eq(input, state, pos, "?") {
-                                Matched(newpos, value) => {
-                                    Matched(newpos, Some(value))
-                                }
-                                Failed => { Matched(pos, None) }
-                            };
-                        match seq_res {
-                            Matched(pos, cond) => {
-                                {
-                                    let seq_res =
-                                        {
-                                            let mut repeat_pos = pos;
-                                            loop  {
-                                                let pos = repeat_pos;
-                                                let step_res =
-                                                    {
+fn parse_doubleQuotedCharacter<'input>(input: &'input str,
+                                       state: &mut ParseState, pos: usize)
+ -> RuleResult<char> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "doubleQuotedCharacter" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let choice_res =
+                    parse_simpleDoubleQuotedCharacter(input, state, pos);
+                match choice_res {
+                    Matched(pos, value) => Matched(pos, value),
+                    Failed => {
+                        let choice_res =
+                            parse_simpleEscapeSequence(input, state, pos);
+                        match choice_res {
+                            Matched(pos, value) => Matched(pos, value),
+                            Failed => {
+                                let choice_res =
+                                    parse_zeroEscapeSequence(input, state,
+                                                             pos);
+                                match choice_res {
+                                    Matched(pos, value) =>
+                                    Matched(pos, value),
+                                    Failed => {
+                                        let choice_res =
+                                            parse_hex2EscapeSequence(input,
+                                                                     state,
+                                                                     pos);
+                                        match choice_res {
+                                            Matched(pos, value) =>
+                                            Matched(pos, value),
+                                            Failed => {
+                                                let choice_res =
+                                                    parse_unicodeEscapeSequence(input,
+                                                                                state,
+                                                                                pos);
+                                                match choice_res {
+                                                    Matched(pos, value) =>
+                                                    Matched(pos, value),
+                                                    Failed => {
                                                         let choice_res =
-                                                            {
-                                                                let seq_res =
-                                                                    parse_braced(input,
-                                                                                 state,
-                                                                                 pos);
-                                                                match seq_res
-                                                                    {
-                                                                    Matched(pos,
-                                                                            _)
-                                                                    => {
-                                                                        slice_eq(input,
-                                                                                 state,
-                                                                                 pos,
-                                                                                 "")
-                                                                    }
-                                                                    Failed =>
-                                                                    Failed,
-                                                                }
-                                                            };
+                                                            parse_hex4EscapeSequence(input,
+                                                                                     state,
+                                                                                     pos);
                                                         match choice_res {
                                                             Matched(pos,
                                                                     value) =>
                                                             Matched(pos,
                                                                     value),
-                                                            Failed =>
-                                                            parse_nonBraceCharacters(input,
-                                                                                     state,
-                                                                                     pos),
+                                                            Failed => {
+                                                                let choice_res =
+                                                                    parse_hex8EscapeSequence(input,
+                                                                                             state,
+                                                                                             pos);
+                                                                match choice_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            value)
+                                                                    =>
+                                                                    Matched(pos,
+                                                                            value),
+                                                                    Failed =>
+                                                                    parse_eolEscapeSequence(input,
+                                                                                            state,
+                                                                                            pos),
+                                                                }
+                                                            }
                                                         }
-                                                    };
-                                                match step_res {
-                                                    Matched(newpos, value) =>
-                                                    {
-                                                        repeat_pos = newpos;
                                                     }
-                                                    Failed => { break ; }
                                                 }
                                             }
-                                            Matched(repeat_pos, ())
-                                        };
-                                    match seq_res {
-                                        Matched(pos, _) => {
-                                            {
-                                                let seq_res =
-                                                    slice_eq(input, state,
-                                                             pos, "}");
-                                                match seq_res {
-                                                    Matched(pos, _) => {
-                                                        {
-                                                            let seq_res =
-                                                                parse___(input,
-                                                                         state,
-                                                                         pos);
-                                                            match seq_res {
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "doubleQuotedCharacter" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "doubleQuotedCharacter" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let choice_res =
+                parse_simpleDoubleQuotedCharacter(input, state, pos);
+            match choice_res {
+                Matched(pos, value) => Matched(pos, value),
+                Failed => {
+                    let choice_res =
+                        parse_simpleEscapeSequence(input, state, pos);
+                    match choice_res {
+                        Matched(pos, value) => Matched(pos, value),
+                        Failed => {
+                            let choice_res =
+                                parse_zeroEscapeSequence(input, state, pos);
+                            match choice_res {
+                                Matched(pos, value) => Matched(pos, value),
+                                Failed => {
+                                    let choice_res =
+                                        parse_hex2EscapeSequence(input, state,
+                                                                 pos);
+                                    match choice_res {
+                                        Matched(pos, value) =>
+                                        Matched(pos, value),
+                                        Failed => {
+                                            let choice_res =
+                                                parse_unicodeEscapeSequence(input,
+                                                                            state,
+                                                                            pos);
+                                            match choice_res {
+                                                Matched(pos, value) =>
+                                                Matched(pos, value),
+                                                Failed => {
+                                                    let choice_res =
+                                                        parse_hex4EscapeSequence(input,
+                                                                                 state,
+                                                                                 pos);
+                                                    match choice_res {
+                                                        Matched(pos, value) =>
+                                                        Matched(pos, value),
+                                                        Failed => {
+                                                            let choice_res =
+                                                                parse_hex8EscapeSequence(input,
+                                                                                         state,
+                                                                                         pos);
+                                                            match choice_res {
                                                                 Matched(pos,
-                                                                        _) =>
-                                                                {
-                                                                    {
-                                                                        let match_str =
-                                                                            &input[start_pos..pos];
-                                                                        Matched(pos,
-                                                                                {
-                                                                                    match cond
-                                                                                        {
-                                                                                        Some(_)
-                                                                                        =>
-                                                                                        {
-                                                                                            let mut cond =
-                                                                                                String::with_capacity(match_str.len()
-                                                                                                                          -
-                                                                                                                          1);
-                                                                                            cond.push_str("{");
-                                                                                            cond.push_str(&match_str[2..]);
-                                                                                            (cond,
-                                                                                             true)
-                                                                                        }
-                                                                                        None
-                                                                                        =>
-                                                                                        (match_str.to_string(),
-                                                                                         false),
-                                                                                    }
-                                                                                })
-                                                                    }
-                                                                }
+                                                                        value)
+                                                                =>
+                                                                Matched(pos,
+                                                                        value),
                                                                 Failed =>
-                                                                Failed,
+                                                                parse_eolEscapeSequence(input,
+                                                                                        state,
+                                                                                        pos),
                                                             }
                                                         }
                                                     }
-                                                    Failed => Failed,
                                                 }
                                             }
                                         }
-                                        Failed => Failed,
                                     }
                                 }
                             }
-                            Failed => Failed,
                         }
                     }
                 }
-                Failed => Failed,
             }
         }
     }
 }
-fn parse_braced<'input>(input: &'input str, state: &mut ParseState,
-                        pos: usize) -> RuleResult<String> {
-    {
-        let start_pos = pos;
-        {
-            let seq_res = slice_eq(input, state, pos, "{");
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let seq_res =
-                            {
-                                let mut repeat_pos = pos;
-                                loop  {
-                                    let pos = repeat_pos;
-                                    let step_res =
-                                        {
+fn parse_simpleDoubleQuotedCharacter<'input>(input: &'input str,
+                                             state: &mut ParseState,
+                                             pos: usize) -> RuleResult<char> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "simpleDoubleQuotedCharacter" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res =
+                        {
+                            let assert_res =
+                                {
+                                    let choice_res =
+                                        slice_eq(input, state, pos, "\"");
+                                    match choice_res {
+                                        Matched(pos, value) =>
+                                        Matched(pos, value),
+                                        Failed => {
                                             let choice_res =
-                                                {
-                                                    let seq_res =
-                                                        parse_braced(input,
-                                                                     state,
-                                                                     pos);
-                                                    match seq_res {
-                                                        Matched(pos, _) => {
-                                                            slice_eq(input,
-                                                                     state,
-                                                                     pos, "")
-                                                        }
-                                                        Failed => Failed,
-                                                    }
-                                                };
+                                                slice_eq(input, state, pos,
+                                                         "\\");
                                             match choice_res {
                                                 Matched(pos, value) =>
                                                 Matched(pos, value),
                                                 Failed =>
-                                                parse_nonBraceCharacters(input,
-                                                                         state,
-                                                                         pos),
+                                                parse_eolChar(input, state,
+                                                              pos),
                                             }
-                                        };
-                                    match step_res {
-                                        Matched(newpos, value) => {
-                                            repeat_pos = newpos;
                                         }
-                                        Failed => { break ; }
                                     }
-                                }
-                                Matched(repeat_pos, ())
-                            };
-                        match seq_res {
-                            Matched(pos, _) => {
-                                {
-                                    let seq_res =
-                                        slice_eq(input, state, pos, "}");
-                                    match seq_res {
-                                        Matched(pos, _) => {
-                                            {
-                                                let match_str =
-                                                    &input[start_pos..pos];
-                                                Matched(pos,
-                                                        {
-                                                            match_str.to_string()
-                                                        })
-                                            }
+                                };
+                            match assert_res {
+                                Failed => Matched(pos, ()),
+                                Matched(..) => Failed,
+                            }
+                        };
+                    match seq_res {
+                        Matched(pos, _) => {
+                            {
+                                let seq_res = any_char(input, state, pos);
+                                match seq_res {
+                                    Matched(pos, _) => {
+                                        {
+                                            let match_str =
+                                                &input[start_pos..pos];
+                                            Matched(pos,
+                                                    {
+                                                        match_str.chars().next().unwrap()
+                                                    })
                                         }
-                                        Failed => Failed,
                                     }
+                                    Failed => Failed,
                                 }
                             }
-                            Failed => Failed,
                         }
+                        Failed => Failed,
                     }
                 }
-                Failed => Failed,
-            }
-        }
-    }
-}
-fn parse_nonBraceCharacters<'input>(input: &'input str,
-                                    state: &mut ParseState, pos: usize)
- -> RuleResult<()> {
-    {
-        let mut repeat_pos = pos;
-        let mut repeat_value = vec!();
-        loop  {
-            let pos = repeat_pos;
-            let step_res = parse_nonBraceCharacter(input, state, pos);
-            match step_res {
-                Matched(newpos, value) => {
-                    repeat_pos = newpos;
-                    repeat_value.push(value);
-                }
-                Failed => { break ; }
-            }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "simpleDoubleQuotedCharacter" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "simpleDoubleQuotedCharacter" , line , col),
         }
-        if repeat_value.len() >= 1usize {
-            Matched(repeat_pos, ())
-        } else { Failed }
-    }
-}
-fn parse_nonBraceCharacter<'input>(input: &'input str, state: &mut ParseState,
-                                   pos: usize) -> RuleResult<()> {
-    if input.len() > pos {
-        let (ch, next) = char_range_at(input, pos);
-        match ch {
-            '{' | '}' => state.mark_failure(pos, "[^{}]"),
-            _ => Matched(next, ()),
-        }
-    } else { state.mark_failure(pos, "[^{}]") }
-}
-fn parse_equals<'input>(input: &'input str, state: &mut ParseState,
-                        pos: usize) -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "=");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_colon<'input>(input: &'input str, state: &mut ParseState, pos: usize)
- -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, ":");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_semicolon<'input>(input: &'input str, state: &mut ParseState,
-                           pos: usize) -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, ";");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_slash<'input>(input: &'input str, state: &mut ParseState, pos: usize)
- -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "/");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_and<'input>(input: &'input str, state: &mut ParseState, pos: usize)
- -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "&");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_not<'input>(input: &'input str, state: &mut ParseState, pos: usize)
- -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "!");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_dollar<'input>(input: &'input str, state: &mut ParseState,
-                        pos: usize) -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "$");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_question<'input>(input: &'input str, state: &mut ParseState,
-                          pos: usize) -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "?");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_star<'input>(input: &'input str, state: &mut ParseState, pos: usize)
- -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "*");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_starstar<'input>(input: &'input str, state: &mut ParseState,
-                          pos: usize) -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "**");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_plus<'input>(input: &'input str, state: &mut ParseState, pos: usize)
- -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "+");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_plusplus<'input>(input: &'input str, state: &mut ParseState,
-                          pos: usize) -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "++");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_lparen<'input>(input: &'input str, state: &mut ParseState,
-                        pos: usize) -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "(");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_rparen<'input>(input: &'input str, state: &mut ParseState,
-                        pos: usize) -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, ")");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_dot<'input>(input: &'input str, state: &mut ParseState, pos: usize)
- -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, ".");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_returns<'input>(input: &'input str, state: &mut ParseState,
-                         pos: usize) -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "->");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_lbrace<'input>(input: &'input str, state: &mut ParseState,
-                        pos: usize) -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "{");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_rbrace<'input>(input: &'input str, state: &mut ParseState,
-                        pos: usize) -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "}");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
-        }
-    }
-}
-fn parse_comma<'input>(input: &'input str, state: &mut ParseState, pos: usize)
- -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, ",");
-        match seq_res {
-            Matched(pos, _) => { parse___(input, state, pos) }
-            Failed => Failed,
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
+            {
+                let seq_res =
+                    {
+                        let assert_res =
+                            {
+                                let choice_res =
+                                    slice_eq(input, state, pos, "\"");
+                                match choice_res {
+                                    Matched(pos, value) =>
+                                    Matched(pos, value),
+                                    Failed => {
+                                        let choice_res =
+                                            slice_eq(input, state, pos, "\\");
+                                        match choice_res {
+                                            Matched(pos, value) =>
+                                            Matched(pos, value),
+                                            Failed =>
+                                            parse_eolChar(input, state, pos),
+                                        }
+                                    }
+                                }
+                            };
+                        match assert_res {
+                            Failed => Matched(pos, ()),
+                            Matched(..) => Failed,
+                        }
+                    };
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res = any_char(input, state, pos);
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    {
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos,
+                                                {
+                                                    match_str.chars().next().unwrap()
+                                                })
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    }
+                    Failed => Failed,
+                }
+            }
         }
     }
 }
-fn parse_integer<'input>(input: &'input str, state: &mut ParseState,
-                         pos: usize) -> RuleResult<usize> {
-    {
-        let start_pos = pos;
-        {
-            let seq_res =
+fn parse_singleQuotedString<'input>(input: &'input str,
+                                    state: &mut ParseState, pos: usize)
+ -> RuleResult<String> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "singleQuotedString" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
                 {
-                    let start_pos = pos;
-                    {
-                        let seq_res =
+                    let seq_res = slice_eq(input, state, pos, "\'");
+                    match seq_res {
+                        Matched(pos, _) => {
                             {
-                                let mut repeat_pos = pos;
-                                let mut repeat_value = vec!();
-                                loop  {
-                                    let pos = repeat_pos;
-                                    let step_res =
-                                        if input.len() > pos {
-                                            let (ch, next) =
-                                                char_range_at(input, pos);
-                                            match ch {
-                                                '0' ...'9' =>
-                                                Matched(next, ()),
-                                                _ =>
-                                                state.mark_failure(pos,
-                                                                   "[0-9]"),
+                                let seq_res =
+                                    {
+                                        let mut repeat_pos = pos;
+                                        let mut repeat_value = vec!();
+                                        loop  {
+                                            let pos = repeat_pos;
+                                            let step_res =
+                                                parse_singleQuotedCharacter(input,
+                                                                            state,
+                                                                            pos);
+                                            match step_res {
+                                                Matched(newpos, value) => {
+                                                    repeat_pos = newpos;
+                                                    repeat_value.push(value);
+                                                }
+                                                Failed => { break ; }
+                                            }
+                                        }
+                                        Matched(repeat_pos, repeat_value)
+                                    };
+                                match seq_res {
+                                    Matched(pos, s) => {
+                                        {
+                                            let seq_res =
+                                                slice_eq(input, state, pos,
+                                                         "\'");
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    {
+                                                        let match_str =
+                                                            &input[start_pos..pos];
+                                                        Matched(pos,
+                                                                {
+                                                                    s.into_iter().collect()
+                                                                })
+                                                    }
+                                                }
+                                                Failed => Failed,
                                             }
-                                        } else {
-                                            state.mark_failure(pos, "[0-9]")
-                                        };
-                                    match step_res {
-                                        Matched(newpos, value) => {
-                                            repeat_pos = newpos;
-                                            repeat_value.push(value);
                                         }
-                                        Failed => { break ; }
                                     }
-                                }
-                                if repeat_value.len() >= 1usize {
-                                    Matched(repeat_pos, ())
-                                } else { Failed }
-                            };
-                        match seq_res {
-                            Matched(pos, _) => {
-                                {
-                                    let match_str = &input[start_pos..pos];
-                                    Matched(pos,
-                                            { match_str.parse().unwrap() })
+                                    Failed => Failed,
                                 }
                             }
-                            Failed => Failed,
                         }
+                        Failed => Failed,
                     }
-                };
-            match seq_res {
-                Matched(pos, i) => {
-                    {
-                        let seq_res = parse___(input, state, pos);
-                        match seq_res {
-                            Matched(pos, _) => {
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "singleQuotedString" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "singleQuotedString" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
+            {
+                let seq_res = slice_eq(input, state, pos, "\'");
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res =
                                 {
-                                    let match_str = &input[start_pos..pos];
-                                    Matched(pos, { i })
+                                    let mut repeat_pos = pos;
+                                    let mut repeat_value = vec!();
+                                    loop  {
+                                        let pos = repeat_pos;
+                                        let step_res =
+                                            parse_singleQuotedCharacter(input,
+                                                                        state,
+                                                                        pos);
+                                        match step_res {
+                                            Matched(newpos, value) => {
+                                                repeat_pos = newpos;
+                                                repeat_value.push(value);
+                                            }
+                                            Failed => { break ; }
+                                        }
+                                    }
+                                    Matched(repeat_pos, repeat_value)
+                                };
+                            match seq_res {
+                                Matched(pos, s) => {
+                                    {
+                                        let seq_res =
+                                            slice_eq(input, state, pos, "\'");
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos,
+                                                            {
+                                                                s.into_iter().collect()
+                                                            })
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
                                 }
+                                Failed => Failed,
                             }
-                            Failed => Failed,
                         }
                     }
+                    Failed => Failed,
                 }
-                Failed => Failed,
             }
         }
     }
 }
-fn parse_identifier<'input>(input: &'input str, state: &mut ParseState,
-                            pos: usize) -> RuleResult<String> {
-    {
-        let start_pos = pos;
-        {
-            let seq_res =
-                {
-                    let start_pos = pos;
-                    {
-                        let seq_res =
-                            {
+fn parse_singleQuotedCharacter<'input>(input: &'input str,
+                                       state: &mut ParseState, pos: usize)
+ -> RuleResult<char> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "singleQuotedCharacter" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let choice_res =
+                    parse_simpleSingleQuotedCharacter(input, state, pos);
+                match choice_res {
+                    Matched(pos, value) => Matched(pos, value),
+                    Failed => {
+                        let choice_res =
+                            parse_simpleEscapeSequence(input, state, pos);
+                        match choice_res {
+                            Matched(pos, value) => Matched(pos, value),
+                            Failed => {
                                 let choice_res =
-                                    parse_letter(input, state, pos);
+                                    parse_zeroEscapeSequence(input, state,
+                                                             pos);
                                 match choice_res {
                                     Matched(pos, value) =>
                                     Matched(pos, value),
-                                    Failed =>
-                                    slice_eq(input, state, pos, "_"),
-                                }
-                            };
-                        match seq_res {
-                            Matched(pos, _) => {
-                                {
-                                    let seq_res =
-                                        {
-                                            let mut repeat_pos = pos;
-                                            loop  {
-                                                let pos = repeat_pos;
-                                                let step_res =
-                                                    {
+                                    Failed => {
+                                        let choice_res =
+                                            parse_hex2EscapeSequence(input,
+                                                                     state,
+                                                                     pos);
+                                        match choice_res {
+                                            Matched(pos, value) =>
+                                            Matched(pos, value),
+                                            Failed => {
+                                                let choice_res =
+                                                    parse_unicodeEscapeSequence(input,
+                                                                                state,
+                                                                                pos);
+                                                match choice_res {
+                                                    Matched(pos, value) =>
+                                                    Matched(pos, value),
+                                                    Failed => {
                                                         let choice_res =
-                                                            parse_letter(input,
-                                                                         state,
-                                                                         pos);
+                                                            parse_hex4EscapeSequence(input,
+                                                                                     state,
+                                                                                     pos);
                                                         match choice_res {
                                                             Matched(pos,
                                                                     value) =>
@@ -3085,9 +7788,9 @@ fn parse_identifier<'input>(input: &'input str, state: &mut ParseState,
                                                                     value),
                                                             Failed => {
                                                                 let choice_res =
-                                                                    parse_digit(input,
-                                                                                state,
-                                                                                pos);
+                                                                    parse_hex8EscapeSequence(input,
+                                                                                             state,
+                                                                                             pos);
                                                                 match choice_res
                                                                     {
                                                                     Matched(pos,
@@ -3096,434 +7799,738 @@ fn parse_identifier<'input>(input: &'input str, state: &mut ParseState,
                                                                     Matched(pos,
                                                                             value),
                                                                     Failed =>
-                                                                    slice_eq(input,
-                                                                             state,
-                                                                             pos,
-                                                                             "_"),
+                                                                    parse_eolEscapeSequence(input,
+                                                                                            state,
+                                                                                            pos),
                                                                 }
                                                             }
                                                         }
-                                                    };
-                                                match step_res {
-                                                    Matched(newpos, value) =>
-                                                    {
-                                                        repeat_pos = newpos;
                                                     }
-                                                    Failed => { break ; }
                                                 }
                                             }
-                                            Matched(repeat_pos, ())
-                                        };
-                                    match seq_res {
-                                        Matched(pos, _) => {
-                                            {
-                                                let match_str =
-                                                    &input[start_pos..pos];
-                                                Matched(pos,
-                                                        {
-                                                            match_str.to_string()
-                                                        })
-                                            }
                                         }
-                                        Failed => Failed,
                                     }
                                 }
                             }
-                            Failed => Failed,
                         }
                     }
-                };
-            match seq_res {
-                Matched(pos, chars) => {
-                    {
-                        let seq_res = parse___(input, state, pos);
-                        match seq_res {
-                            Matched(pos, _) => {
-                                {
-                                    let match_str = &input[start_pos..pos];
-                                    Matched(pos, { chars })
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "singleQuotedCharacter" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "singleQuotedCharacter" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let choice_res =
+                parse_simpleSingleQuotedCharacter(input, state, pos);
+            match choice_res {
+                Matched(pos, value) => Matched(pos, value),
+                Failed => {
+                    let choice_res =
+                        parse_simpleEscapeSequence(input, state, pos);
+                    match choice_res {
+                        Matched(pos, value) => Matched(pos, value),
+                        Failed => {
+                            let choice_res =
+                                parse_zeroEscapeSequence(input, state, pos);
+                            match choice_res {
+                                Matched(pos, value) => Matched(pos, value),
+                                Failed => {
+                                    let choice_res =
+                                        parse_hex2EscapeSequence(input, state,
+                                                                 pos);
+                                    match choice_res {
+                                        Matched(pos, value) =>
+                                        Matched(pos, value),
+                                        Failed => {
+                                            let choice_res =
+                                                parse_unicodeEscapeSequence(input,
+                                                                            state,
+                                                                            pos);
+                                            match choice_res {
+                                                Matched(pos, value) =>
+                                                Matched(pos, value),
+                                                Failed => {
+                                                    let choice_res =
+                                                        parse_hex4EscapeSequence(input,
+                                                                                 state,
+                                                                                 pos);
+                                                    match choice_res {
+                                                        Matched(pos, value) =>
+                                                        Matched(pos, value),
+                                                        Failed => {
+                                                            let choice_res =
+                                                                parse_hex8EscapeSequence(input,
+                                                                                         state,
+                                                                                         pos);
+                                                            match choice_res {
+                                                                Matched(pos,
+                                                                        value)
+                                                                =>
+                                                                Matched(pos,
+                                                                        value),
+                                                                Failed =>
+                                                                parse_eolEscapeSequence(input,
+                                                                                        state,
+                                                                                        pos),
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
                                 }
                             }
-                            Failed => Failed,
                         }
                     }
                 }
-                Failed => Failed,
             }
         }
     }
 }
-fn parse_literal<'input>(input: &'input str, state: &mut ParseState,
-                         pos: usize) -> RuleResult<Expr> {
-    {
-        let start_pos = pos;
-        {
-            let seq_res =
+fn parse_simpleSingleQuotedCharacter<'input>(input: &'input str,
+                                             state: &mut ParseState,
+                                             pos: usize) -> RuleResult<char> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "simpleSingleQuotedCharacter" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
                 {
-                    let choice_res =
-                        parse_doubleQuotedString(input, state, pos);
-                    match choice_res {
-                        Matched(pos, value) => Matched(pos, value),
-                        Failed => parse_singleQuotedString(input, state, pos),
-                    }
-                };
-            match seq_res {
-                Matched(pos, value) => {
-                    {
-                        let seq_res =
-                            match slice_eq(input, state, pos, "i") {
-                                Matched(newpos, value) => {
-                                    Matched(newpos, Some(value))
-                                }
-                                Failed => { Matched(pos, None) }
-                            };
-                        match seq_res {
-                            Matched(pos, case_insensitive) => {
+                    let seq_res =
+                        {
+                            let assert_res =
                                 {
-                                    let seq_res = parse___(input, state, pos);
-                                    match seq_res {
-                                        Matched(pos, _) => {
-                                            {
-                                                let match_str =
-                                                    &input[start_pos..pos];
-                                                Matched(pos,
-                                                        {
-                                                            LiteralExpr(value,
-                                                                        case_insensitive.is_some())
-                                                        })
+                                    let choice_res =
+                                        slice_eq(input, state, pos, "\'");
+                                    match choice_res {
+                                        Matched(pos, value) =>
+                                        Matched(pos, value),
+                                        Failed => {
+                                            let choice_res =
+                                                slice_eq(input, state, pos,
+                                                         "\\");
+                                            match choice_res {
+                                                Matched(pos, value) =>
+                                                Matched(pos, value),
+                                                Failed =>
+                                                parse_eolChar(input, state,
+                                                              pos),
                                             }
                                         }
-                                        Failed => Failed,
                                     }
+                                };
+                            match assert_res {
+                                Failed => Matched(pos, ()),
+                                Matched(..) => Failed,
+                            }
+                        };
+                    match seq_res {
+                        Matched(pos, _) => {
+                            {
+                                let seq_res = any_char(input, state, pos);
+                                match seq_res {
+                                    Matched(pos, _) => {
+                                        {
+                                            let match_str =
+                                                &input[start_pos..pos];
+                                            Matched(pos,
+                                                    {
+                                                        match_str.chars().next().unwrap()
+                                                    })
+                                        }
+                                    }
+                                    Failed => Failed,
                                 }
                             }
-                            Failed => Failed,
                         }
+                        Failed => Failed,
                     }
                 }
-                Failed => Failed,
-            }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "simpleSingleQuotedCharacter" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "simpleSingleQuotedCharacter" , line , col),
         }
-    }
-}
-fn parse_string<'input>(input: &'input str, state: &mut ParseState,
-                        pos: usize) -> RuleResult<String> {
-    {
-        let start_pos = pos;
+        __peg_result
+    } else {
         {
-            let seq_res =
-                {
-                    let choice_res =
-                        parse_doubleQuotedString(input, state, pos);
-                    match choice_res {
-                        Matched(pos, value) => Matched(pos, value),
-                        Failed => parse_singleQuotedString(input, state, pos),
-                    }
-                };
-            match seq_res {
-                Matched(pos, string) => {
+            let start_pos = pos;
+            {
+                let seq_res =
                     {
-                        let seq_res = parse___(input, state, pos);
-                        match seq_res {
-                            Matched(pos, _) => {
-                                {
-                                    let match_str = &input[start_pos..pos];
-                                    Matched(pos, { string })
+                        let assert_res =
+                            {
+                                let choice_res =
+                                    slice_eq(input, state, pos, "\'");
+                                match choice_res {
+                                    Matched(pos, value) =>
+                                    Matched(pos, value),
+                                    Failed => {
+                                        let choice_res =
+                                            slice_eq(input, state, pos, "\\");
+                                        match choice_res {
+                                            Matched(pos, value) =>
+                                            Matched(pos, value),
+                                            Failed =>
+                                            parse_eolChar(input, state, pos),
+                                        }
+                                    }
+                                }
+                            };
+                        match assert_res {
+                            Failed => Matched(pos, ()),
+                            Matched(..) => Failed,
+                        }
+                    };
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res = any_char(input, state, pos);
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    {
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos,
+                                                {
+                                                    match_str.chars().next().unwrap()
+                                                })
+                                    }
                                 }
+                                Failed => Failed,
                             }
-                            Failed => Failed,
                         }
                     }
+                    Failed => Failed,
                 }
-                Failed => Failed,
             }
         }
     }
 }
-fn parse_doubleQuotedString<'input>(input: &'input str,
-                                    state: &mut ParseState, pos: usize)
- -> RuleResult<String> {
-    {
-        let start_pos = pos;
-        {
-            let seq_res = slice_eq(input, state, pos, "\"");
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let seq_res =
+fn parse_class<'input>(input: &'input str, state: &mut ParseState, pos: usize)
+ -> RuleResult<Expr> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "class"
+                 , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res = slice_eq(input, state, pos, "[");
+                    match seq_res {
+                        Matched(pos, _) => {
                             {
-                                let mut repeat_pos = pos;
-                                let mut repeat_value = vec!();
-                                loop  {
-                                    let pos = repeat_pos;
-                                    let step_res =
-                                        parse_doubleQuotedCharacter(input,
-                                                                    state,
-                                                                    pos);
-                                    match step_res {
+                                let seq_res =
+                                    match slice_eq(input, state, pos, "^") {
                                         Matched(newpos, value) => {
-                                            repeat_pos = newpos;
-                                            repeat_value.push(value);
+                                            Matched(newpos, Some(value))
+                                        }
+                                        Failed => { Matched(pos, None) }
+                                    };
+                                match seq_res {
+                                    Matched(pos, inverted) => {
+                                        {
+                                            let seq_res =
+                                                {
+                                                    let mut repeat_pos = pos;
+                                                    let mut repeat_value =
+                                                        vec!();
+                                                    loop  {
+                                                        let pos = repeat_pos;
+                                                        let step_res =
+                                                            {
+                                                                let choice_res =
+                                                                    parse_classCharacterRange(input,
+                                                                                              state,
+                                                                                              pos);
+                                                                match choice_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            value)
+                                                                    =>
+                                                                    Matched(pos,
+                                                                            value),
+                                                                    Failed =>
+                                                                    parse_classCharacter(input,
+                                                                                         state,
+                                                                                         pos),
+                                                                }
+                                                            };
+                                                        match step_res {
+                                                            Matched(newpos,
+                                                                    value) =>
+                                                            {
+                                                                repeat_pos =
+                                                                    newpos;
+                                                                repeat_value.push(value);
+                                                            }
+                                                            Failed => {
+                                                                break ;
+                                                            }
+                                                        }
+                                                    }
+                                                    Matched(repeat_pos,
+                                                            repeat_value)
+                                                };
+                                            match seq_res {
+                                                Matched(pos, parts) => {
+                                                    {
+                                                        let seq_res =
+                                                            slice_eq(input,
+                                                                     state,
+                                                                     pos,
+                                                                     "]");
+                                                        match seq_res {
+                                                            Matched(pos, _) =>
+                                                            {
+                                                                {
+                                                                    let seq_res =
+                                                                        match slice_eq(input,
+                                                                                       state,
+                                                                                       pos,
+                                                                                       "i")
+                                                                            {
+                                                                            Matched(newpos,
+                                                                                    value)
+                                                                            =>
+                                                                            {
+                                                                                Matched(newpos,
+                                                                                        Some(value))
+                                                                            }
+                                                                            Failed
+                                                                            =>
+                                                                            {
+                                                                                Matched(pos,
+                                                                                        None)
+                                                                            }
+                                                                        };
+                                                                    match seq_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                flags)
+                                                                        => {
+                                                                            {
+                                                                                let seq_res =
+                                                                                    parse___(input,
+                                                                                             state,
+                                                                                             pos);
+                                                                                match seq_res
+                                                                                    {
+                                                                                    Matched(pos,
+                                                                                            _)
+                                                                                    =>
+                                                                                    {
+                                                                                        {
+                                                                                            let match_str =
+                                                                                                &input[start_pos..pos];
+                                                                                            Matched(pos,
+                                                                                                    {
+                                                                                                        CharSetExpr(inverted.is_some(),
+                                                                                                                    parts)
+                                                                                                    })
+                                                                                        }
+                                                                                    }
+                                                                                    Failed
+                                                                                    =>
+                                                                                    Failed,
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                        Failed
+                                                                        =>
+                                                                        Failed,
+                                                                    }
+                                                                }
+                                                            }
+                                                            Failed => Failed,
+                                                        }
+                                                    }
+                                                }
+                                                Failed => Failed,
+                                            }
                                         }
-                                        Failed => { break ; }
                                     }
+                                    Failed => Failed,
                                 }
-                                Matched(repeat_pos, repeat_value)
-                            };
-                        match seq_res {
-                            Matched(pos, s) => {
-                                {
-                                    let seq_res =
-                                        slice_eq(input, state, pos, "\"");
-                                    match seq_res {
-                                        Matched(pos, _) => {
+                            }
+                        }
+                        Failed => Failed,
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "class" , line ,
+                     col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "class"
+                     , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
+            {
+                let seq_res = slice_eq(input, state, pos, "[");
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res =
+                                match slice_eq(input, state, pos, "^") {
+                                    Matched(newpos, value) => {
+                                        Matched(newpos, Some(value))
+                                    }
+                                    Failed => { Matched(pos, None) }
+                                };
+                            match seq_res {
+                                Matched(pos, inverted) => {
+                                    {
+                                        let seq_res =
                                             {
-                                                let match_str =
-                                                    &input[start_pos..pos];
-                                                Matched(pos,
+                                                let mut repeat_pos = pos;
+                                                let mut repeat_value = vec!();
+                                                loop  {
+                                                    let pos = repeat_pos;
+                                                    let step_res =
                                                         {
-                                                            s.into_iter().collect()
-                                                        })
+                                                            let choice_res =
+                                                                parse_classCharacterRange(input,
+                                                                                          state,
+                                                                                          pos);
+                                                            match choice_res {
+                                                                Matched(pos,
+                                                                        value)
+                                                                =>
+                                                                Matched(pos,
+                                                                        value),
+                                                                Failed =>
+                                                                parse_classCharacter(input,
+                                                                                     state,
+                                                                                     pos),
+                                                            }
+                                                        };
+                                                    match step_res {
+                                                        Matched(newpos, value)
+                                                        => {
+                                                            repeat_pos =
+                                                                newpos;
+                                                            repeat_value.push(value);
+                                                        }
+                                                        Failed => { break ; }
+                                                    }
+                                                }
+                                                Matched(repeat_pos,
+                                                        repeat_value)
+                                            };
+                                        match seq_res {
+                                            Matched(pos, parts) => {
+                                                {
+                                                    let seq_res =
+                                                        slice_eq(input, state,
+                                                                 pos, "]");
+                                                    match seq_res {
+                                                        Matched(pos, _) => {
+                                                            {
+                                                                let seq_res =
+                                                                    match slice_eq(input,
+                                                                                   state,
+                                                                                   pos,
+                                                                                   "i")
+                                                                        {
+                                                                        Matched(newpos,
+                                                                                value)
+                                                                        => {
+                                                                            Matched(newpos,
+                                                                                    Some(value))
+                                                                        }
+                                                                        Failed
+                                                                        => {
+                                                                            Matched(pos,
+                                                                                    None)
+                                                                        }
+                                                                    };
+                                                                match seq_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            flags)
+                                                                    => {
+                                                                        {
+                                                                            let seq_res =
+                                                                                parse___(input,
+                                                                                         state,
+                                                                                         pos);
+                                                                            match seq_res
+                                                                                {
+                                                                                Matched(pos,
+                                                                                        _)
+                                                                                =>
+                                                                                {
+                                                                                    {
+                                                                                        let match_str =
+                                                                                            &input[start_pos..pos];
+                                                                                        Matched(pos,
+                                                                                                {
+                                                                                                    CharSetExpr(inverted.is_some(),
+                                                                                                                parts)
+                                                                                                })
+                                                                                    }
+                                                                                }
+                                                                                Failed
+                                                                                =>
+                                                                                Failed,
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                    Failed =>
+                                                                    Failed,
+                                                                }
+                                                            }
+                                                        }
+                                                        Failed => Failed,
+                                                    }
+                                                }
                                             }
+                                            Failed => Failed,
                                         }
-                                        Failed => Failed,
                                     }
                                 }
+                                Failed => Failed,
                             }
-                            Failed => Failed,
                         }
                     }
+                    Failed => Failed,
                 }
-                Failed => Failed,
             }
         }
     }
 }
-fn parse_doubleQuotedCharacter<'input>(input: &'input str,
-                                       state: &mut ParseState, pos: usize)
- -> RuleResult<char> {
-    {
-        let choice_res = parse_simpleDoubleQuotedCharacter(input, state, pos);
-        match choice_res {
-            Matched(pos, value) => Matched(pos, value),
-            Failed => {
-                let choice_res =
-                    parse_simpleEscapeSequence(input, state, pos);
-                match choice_res {
-                    Matched(pos, value) => Matched(pos, value),
-                    Failed => {
-                        let choice_res =
-                            parse_zeroEscapeSequence(input, state, pos);
-                        match choice_res {
-                            Matched(pos, value) => Matched(pos, value),
-                            Failed => {
-                                let choice_res =
-                                    parse_hex2EscapeSequence(input, state,
-                                                             pos);
-                                match choice_res {
-                                    Matched(pos, value) =>
-                                    Matched(pos, value),
-                                    Failed => {
-                                        let choice_res =
-                                            parse_unicodeEscapeSequence(input,
-                                                                        state,
-                                                                        pos);
-                                        match choice_res {
-                                            Matched(pos, value) =>
-                                            Matched(pos, value),
-                                            Failed => {
-                                                let choice_res =
-                                                    parse_hex4EscapeSequence(input,
-                                                                             state,
-                                                                             pos);
-                                                match choice_res {
-                                                    Matched(pos, value) =>
-                                                    Matched(pos, value),
-                                                    Failed => {
-                                                        let choice_res =
-                                                            parse_hex8EscapeSequence(input,
-                                                                                     state,
-                                                                                     pos);
-                                                        match choice_res {
-                                                            Matched(pos,
-                                                                    value) =>
-                                                            Matched(pos,
-                                                                    value),
-                                                            Failed =>
-                                                            parse_eolEscapeSequence(input,
-                                                                                    state,
-                                                                                    pos),
-                                                        }
+fn parse_classCharacterRange<'input>(input: &'input str,
+                                     state: &mut ParseState, pos: usize)
+ -> RuleResult<CharSetCase> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "classCharacterRange" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res =
+                        parse_bracketDelimitedCharacter(input, state, pos);
+                    match seq_res {
+                        Matched(pos, begin) => {
+                            {
+                                let seq_res =
+                                    slice_eq(input, state, pos, "-");
+                                match seq_res {
+                                    Matched(pos, _) => {
+                                        {
+                                            let seq_res =
+                                                parse_bracketDelimitedCharacter(input,
+                                                                                state,
+                                                                                pos);
+                                            match seq_res {
+                                                Matched(pos, end) => {
+                                                    {
+                                                        let match_str =
+                                                            &input[start_pos..pos];
+                                                        Matched(pos,
+                                                                {
+                                                                    CharSetCase{start:
+                                                                                    begin,
+                                                                                end:
+                                                                                    end,}
+                                                                })
                                                     }
                                                 }
+                                                Failed => Failed,
                                             }
                                         }
                                     }
+                                    Failed => Failed,
                                 }
                             }
                         }
+                        Failed => Failed,
                     }
                 }
-            }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "classCharacterRange" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "classCharacterRange" , line , col),
         }
-    }
-}
-fn parse_simpleDoubleQuotedCharacter<'input>(input: &'input str,
-                                             state: &mut ParseState,
-                                             pos: usize) -> RuleResult<char> {
-    {
-        let start_pos = pos;
+        __peg_result
+    } else {
         {
-            let seq_res =
-                {
-                    let assert_res =
+            let start_pos = pos;
+            {
+                let seq_res =
+                    parse_bracketDelimitedCharacter(input, state, pos);
+                match seq_res {
+                    Matched(pos, begin) => {
                         {
-                            let choice_res =
-                                slice_eq(input, state, pos, "\"");
-                            match choice_res {
-                                Matched(pos, value) => Matched(pos, value),
-                                Failed => {
-                                    let choice_res =
-                                        slice_eq(input, state, pos, "\\");
-                                    match choice_res {
-                                        Matched(pos, value) =>
-                                        Matched(pos, value),
-                                        Failed =>
-                                        parse_eolChar(input, state, pos),
+                            let seq_res = slice_eq(input, state, pos, "-");
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    {
+                                        let seq_res =
+                                            parse_bracketDelimitedCharacter(input,
+                                                                            state,
+                                                                            pos);
+                                        match seq_res {
+                                            Matched(pos, end) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos,
+                                                            {
+                                                                CharSetCase{start:
+                                                                                begin,
+                                                                            end:
+                                                                                end,}
+                                                            })
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
                                     }
                                 }
+                                Failed => Failed,
                             }
-                        };
-                    match assert_res {
-                        Failed => Matched(pos, ()),
-                        Matched(..) => Failed,
-                    }
-                };
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let seq_res = any_char(input, state, pos);
-                        match seq_res {
-                            Matched(pos, _) => {
-                                {
-                                    let match_str = &input[start_pos..pos];
-                                    Matched(pos,
-                                            {
-                                                match_str.chars().next().unwrap()
-                                            })
-                                }
-                            }
-                            Failed => Failed,
                         }
                     }
+                    Failed => Failed,
                 }
-                Failed => Failed,
             }
         }
     }
 }
-fn parse_singleQuotedString<'input>(input: &'input str,
-                                    state: &mut ParseState, pos: usize)
- -> RuleResult<String> {
-    {
-        let start_pos = pos;
-        {
-            let seq_res = slice_eq(input, state, pos, "\'");
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let seq_res =
+fn parse_classCharacter<'input>(input: &'input str, state: &mut ParseState,
+                                pos: usize) -> RuleResult<CharSetCase> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "classCharacter" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res =
+                        parse_bracketDelimitedCharacter(input, state, pos);
+                    match seq_res {
+                        Matched(pos, char_) => {
                             {
-                                let mut repeat_pos = pos;
-                                let mut repeat_value = vec!();
-                                loop  {
-                                    let pos = repeat_pos;
-                                    let step_res =
-                                        parse_singleQuotedCharacter(input,
-                                                                    state,
-                                                                    pos);
-                                    match step_res {
-                                        Matched(newpos, value) => {
-                                            repeat_pos = newpos;
-                                            repeat_value.push(value);
-                                        }
-                                        Failed => { break ; }
-                                    }
-                                }
-                                Matched(repeat_pos, repeat_value)
-                            };
-                        match seq_res {
-                            Matched(pos, s) => {
-                                {
-                                    let seq_res =
-                                        slice_eq(input, state, pos, "\'");
-                                    match seq_res {
-                                        Matched(pos, _) => {
-                                            {
-                                                let match_str =
-                                                    &input[start_pos..pos];
-                                                Matched(pos,
-                                                        {
-                                                            s.into_iter().collect()
-                                                        })
-                                            }
-                                        }
-                                        Failed => Failed,
-                                    }
-                                }
+                                let match_str = &input[start_pos..pos];
+                                Matched(pos,
+                                        {
+                                            CharSetCase{start: char_,
+                                                        end: char_,}
+                                        })
                             }
-                            Failed => Failed,
                         }
+                        Failed => Failed,
                     }
                 }
-                Failed => Failed,
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "classCharacter"
+                     , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "classCharacter" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
+            {
+                let seq_res =
+                    parse_bracketDelimitedCharacter(input, state, pos);
+                match seq_res {
+                    Matched(pos, char_) => {
+                        {
+                            let match_str = &input[start_pos..pos];
+                            Matched(pos,
+                                    {
+                                        CharSetCase{start: char_, end: char_,}
+                                    })
+                        }
+                    }
+                    Failed => Failed,
+                }
             }
         }
     }
 }
-fn parse_singleQuotedCharacter<'input>(input: &'input str,
-                                       state: &mut ParseState, pos: usize)
+fn parse_bracketDelimitedCharacter<'input>(input: &'input str,
+                                           state: &mut ParseState, pos: usize)
  -> RuleResult<char> {
-    {
-        let choice_res = parse_simpleSingleQuotedCharacter(input, state, pos);
-        match choice_res {
-            Matched(pos, value) => Matched(pos, value),
-            Failed => {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "bracketDelimitedCharacter" , line , col);
+        let mut __peg_closure = move || {
+            {
                 let choice_res =
-                    parse_simpleEscapeSequence(input, state, pos);
+                    parse_simpleBracketDelimitedCharacter(input, state, pos);
                 match choice_res {
                     Matched(pos, value) => Matched(pos, value),
                     Failed => {
                         let choice_res =
-                            parse_zeroEscapeSequence(input, state, pos);
+                            parse_simpleEscapeSequence(input, state, pos);
                         match choice_res {
                             Matched(pos, value) => Matched(pos, value),
                             Failed => {
                                 let choice_res =
-                                    parse_hex2EscapeSequence(input, state,
+                                    parse_zeroEscapeSequence(input, state,
                                                              pos);
                                 match choice_res {
                                     Matched(pos, value) =>
                                     Matched(pos, value),
                                     Failed => {
                                         let choice_res =
-                                            parse_unicodeEscapeSequence(input,
-                                                                        state,
-                                                                        pos);
+                                            parse_hex2EscapeSequence(input,
+                                                                     state,
+                                                                     pos);
                                         match choice_res {
                                             Matched(pos, value) =>
                                             Matched(pos, value),
                                             Failed => {
                                                 let choice_res =
-                                                    parse_hex4EscapeSequence(input,
-                                                                             state,
-                                                                             pos);
+                                                    parse_unicodeEscapeSequence(input,
+                                                                                state,
+                                                                                pos);
                                                 match choice_res {
                                                     Matched(pos, value) =>
                                                     Matched(pos, value),
                                                     Failed => {
                                                         let choice_res =
-                                                            parse_hex8EscapeSequence(input,
+                                                            parse_hex4EscapeSequence(input,
                                                                                      state,
                                                                                      pos);
                                                         match choice_res {
@@ -3531,10 +8538,101 @@ fn parse_singleQuotedCharacter<'input>(input: &'input str,
                                                                     value) =>
                                                             Matched(pos,
                                                                     value),
-                                                            Failed =>
-                                                            parse_eolEscapeSequence(input,
-                                                                                    state,
-                                                                                    pos),
+                                                            Failed => {
+                                                                let choice_res =
+                                                                    parse_hex8EscapeSequence(input,
+                                                                                             state,
+                                                                                             pos);
+                                                                match choice_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            value)
+                                                                    =>
+                                                                    Matched(pos,
+                                                                            value),
+                                                                    Failed =>
+                                                                    parse_eolEscapeSequence(input,
+                                                                                            state,
+                                                                                            pos),
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "bracketDelimitedCharacter" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "bracketDelimitedCharacter" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let choice_res =
+                parse_simpleBracketDelimitedCharacter(input, state, pos);
+            match choice_res {
+                Matched(pos, value) => Matched(pos, value),
+                Failed => {
+                    let choice_res =
+                        parse_simpleEscapeSequence(input, state, pos);
+                    match choice_res {
+                        Matched(pos, value) => Matched(pos, value),
+                        Failed => {
+                            let choice_res =
+                                parse_zeroEscapeSequence(input, state, pos);
+                            match choice_res {
+                                Matched(pos, value) => Matched(pos, value),
+                                Failed => {
+                                    let choice_res =
+                                        parse_hex2EscapeSequence(input, state,
+                                                                 pos);
+                                    match choice_res {
+                                        Matched(pos, value) =>
+                                        Matched(pos, value),
+                                        Failed => {
+                                            let choice_res =
+                                                parse_unicodeEscapeSequence(input,
+                                                                            state,
+                                                                            pos);
+                                            match choice_res {
+                                                Matched(pos, value) =>
+                                                Matched(pos, value),
+                                                Failed => {
+                                                    let choice_res =
+                                                        parse_hex4EscapeSequence(input,
+                                                                                 state,
+                                                                                 pos);
+                                                    match choice_res {
+                                                        Matched(pos, value) =>
+                                                        Matched(pos, value),
+                                                        Failed => {
+                                                            let choice_res =
+                                                                parse_hex8EscapeSequence(input,
+                                                                                         state,
+                                                                                         pos);
+                                                            match choice_res {
+                                                                Matched(pos,
+                                                                        value)
+                                                                =>
+                                                                Matched(pos,
+                                                                        value),
+                                                                Failed =>
+                                                                parse_eolEscapeSequence(input,
+                                                                                        state,
+                                                                                        pos),
+                                                            }
                                                         }
                                                     }
                                                 }
@@ -3550,1077 +8648,1690 @@ fn parse_singleQuotedCharacter<'input>(input: &'input str,
         }
     }
 }
-fn parse_simpleSingleQuotedCharacter<'input>(input: &'input str,
-                                             state: &mut ParseState,
-                                             pos: usize) -> RuleResult<char> {
-    {
-        let start_pos = pos;
-        {
-            let seq_res =
+fn parse_simpleBracketDelimitedCharacter<'input>(input: &'input str,
+                                                 state: &mut ParseState,
+                                                 pos: usize)
+ -> RuleResult<char> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "simpleBracketDelimitedCharacter" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
                 {
-                    let assert_res =
+                    let seq_res =
                         {
-                            let choice_res =
-                                slice_eq(input, state, pos, "\'");
-                            match choice_res {
-                                Matched(pos, value) => Matched(pos, value),
-                                Failed => {
+                            let assert_res =
+                                {
                                     let choice_res =
-                                        slice_eq(input, state, pos, "\\");
+                                        slice_eq(input, state, pos, "]");
                                     match choice_res {
                                         Matched(pos, value) =>
                                         Matched(pos, value),
-                                        Failed =>
-                                        parse_eolChar(input, state, pos),
+                                        Failed => {
+                                            let choice_res =
+                                                slice_eq(input, state, pos,
+                                                         "\\");
+                                            match choice_res {
+                                                Matched(pos, value) =>
+                                                Matched(pos, value),
+                                                Failed =>
+                                                parse_eolChar(input, state,
+                                                              pos),
+                                            }
+                                        }
                                     }
-                                }
+                                };
+                            match assert_res {
+                                Failed => Matched(pos, ()),
+                                Matched(..) => Failed,
                             }
                         };
-                    match assert_res {
-                        Failed => Matched(pos, ()),
-                        Matched(..) => Failed,
+                    match seq_res {
+                        Matched(pos, _) => {
+                            {
+                                let seq_res = any_char(input, state, pos);
+                                match seq_res {
+                                    Matched(pos, _) => {
+                                        {
+                                            let match_str =
+                                                &input[start_pos..pos];
+                                            Matched(pos,
+                                                    {
+                                                        match_str.chars().next().unwrap()
+                                                    })
+                                        }
+                                    }
+                                    Failed => Failed,
+                                }
+                            }
+                        }
+                        Failed => Failed,
                     }
-                };
-            match seq_res {
-                Matched(pos, _) => {
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "simpleBracketDelimitedCharacter" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "simpleBracketDelimitedCharacter" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
+            {
+                let seq_res =
                     {
-                        let seq_res = any_char(input, state, pos);
-                        match seq_res {
-                            Matched(pos, _) => {
-                                {
-                                    let match_str = &input[start_pos..pos];
-                                    Matched(pos,
-                                            {
-                                                match_str.chars().next().unwrap()
-                                            })
+                        let assert_res =
+                            {
+                                let choice_res =
+                                    slice_eq(input, state, pos, "]");
+                                match choice_res {
+                                    Matched(pos, value) =>
+                                    Matched(pos, value),
+                                    Failed => {
+                                        let choice_res =
+                                            slice_eq(input, state, pos, "\\");
+                                        match choice_res {
+                                            Matched(pos, value) =>
+                                            Matched(pos, value),
+                                            Failed =>
+                                            parse_eolChar(input, state, pos),
+                                        }
+                                    }
+                                }
+                            };
+                        match assert_res {
+                            Failed => Matched(pos, ()),
+                            Matched(..) => Failed,
+                        }
+                    };
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res = any_char(input, state, pos);
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    {
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos,
+                                                {
+                                                    match_str.chars().next().unwrap()
+                                                })
+                                    }
                                 }
+                                Failed => Failed,
                             }
-                            Failed => Failed,
                         }
                     }
+                    Failed => Failed,
                 }
-                Failed => Failed,
             }
         }
     }
 }
-fn parse_class<'input>(input: &'input str, state: &mut ParseState, pos: usize)
- -> RuleResult<Expr> {
-    {
-        let start_pos = pos;
-        {
-            let seq_res = slice_eq(input, state, pos, "[");
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let seq_res =
-                            match slice_eq(input, state, pos, "^") {
-                                Matched(newpos, value) => {
-                                    Matched(newpos, Some(value))
-                                }
-                                Failed => { Matched(pos, None) }
-                            };
-                        match seq_res {
-                            Matched(pos, inverted) => {
-                                {
-                                    let seq_res =
-                                        {
-                                            let mut repeat_pos = pos;
-                                            let mut repeat_value = vec!();
-                                            loop  {
-                                                let pos = repeat_pos;
-                                                let step_res =
-                                                    {
+fn parse_simpleEscapeSequence<'input>(input: &'input str,
+                                      state: &mut ParseState, pos: usize)
+ -> RuleResult<char> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "simpleEscapeSequence" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res = slice_eq(input, state, pos, "\\");
+                    match seq_res {
+                        Matched(pos, _) => {
+                            {
+                                let seq_res =
+                                    {
+                                        let assert_res =
+                                            {
+                                                let choice_res =
+                                                    parse_digit(input, state,
+                                                                pos);
+                                                match choice_res {
+                                                    Matched(pos, value) =>
+                                                    Matched(pos, value),
+                                                    Failed => {
                                                         let choice_res =
-                                                            parse_classCharacterRange(input,
-                                                                                      state,
-                                                                                      pos);
+                                                            slice_eq(input,
+                                                                     state,
+                                                                     pos,
+                                                                     "x");
                                                         match choice_res {
                                                             Matched(pos,
                                                                     value) =>
                                                             Matched(pos,
                                                                     value),
-                                                            Failed =>
-                                                            parse_classCharacter(input,
-                                                                                 state,
-                                                                                 pos),
-                                                        }
-                                                    };
-                                                match step_res {
-                                                    Matched(newpos, value) =>
-                                                    {
-                                                        repeat_pos = newpos;
-                                                        repeat_value.push(value);
-                                                    }
-                                                    Failed => { break ; }
-                                                }
-                                            }
-                                            Matched(repeat_pos, repeat_value)
-                                        };
-                                    match seq_res {
-                                        Matched(pos, parts) => {
-                                            {
-                                                let seq_res =
-                                                    slice_eq(input, state,
-                                                             pos, "]");
-                                                match seq_res {
-                                                    Matched(pos, _) => {
-                                                        {
-                                                            let seq_res =
-                                                                match slice_eq(input,
-                                                                               state,
-                                                                               pos,
-                                                                               "i")
+                                                            Failed => {
+                                                                let choice_res =
+                                                                    slice_eq(input,
+                                                                             state,
+                                                                             pos,
+                                                                             "u");
+                                                                match choice_res
                                                                     {
-                                                                    Matched(newpos,
+                                                                    Matched(pos,
                                                                             value)
-                                                                    => {
-                                                                        Matched(newpos,
-                                                                                Some(value))
-                                                                    }
+                                                                    =>
+                                                                    Matched(pos,
+                                                                            value),
                                                                     Failed =>
                                                                     {
-                                                                        Matched(pos,
-                                                                                None)
-                                                                    }
-                                                                };
-                                                            match seq_res {
-                                                                Matched(pos,
-                                                                        flags)
-                                                                => {
-                                                                    {
-                                                                        let seq_res =
-                                                                            parse___(input,
+                                                                        let choice_res =
+                                                                            slice_eq(input,
                                                                                      state,
-                                                                                     pos);
-                                                                        match seq_res
+                                                                                     pos,
+                                                                                     "U");
+                                                                        match choice_res
                                                                             {
                                                                             Matched(pos,
-                                                                                    _)
+                                                                                    value)
                                                                             =>
-                                                                            {
-                                                                                {
-                                                                                    let match_str =
-                                                                                        &input[start_pos..pos];
-                                                                                    Matched(pos,
-                                                                                            {
-                                                                                                CharSetExpr(inverted.is_some(),
-                                                                                                            parts)
-                                                                                            })
-                                                                                }
-                                                                            }
+                                                                            Matched(pos,
+                                                                                    value),
                                                                             Failed
                                                                             =>
-                                                                            Failed,
+                                                                            parse_eolChar(input,
+                                                                                          state,
+                                                                                          pos),
                                                                         }
                                                                     }
                                                                 }
-                                                                Failed =>
-                                                                Failed,
                                                             }
                                                         }
                                                     }
-                                                    Failed => Failed,
+                                                }
+                                            };
+                                        match assert_res {
+                                            Failed => Matched(pos, ()),
+                                            Matched(..) => Failed,
+                                        }
+                                    };
+                                match seq_res {
+                                    Matched(pos, _) => {
+                                        {
+                                            let seq_res =
+                                                any_char(input, state, pos);
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    {
+                                                        let match_str =
+                                                            &input[start_pos..pos];
+                                                        Matched(pos,
+                                                                {
+                                                                    match match_str[1..].chars().next().unwrap()
+                                                                        {
+                                                                        'n' =>
+                                                                        '\n',
+                                                                        'r' =>
+                                                                        '\r',
+                                                                        't' =>
+                                                                        '\t',
+                                                                        x =>
+                                                                        x,
+                                                                    }
+                                                                })
+                                                    }
+                                                }
+                                                Failed => Failed,
+                                            }
+                                        }
+                                    }
+                                    Failed => Failed,
+                                }
+                            }
+                        }
+                        Failed => Failed,
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "simpleEscapeSequence" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "simpleEscapeSequence" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let start_pos = pos;
+            {
+                let seq_res = slice_eq(input, state, pos, "\\");
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res =
+                                {
+                                    let assert_res =
+                                        {
+                                            let choice_res =
+                                                parse_digit(input, state,
+                                                            pos);
+                                            match choice_res {
+                                                Matched(pos, value) =>
+                                                Matched(pos, value),
+                                                Failed => {
+                                                    let choice_res =
+                                                        slice_eq(input, state,
+                                                                 pos, "x");
+                                                    match choice_res {
+                                                        Matched(pos, value) =>
+                                                        Matched(pos, value),
+                                                        Failed => {
+                                                            let choice_res =
+                                                                slice_eq(input,
+                                                                         state,
+                                                                         pos,
+                                                                         "u");
+                                                            match choice_res {
+                                                                Matched(pos,
+                                                                        value)
+                                                                =>
+                                                                Matched(pos,
+                                                                        value),
+                                                                Failed => {
+                                                                    let choice_res =
+                                                                        slice_eq(input,
+                                                                                 state,
+                                                                                 pos,
+                                                                                 "U");
+                                                                    match choice_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                value)
+                                                                        =>
+                                                                        Matched(pos,
+                                                                                value),
+                                                                        Failed
+                                                                        =>
+                                                                        parse_eolChar(input,
+                                                                                      state,
+                                                                                      pos),
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        };
+                                    match assert_res {
+                                        Failed => Matched(pos, ()),
+                                        Matched(..) => Failed,
+                                    }
+                                };
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    {
+                                        let seq_res =
+                                            any_char(input, state, pos);
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos,
+                                                            {
+                                                                match match_str[1..].chars().next().unwrap()
+                                                                    {
+                                                                    'n' =>
+                                                                    '\n',
+                                                                    'r' =>
+                                                                    '\r',
+                                                                    't' =>
+                                                                    '\t',
+                                                                    x => x,
+                                                                }
+                                                            })
                                                 }
                                             }
+                                            Failed => Failed,
                                         }
-                                        Failed => Failed,
                                     }
                                 }
+                                Failed => Failed,
                             }
-                            Failed => Failed,
                         }
                     }
+                    Failed => Failed,
                 }
-                Failed => Failed,
             }
         }
     }
 }
-fn parse_classCharacterRange<'input>(input: &'input str,
-                                     state: &mut ParseState, pos: usize)
- -> RuleResult<CharSetCase> {
-    {
-        let start_pos = pos;
-        {
-            let seq_res = parse_bracketDelimitedCharacter(input, state, pos);
-            match seq_res {
-                Matched(pos, begin) => {
-                    {
-                        let seq_res = slice_eq(input, state, pos, "-");
-                        match seq_res {
-                            Matched(pos, _) => {
-                                {
-                                    let seq_res =
-                                        parse_bracketDelimitedCharacter(input,
-                                                                        state,
-                                                                        pos);
-                                    match seq_res {
-                                        Matched(pos, end) => {
-                                            {
-                                                let match_str =
-                                                    &input[start_pos..pos];
-                                                Matched(pos,
-                                                        {
-                                                            CharSetCase{start:
-                                                                            begin,
-                                                                        end:
-                                                                            end,}
-                                                        })
-                                            }
+fn parse_zeroEscapeSequence<'input>(input: &'input str,
+                                    state: &mut ParseState, pos: usize)
+ -> RuleResult<char> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "zeroEscapeSequence" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res = slice_eq(input, state, pos, "\\0");
+                    match seq_res {
+                        Matched(pos, _) => {
+                            {
+                                let seq_res =
+                                    {
+                                        let assert_res =
+                                            parse_digit(input, state, pos);
+                                        match assert_res {
+                                            Failed => Matched(pos, ()),
+                                            Matched(..) => Failed,
+                                        }
+                                    };
+                                match seq_res {
+                                    Matched(pos, _) => {
+                                        {
+                                            let match_str =
+                                                &input[start_pos..pos];
+                                            Matched(pos, { 0u8 as char })
                                         }
-                                        Failed => Failed,
                                     }
+                                    Failed => Failed,
                                 }
                             }
-                            Failed => Failed,
                         }
+                        Failed => Failed,
                     }
                 }
-                Failed => Failed,
-            }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "zeroEscapeSequence" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "zeroEscapeSequence" , line , col),
         }
-    }
-}
-fn parse_classCharacter<'input>(input: &'input str, state: &mut ParseState,
-                                pos: usize) -> RuleResult<CharSetCase> {
-    {
-        let start_pos = pos;
+        __peg_result
+    } else {
         {
-            let seq_res = parse_bracketDelimitedCharacter(input, state, pos);
-            match seq_res {
-                Matched(pos, char_) => {
-                    {
-                        let match_str = &input[start_pos..pos];
-                        Matched(pos,
-                                { CharSetCase{start: char_, end: char_,} })
+            let start_pos = pos;
+            {
+                let seq_res = slice_eq(input, state, pos, "\\0");
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res =
+                                {
+                                    let assert_res =
+                                        parse_digit(input, state, pos);
+                                    match assert_res {
+                                        Failed => Matched(pos, ()),
+                                        Matched(..) => Failed,
+                                    }
+                                };
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    {
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos, { 0u8 as char })
+                                    }
+                                }
+                                Failed => Failed,
+                            }
+                        }
                     }
+                    Failed => Failed,
                 }
-                Failed => Failed,
             }
         }
     }
 }
-fn parse_bracketDelimitedCharacter<'input>(input: &'input str,
-                                           state: &mut ParseState, pos: usize)
+fn parse_hex2EscapeSequence<'input>(input: &'input str,
+                                    state: &mut ParseState, pos: usize)
  -> RuleResult<char> {
-    {
-        let choice_res =
-            parse_simpleBracketDelimitedCharacter(input, state, pos);
-        match choice_res {
-            Matched(pos, value) => Matched(pos, value),
-            Failed => {
-                let choice_res =
-                    parse_simpleEscapeSequence(input, state, pos);
-                match choice_res {
-                    Matched(pos, value) => Matched(pos, value),
-                    Failed => {
-                        let choice_res =
-                            parse_zeroEscapeSequence(input, state, pos);
-                        match choice_res {
-                            Matched(pos, value) => Matched(pos, value),
-                            Failed => {
-                                let choice_res =
-                                    parse_hex2EscapeSequence(input, state,
-                                                             pos);
-                                match choice_res {
-                                    Matched(pos, value) =>
-                                    Matched(pos, value),
-                                    Failed => {
-                                        let choice_res =
-                                            parse_unicodeEscapeSequence(input,
-                                                                        state,
-                                                                        pos);
-                                        match choice_res {
-                                            Matched(pos, value) =>
-                                            Matched(pos, value),
-                                            Failed => {
-                                                let choice_res =
-                                                    parse_hex4EscapeSequence(input,
-                                                                             state,
-                                                                             pos);
-                                                match choice_res {
-                                                    Matched(pos, value) =>
-                                                    Matched(pos, value),
-                                                    Failed => {
-                                                        let choice_res =
-                                                            parse_hex8EscapeSequence(input,
-                                                                                     state,
-                                                                                     pos);
-                                                        match choice_res {
-                                                            Matched(pos,
-                                                                    value) =>
-                                                            Matched(pos,
-                                                                    value),
-                                                            Failed =>
-                                                            parse_eolEscapeSequence(input,
-                                                                                    state,
-                                                                                    pos),
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "hex2EscapeSequence" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res = slice_eq(input, state, pos, "\\x");
+                    match seq_res {
+                        Matched(pos, _) => {
+                            {
+                                let seq_res =
+                                    {
+                                        let start_pos = pos;
+                                        {
+                                            let seq_res =
+                                                parse_hexDigit(input, state,
+                                                               pos);
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    {
+                                                        let seq_res =
+                                                            parse_hexDigit(input,
+                                                                           state,
+                                                                           pos);
+                                                        match seq_res {
+                                                            Matched(pos, _) =>
+                                                            {
+                                                                {
+                                                                    let match_str =
+                                                                        &input[start_pos..pos];
+                                                                    Matched(pos,
+                                                                            {
+                                                                                u32::from_str_radix(match_str,
+                                                                                                    16)
+                                                                            })
+                                                                }
+                                                            }
+                                                            Failed => Failed,
                                                         }
                                                     }
                                                 }
+                                                Failed => Failed,
                                             }
                                         }
+                                    };
+                                match seq_res {
+                                    Matched(pos, value) => {
+                                        {
+                                            let match_str =
+                                                &input[start_pos..pos];
+                                            Matched(pos,
+                                                    {
+                                                        char::from_u32(value.unwrap()).unwrap()
+                                                    })
+                                        }
                                     }
+                                    Failed => Failed,
                                 }
                             }
                         }
+                        Failed => Failed,
                     }
                 }
-            }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "hex2EscapeSequence" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "hex2EscapeSequence" , line , col),
         }
-    }
-}
-fn parse_simpleBracketDelimitedCharacter<'input>(input: &'input str,
-                                                 state: &mut ParseState,
-                                                 pos: usize)
- -> RuleResult<char> {
-    {
-        let start_pos = pos;
+        __peg_result
+    } else {
         {
-            let seq_res =
-                {
-                    let assert_res =
+            let start_pos = pos;
+            {
+                let seq_res = slice_eq(input, state, pos, "\\x");
+                match seq_res {
+                    Matched(pos, _) => {
                         {
-                            let choice_res = slice_eq(input, state, pos, "]");
-                            match choice_res {
-                                Matched(pos, value) => Matched(pos, value),
-                                Failed => {
-                                    let choice_res =
-                                        slice_eq(input, state, pos, "\\");
-                                    match choice_res {
-                                        Matched(pos, value) =>
-                                        Matched(pos, value),
-                                        Failed =>
-                                        parse_eolChar(input, state, pos),
-                                    }
-                                }
-                            }
-                        };
-                    match assert_res {
-                        Failed => Matched(pos, ()),
-                        Matched(..) => Failed,
-                    }
-                };
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let seq_res = any_char(input, state, pos);
-                        match seq_res {
-                            Matched(pos, _) => {
+                            let seq_res =
                                 {
-                                    let match_str = &input[start_pos..pos];
-                                    Matched(pos,
-                                            {
-                                                match_str.chars().next().unwrap()
-                                            })
+                                    let start_pos = pos;
+                                    {
+                                        let seq_res =
+                                            parse_hexDigit(input, state, pos);
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let seq_res =
+                                                        parse_hexDigit(input,
+                                                                       state,
+                                                                       pos);
+                                                    match seq_res {
+                                                        Matched(pos, _) => {
+                                                            {
+                                                                let match_str =
+                                                                    &input[start_pos..pos];
+                                                                Matched(pos,
+                                                                        {
+                                                                            u32::from_str_radix(match_str,
+                                                                                                16)
+                                                                        })
+                                                            }
+                                                        }
+                                                        Failed => Failed,
+                                                    }
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
+                                };
+                            match seq_res {
+                                Matched(pos, value) => {
+                                    {
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos,
+                                                {
+                                                    char::from_u32(value.unwrap()).unwrap()
+                                                })
+                                    }
                                 }
+                                Failed => Failed,
                             }
-                            Failed => Failed,
                         }
                     }
+                    Failed => Failed,
                 }
-                Failed => Failed,
             }
         }
     }
 }
-fn parse_simpleEscapeSequence<'input>(input: &'input str,
-                                      state: &mut ParseState, pos: usize)
+fn parse_unicodeEscapeSequence<'input>(input: &'input str,
+                                       state: &mut ParseState, pos: usize)
  -> RuleResult<char> {
-    {
-        let start_pos = pos;
-        {
-            let seq_res = slice_eq(input, state, pos, "\\");
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let seq_res =
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "unicodeEscapeSequence" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res = slice_eq(input, state, pos, "\\u{");
+                    match seq_res {
+                        Matched(pos, _) => {
                             {
-                                let assert_res =
+                                let seq_res =
                                     {
-                                        let choice_res =
-                                            parse_digit(input, state, pos);
-                                        match choice_res {
-                                            Matched(pos, value) =>
-                                            Matched(pos, value),
-                                            Failed => {
-                                                let choice_res =
-                                                    slice_eq(input, state,
-                                                             pos, "x");
-                                                match choice_res {
-                                                    Matched(pos, value) =>
-                                                    Matched(pos, value),
-                                                    Failed => {
-                                                        let choice_res =
-                                                            slice_eq(input,
-                                                                     state,
-                                                                     pos,
-                                                                     "u");
-                                                        match choice_res {
-                                                            Matched(pos,
+                                        let start_pos = pos;
+                                        {
+                                            let seq_res =
+                                                {
+                                                    let mut repeat_pos = pos;
+                                                    let mut repeat_value =
+                                                        vec!();
+                                                    loop  {
+                                                        let pos = repeat_pos;
+                                                        let step_res =
+                                                            parse_hexDigit(input,
+                                                                           state,
+                                                                           pos);
+                                                        match step_res {
+                                                            Matched(newpos,
                                                                     value) =>
-                                                            Matched(pos,
-                                                                    value),
+                                                            {
+                                                                repeat_pos =
+                                                                    newpos;
+                                                                repeat_value.push(value);
+                                                            }
                                                             Failed => {
-                                                                let choice_res =
-                                                                    slice_eq(input,
-                                                                             state,
-                                                                             pos,
-                                                                             "U");
-                                                                match choice_res
-                                                                    {
-                                                                    Matched(pos,
-                                                                            value)
-                                                                    =>
-                                                                    Matched(pos,
-                                                                            value),
-                                                                    Failed =>
-                                                                    parse_eolChar(input,
-                                                                                  state,
-                                                                                  pos),
-                                                                }
+                                                                break ;
                                                             }
                                                         }
                                                     }
+                                                    if repeat_value.len() >=
+                                                           1usize {
+                                                        Matched(repeat_pos,
+                                                                ())
+                                                    } else { Failed }
+                                                };
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    {
+                                                        let match_str =
+                                                            &input[start_pos..pos];
+                                                        Matched(pos,
+                                                                {
+                                                                    u32::from_str_radix(match_str,
+                                                                                        16)
+                                                                })
+                                                    }
                                                 }
+                                                Failed => Failed,
                                             }
                                         }
                                     };
-                                match assert_res {
-                                    Failed => Matched(pos, ()),
-                                    Matched(..) => Failed,
-                                }
-                            };
-                        match seq_res {
-                            Matched(pos, _) => {
-                                {
-                                    let seq_res = any_char(input, state, pos);
-                                    match seq_res {
-                                        Matched(pos, _) => {
-                                            {
-                                                let match_str =
-                                                    &input[start_pos..pos];
-                                                Matched(pos,
-                                                        {
-                                                            match match_str[1..].chars().next().unwrap()
+                                match seq_res {
+                                    Matched(pos, value) => {
+                                        {
+                                            let seq_res =
+                                                slice_eq(input, state, pos,
+                                                         "}");
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    {
+                                                        let match_str =
+                                                            &input[start_pos..pos];
+                                                        Matched(pos,
                                                                 {
-                                                                'n' => '\n',
-                                                                'r' => '\r',
-                                                                't' => '\t',
-                                                                x => x,
-                                                            }
-                                                        })
+                                                                    char::from_u32(value.unwrap()).unwrap()
+                                                                })
+                                                    }
+                                                }
+                                                Failed => Failed,
                                             }
                                         }
-                                        Failed => Failed,
                                     }
+                                    Failed => Failed,
                                 }
                             }
-                            Failed => Failed,
                         }
+                        Failed => Failed,
                     }
                 }
-                Failed => Failed,
-            }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "unicodeEscapeSequence" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "unicodeEscapeSequence" , line , col),
         }
-    }
-}
-fn parse_zeroEscapeSequence<'input>(input: &'input str,
-                                    state: &mut ParseState, pos: usize)
- -> RuleResult<char> {
-    {
-        let start_pos = pos;
+        __peg_result
+    } else {
         {
-            let seq_res = slice_eq(input, state, pos, "\\0");
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let seq_res =
-                            {
-                                let assert_res =
-                                    parse_digit(input, state, pos);
-                                match assert_res {
-                                    Failed => Matched(pos, ()),
-                                    Matched(..) => Failed,
-                                }
-                            };
-                        match seq_res {
-                            Matched(pos, _) => {
+            let start_pos = pos;
+            {
+                let seq_res = slice_eq(input, state, pos, "\\u{");
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res =
                                 {
-                                    let match_str = &input[start_pos..pos];
-                                    Matched(pos, { 0u8 as char })
+                                    let start_pos = pos;
+                                    {
+                                        let seq_res =
+                                            {
+                                                let mut repeat_pos = pos;
+                                                let mut repeat_value = vec!();
+                                                loop  {
+                                                    let pos = repeat_pos;
+                                                    let step_res =
+                                                        parse_hexDigit(input,
+                                                                       state,
+                                                                       pos);
+                                                    match step_res {
+                                                        Matched(newpos, value)
+                                                        => {
+                                                            repeat_pos =
+                                                                newpos;
+                                                            repeat_value.push(value);
+                                                        }
+                                                        Failed => { break ; }
+                                                    }
+                                                }
+                                                if repeat_value.len() >=
+                                                       1usize {
+                                                    Matched(repeat_pos, ())
+                                                } else { Failed }
+                                            };
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos,
+                                                            {
+                                                                u32::from_str_radix(match_str,
+                                                                                    16)
+                                                            })
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
+                                };
+                            match seq_res {
+                                Matched(pos, value) => {
+                                    {
+                                        let seq_res =
+                                            slice_eq(input, state, pos, "}");
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let match_str =
+                                                        &input[start_pos..pos];
+                                                    Matched(pos,
+                                                            {
+                                                                char::from_u32(value.unwrap()).unwrap()
+                                                            })
+                                                }
+                                            }
+                                            Failed => Failed,
+                                        }
+                                    }
                                 }
+                                Failed => Failed,
                             }
-                            Failed => Failed,
                         }
                     }
+                    Failed => Failed,
                 }
-                Failed => Failed,
             }
         }
     }
 }
-fn parse_hex2EscapeSequence<'input>(input: &'input str,
+fn parse_hex4EscapeSequence<'input>(input: &'input str,
                                     state: &mut ParseState, pos: usize)
  -> RuleResult<char> {
-    {
-        let start_pos = pos;
-        {
-            let seq_res = slice_eq(input, state, pos, "\\x");
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let seq_res =
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "hex4EscapeSequence" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res = slice_eq(input, state, pos, "\\u");
+                    match seq_res {
+                        Matched(pos, _) => {
                             {
-                                let start_pos = pos;
-                                {
-                                    let seq_res =
-                                        parse_hexDigit(input, state, pos);
-                                    match seq_res {
-                                        Matched(pos, _) => {
-                                            {
-                                                let seq_res =
-                                                    parse_hexDigit(input,
-                                                                   state,
-                                                                   pos);
-                                                match seq_res {
-                                                    Matched(pos, _) => {
-                                                        {
-                                                            let match_str =
-                                                                &input[start_pos..pos];
-                                                            Matched(pos,
-                                                                    {
-                                                                        u32::from_str_radix(match_str,
-                                                                                            16)
-                                                                    })
+                                let seq_res =
+                                    {
+                                        let start_pos = pos;
+                                        {
+                                            let seq_res =
+                                                parse_hexDigit(input, state,
+                                                               pos);
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    {
+                                                        let seq_res =
+                                                            parse_hexDigit(input,
+                                                                           state,
+                                                                           pos);
+                                                        match seq_res {
+                                                            Matched(pos, _) =>
+                                                            {
+                                                                {
+                                                                    let seq_res =
+                                                                        parse_hexDigit(input,
+                                                                                       state,
+                                                                                       pos);
+                                                                    match seq_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                _)
+                                                                        => {
+                                                                            {
+                                                                                let seq_res =
+                                                                                    parse_hexDigit(input,
+                                                                                                   state,
+                                                                                                   pos);
+                                                                                match seq_res
+                                                                                    {
+                                                                                    Matched(pos,
+                                                                                            _)
+                                                                                    =>
+                                                                                    {
+                                                                                        {
+                                                                                            let match_str =
+                                                                                                &input[start_pos..pos];
+                                                                                            Matched(pos,
+                                                                                                    {
+                                                                                                        u32::from_str_radix(match_str,
+                                                                                                                            16)
+                                                                                                    })
+                                                                                        }
+                                                                                    }
+                                                                                    Failed
+                                                                                    =>
+                                                                                    Failed,
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                        Failed
+                                                                        =>
+                                                                        Failed,
+                                                                    }
+                                                                }
+                                                            }
+                                                            Failed => Failed,
                                                         }
                                                     }
-                                                    Failed => Failed,
                                                 }
+                                                Failed => Failed,
                                             }
                                         }
-                                        Failed => Failed,
+                                    };
+                                match seq_res {
+                                    Matched(pos, value) => {
+                                        {
+                                            let match_str =
+                                                &input[start_pos..pos];
+                                            Matched(pos,
+                                                    {
+                                                        char::from_u32(value.unwrap()).unwrap()
+                                                    })
+                                        }
                                     }
-                                }
-                            };
-                        match seq_res {
-                            Matched(pos, value) => {
-                                {
-                                    let match_str = &input[start_pos..pos];
-                                    Matched(pos,
-                                            {
-                                                char::from_u32(value.unwrap()).unwrap()
-                                            })
+                                    Failed => Failed,
                                 }
                             }
-                            Failed => Failed,
                         }
+                        Failed => Failed,
                     }
                 }
-                Failed => Failed,
-            }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "hex4EscapeSequence" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "hex4EscapeSequence" , line , col),
         }
-    }
-}
-fn parse_unicodeEscapeSequence<'input>(input: &'input str,
-                                       state: &mut ParseState, pos: usize)
- -> RuleResult<char> {
-    {
-        let start_pos = pos;
+        __peg_result
+    } else {
         {
-            let seq_res = slice_eq(input, state, pos, "\\u{");
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let seq_res =
-                            {
-                                let start_pos = pos;
+            let start_pos = pos;
+            {
+                let seq_res = slice_eq(input, state, pos, "\\u");
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res =
                                 {
-                                    let seq_res =
-                                        {
-                                            let mut repeat_pos = pos;
-                                            let mut repeat_value = vec!();
-                                            loop  {
-                                                let pos = repeat_pos;
-                                                let step_res =
-                                                    parse_hexDigit(input,
-                                                                   state,
-                                                                   pos);
-                                                match step_res {
-                                                    Matched(newpos, value) =>
-                                                    {
-                                                        repeat_pos = newpos;
-                                                        repeat_value.push(value);
+                                    let start_pos = pos;
+                                    {
+                                        let seq_res =
+                                            parse_hexDigit(input, state, pos);
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let seq_res =
+                                                        parse_hexDigit(input,
+                                                                       state,
+                                                                       pos);
+                                                    match seq_res {
+                                                        Matched(pos, _) => {
+                                                            {
+                                                                let seq_res =
+                                                                    parse_hexDigit(input,
+                                                                                   state,
+                                                                                   pos);
+                                                                match seq_res
+                                                                    {
+                                                                    Matched(pos,
+                                                                            _)
+                                                                    => {
+                                                                        {
+                                                                            let seq_res =
+                                                                                parse_hexDigit(input,
+                                                                                               state,
+                                                                                               pos);
+                                                                            match seq_res
+                                                                                {
+                                                                                Matched(pos,
+                                                                                        _)
+                                                                                =>
+                                                                                {
+                                                                                    {
+                                                                                        let match_str =
+                                                                                            &input[start_pos..pos];
+                                                                                        Matched(pos,
+                                                                                                {
+                                                                                                    u32::from_str_radix(match_str,
+                                                                                                                        16)
+                                                                                                })
+                                                                                    }
+                                                                                }
+                                                                                Failed
+                                                                                =>
+                                                                                Failed,
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                    Failed =>
+                                                                    Failed,
+                                                                }
+                                                            }
+                                                        }
+                                                        Failed => Failed,
                                                     }
-                                                    Failed => { break ; }
                                                 }
                                             }
-                                            if repeat_value.len() >= 1usize {
-                                                Matched(repeat_pos, ())
-                                            } else { Failed }
-                                        };
-                                    match seq_res {
-                                        Matched(pos, _) => {
-                                            {
-                                                let match_str =
-                                                    &input[start_pos..pos];
-                                                Matched(pos,
-                                                        {
-                                                            u32::from_str_radix(match_str,
-                                                                                16)
-                                                        })
-                                            }
+                                            Failed => Failed,
                                         }
-                                        Failed => Failed,
                                     }
-                                }
-                            };
-                        match seq_res {
-                            Matched(pos, value) => {
-                                {
-                                    let seq_res =
-                                        slice_eq(input, state, pos, "}");
-                                    match seq_res {
-                                        Matched(pos, _) => {
-                                            {
-                                                let match_str =
-                                                    &input[start_pos..pos];
-                                                Matched(pos,
-                                                        {
-                                                            char::from_u32(value.unwrap()).unwrap()
-                                                        })
-                                            }
-                                        }
-                                        Failed => Failed,
+                                };
+                            match seq_res {
+                                Matched(pos, value) => {
+                                    {
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos,
+                                                {
+                                                    char::from_u32(value.unwrap()).unwrap()
+                                                })
                                     }
                                 }
+                                Failed => Failed,
                             }
-                            Failed => Failed,
                         }
                     }
+                    Failed => Failed,
                 }
-                Failed => Failed,
             }
         }
     }
 }
-fn parse_hex4EscapeSequence<'input>(input: &'input str,
+fn parse_hex8EscapeSequence<'input>(input: &'input str,
                                     state: &mut ParseState, pos: usize)
  -> RuleResult<char> {
-    {
-        let start_pos = pos;
-        {
-            let seq_res = slice_eq(input, state, pos, "\\u");
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let seq_res =
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "hex8EscapeSequence" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res = slice_eq(input, state, pos, "\\U");
+                    match seq_res {
+                        Matched(pos, _) => {
                             {
-                                let start_pos = pos;
-                                {
-                                    let seq_res =
-                                        parse_hexDigit(input, state, pos);
-                                    match seq_res {
-                                        Matched(pos, _) => {
-                                            {
-                                                let seq_res =
-                                                    parse_hexDigit(input,
-                                                                   state,
-                                                                   pos);
-                                                match seq_res {
-                                                    Matched(pos, _) => {
-                                                        {
-                                                            let seq_res =
-                                                                parse_hexDigit(input,
-                                                                               state,
-                                                                               pos);
-                                                            match seq_res {
-                                                                Matched(pos,
-                                                                        _) =>
+                                let seq_res =
+                                    {
+                                        let start_pos = pos;
+                                        {
+                                            let seq_res =
+                                                parse_hexDigit(input, state,
+                                                               pos);
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    {
+                                                        let seq_res =
+                                                            parse_hexDigit(input,
+                                                                           state,
+                                                                           pos);
+                                                        match seq_res {
+                                                            Matched(pos, _) =>
+                                                            {
                                                                 {
-                                                                    {
-                                                                        let seq_res =
-                                                                            parse_hexDigit(input,
-                                                                                           state,
-                                                                                           pos);
-                                                                        match seq_res
-                                                                            {
-                                                                            Matched(pos,
-                                                                                    _)
-                                                                            =>
+                                                                    let seq_res =
+                                                                        parse_hexDigit(input,
+                                                                                       state,
+                                                                                       pos);
+                                                                    match seq_res
+                                                                        {
+                                                                        Matched(pos,
+                                                                                _)
+                                                                        => {
                                                                             {
-                                                                                {
-                                                                                    let match_str =
-                                                                                        &input[start_pos..pos];
+                                                                                let seq_res =
+                                                                                    parse_hexDigit(input,
+                                                                                                   state,
+                                                                                                   pos);
+                                                                                match seq_res
+                                                                                    {
                                                                                     Matched(pos,
-                                                                                            {
-                                                                                                u32::from_str_radix(match_str,
-                                                                                                                    16)
-                                                                                            })
+                                                                                            _)
+                                                                                    =>
+                                                                                    {
+                                                                                        {
+                                                                                            let seq_res =
+                                                                                                parse_hexDigit(input,
+                                                                                                               state,
+                                                                                                               pos);
+                                                                                            match seq_res
+                                                                                                {
+                                                                                                Matched(pos,
+                                                                                                        _)
+                                                                                                =>
+                                                                                                {
+                                                                                                    {
+                                                                                                        let seq_res =
+                                                                                                            parse_hexDigit(input,
+                                                                                                                           state,
+                                                                                                                           pos);
+                                                                                                        match seq_res
+                                                                                                            {
+                                                                                                            Matched(pos,
+                                                                                                                    _)
+                                                                                                            =>
+                                                                                                            {
+                                                                                                                {
+                                                                                                                    let seq_res =
+                                                                                                                        parse_hexDigit(input,
+                                                                                                                                       state,
+                                                                                                                                       pos);
+                                                                                                                    match seq_res
+                                                                                                                        {
+                                                                                                                        Matched(pos,
+                                                                                                                                _)
+                                                                                                                        =>
+                                                                                                                        {
+                                                                                                                            {
+                                                                                                                                let seq_res =
+                                                                                                                                    parse_hexDigit(input,
+                                                                                                                                                   state,
+                                                                                                                                                   pos);
+                                                                                                                                match seq_res
+                                                                                                                                    {
+                                                                                                                                    Matched(pos,
+                                                                                                                                            _)
+                                                                                                                                    =>
+                                                                                                                                    {
+                                                                                                                                        {
+                                                                                                                                            let match_str =
+                                                                                                                                                &input[start_pos..pos];
+                                                                                                                                            Matched(pos,
+                                                                                                                                                    {
+                                                                                                                                                        u32::from_str_radix(match_str,
+                                                                                                                                                                            16)
+                                                                                                                                                    })
+                                                                                                                                        }
+                                                                                                                                    }
+                                                                                                                                    Failed
+                                                                                                                                    =>
+                                                                                                                                    Failed,
+                                                                                                                                }
+                                                                                                                            }
+                                                                                                                        }
+                                                                                                                        Failed
+                                                                                                                        =>
+                                                                                                                        Failed,
+                                                                                                                    }
+                                                                                                                }
+                                                                                                            }
+                                                                                                            Failed
+                                                                                                            =>
+                                                                                                            Failed,
+                                                                                                        }
+                                                                                                    }
+                                                                                                }
+                                                                                                Failed
+                                                                                                =>
+                                                                                                Failed,
+                                                                                            }
+                                                                                        }
+                                                                                    }
+                                                                                    Failed
+                                                                                    =>
+                                                                                    Failed,
                                                                                 }
                                                                             }
-                                                                            Failed
-                                                                            =>
-                                                                            Failed,
                                                                         }
+                                                                        Failed
+                                                                        =>
+                                                                        Failed,
                                                                     }
                                                                 }
-                                                                Failed =>
-                                                                Failed,
                                                             }
+                                                            Failed => Failed,
                                                         }
                                                     }
-                                                    Failed => Failed,
                                                 }
+                                                Failed => Failed,
                                             }
                                         }
-                                        Failed => Failed,
+                                    };
+                                match seq_res {
+                                    Matched(pos, value) => {
+                                        {
+                                            let match_str =
+                                                &input[start_pos..pos];
+                                            Matched(pos,
+                                                    {
+                                                        char::from_u32(value.unwrap()).unwrap()
+                                                    })
+                                        }
                                     }
-                                }
-                            };
-                        match seq_res {
-                            Matched(pos, value) => {
-                                {
-                                    let match_str = &input[start_pos..pos];
-                                    Matched(pos,
-                                            {
-                                                char::from_u32(value.unwrap()).unwrap()
-                                            })
+                                    Failed => Failed,
                                 }
                             }
-                            Failed => Failed,
                         }
+                        Failed => Failed,
                     }
                 }
-                Failed => Failed,
-            }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "hex8EscapeSequence" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "hex8EscapeSequence" , line , col),
         }
-    }
-}
-fn parse_hex8EscapeSequence<'input>(input: &'input str,
-                                    state: &mut ParseState, pos: usize)
- -> RuleResult<char> {
-    {
-        let start_pos = pos;
+        __peg_result
+    } else {
         {
-            let seq_res = slice_eq(input, state, pos, "\\U");
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let seq_res =
-                            {
-                                let start_pos = pos;
+            let start_pos = pos;
+            {
+                let seq_res = slice_eq(input, state, pos, "\\U");
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res =
                                 {
-                                    let seq_res =
-                                        parse_hexDigit(input, state, pos);
-                                    match seq_res {
-                                        Matched(pos, _) => {
-                                            {
-                                                let seq_res =
-                                                    parse_hexDigit(input,
-                                                                   state,
-                                                                   pos);
-                                                match seq_res {
-                                                    Matched(pos, _) => {
-                                                        {
-                                                            let seq_res =
-                                                                parse_hexDigit(input,
-                                                                               state,
-                                                                               pos);
-                                                            match seq_res {
-                                                                Matched(pos,
-                                                                        _) =>
-                                                                {
+                                    let start_pos = pos;
+                                    {
+                                        let seq_res =
+                                            parse_hexDigit(input, state, pos);
+                                        match seq_res {
+                                            Matched(pos, _) => {
+                                                {
+                                                    let seq_res =
+                                                        parse_hexDigit(input,
+                                                                       state,
+                                                                       pos);
+                                                    match seq_res {
+                                                        Matched(pos, _) => {
+                                                            {
+                                                                let seq_res =
+                                                                    parse_hexDigit(input,
+                                                                                   state,
+                                                                                   pos);
+                                                                match seq_res
                                                                     {
-                                                                        let seq_res =
-                                                                            parse_hexDigit(input,
-                                                                                           state,
-                                                                                           pos);
-                                                                        match seq_res
-                                                                            {
-                                                                            Matched(pos,
-                                                                                    _)
-                                                                            =>
-                                                                            {
+                                                                    Matched(pos,
+                                                                            _)
+                                                                    => {
+                                                                        {
+                                                                            let seq_res =
+                                                                                parse_hexDigit(input,
+                                                                                               state,
+                                                                                               pos);
+                                                                            match seq_res
                                                                                 {
-                                                                                    let seq_res =
-                                                                                        parse_hexDigit(input,
-                                                                                                       state,
-                                                                                                       pos);
-                                                                                    match seq_res
-                                                                                        {
-                                                                                        Matched(pos,
-                                                                                                _)
-                                                                                        =>
-                                                                                        {
+                                                                                Matched(pos,
+                                                                                        _)
+                                                                                =>
+                                                                                {
+                                                                                    {
+                                                                                        let seq_res =
+                                                                                            parse_hexDigit(input,
+                                                                                                           state,
+                                                                                                           pos);
+                                                                                        match seq_res
                                                                                             {
-                                                                                                let seq_res =
-                                                                                                    parse_hexDigit(input,
-                                                                                                                   state,
-                                                                                                                   pos);
-                                                                                                match seq_res
-                                                                                                    {
-                                                                                                    Matched(pos,
-                                                                                                            _)
-                                                                                                    =>
-                                                                                                    {
+                                                                                            Matched(pos,
+                                                                                                    _)
+                                                                                            =>
+                                                                                            {
+                                                                                                {
+                                                                                                    let seq_res =
+                                                                                                        parse_hexDigit(input,
+                                                                                                                       state,
+                                                                                                                       pos);
+                                                                                                    match seq_res
                                                                                                         {
-                                                                                                            let seq_res =
-                                                                                                                parse_hexDigit(input,
-                                                                                                                               state,
-                                                                                                                               pos);
-                                                                                                            match seq_res
-                                                                                                                {
-                                                                                                                Matched(pos,
-                                                                                                                        _)
-                                                                                                                =>
-                                                                                                                {
+                                                                                                        Matched(pos,
+                                                                                                                _)
+                                                                                                        =>
+                                                                                                        {
+                                                                                                            {
+                                                                                                                let seq_res =
+                                                                                                                    parse_hexDigit(input,
+                                                                                                                                   state,
+                                                                                                                                   pos);
+                                                                                                                match seq_res
                                                                                                                     {
-                                                                                                                        let seq_res =
-                                                                                                                            parse_hexDigit(input,
-                                                                                                                                           state,
-                                                                                                                                           pos);
-                                                                                                                        match seq_res
-                                                                                                                            {
-                                                                                                                            Matched(pos,
-                                                                                                                                    _)
-                                                                                                                            =>
-                                                                                                                            {
+                                                                                                                    Matched(pos,
+                                                                                                                            _)
+                                                                                                                    =>
+                                                                                                                    {
+                                                                                                                        {
+                                                                                                                            let seq_res =
+                                                                                                                                parse_hexDigit(input,
+                                                                                                                                               state,
+                                                                                                                                               pos);
+                                                                                                                            match seq_res
                                                                                                                                 {
-                                                                                                                                    let match_str =
-                                                                                                                                        &input[start_pos..pos];
-                                                                                                                                    Matched(pos,
-                                                                                                                                            {
-                                                                                                                                                u32::from_str_radix(match_str,
-                                                                                                                                                                    16)
-                                                                                                                                            })
+                                                                                                                                Matched(pos,
+                                                                                                                                        _)
+                                                                                                                                =>
+                                                                                                                                {
+                                                                                                                                    {
+                                                                                                                                        let match_str =
+                                                                                                                                            &input[start_pos..pos];
+                                                                                                                                        Matched(pos,
+                                                                                                                                                {
+                                                                                                                                                    u32::from_str_radix(match_str,
+                                                                                                                                                                        16)
+                                                                                                                                                })
+                                                                                                                                    }
                                                                                                                                 }
+                                                                                                                                Failed
+                                                                                                                                =>
+                                                                                                                                Failed,
                                                                                                                             }
-                                                                                                                            Failed
-                                                                                                                            =>
-                                                                                                                            Failed,
                                                                                                                         }
                                                                                                                     }
+                                                                                                                    Failed
+                                                                                                                    =>
+                                                                                                                    Failed,
                                                                                                                 }
-                                                                                                                Failed
-                                                                                                                =>
-                                                                                                                Failed,
                                                                                                             }
                                                                                                         }
+                                                                                                        Failed
+                                                                                                        =>
+                                                                                                        Failed,
                                                                                                     }
-                                                                                                    Failed
-                                                                                                    =>
-                                                                                                    Failed,
                                                                                                 }
                                                                                             }
+                                                                                            Failed
+                                                                                            =>
+                                                                                            Failed,
                                                                                         }
-                                                                                        Failed
-                                                                                        =>
-                                                                                        Failed,
                                                                                     }
                                                                                 }
+                                                                                Failed
+                                                                                =>
+                                                                                Failed,
                                                                             }
-                                                                            Failed
-                                                                            =>
-                                                                            Failed,
                                                                         }
                                                                     }
+                                                                    Failed =>
+                                                                    Failed,
                                                                 }
-                                                                Failed =>
-                                                                Failed,
                                                             }
                                                         }
+                                                        Failed => Failed,
                                                     }
-                                                    Failed => Failed,
                                                 }
                                             }
+                                            Failed => Failed,
                                         }
-                                        Failed => Failed,
+                                    }
+                                };
+                            match seq_res {
+                                Matched(pos, value) => {
+                                    {
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos,
+                                                {
+                                                    char::from_u32(value.unwrap()).unwrap()
+                                                })
                                     }
                                 }
-                            };
-                        match seq_res {
-                            Matched(pos, value) => {
-                                {
-                                    let match_str = &input[start_pos..pos];
-                                    Matched(pos,
-                                            {
-                                                char::from_u32(value.unwrap()).unwrap()
-                                            })
-                                }
+                                Failed => Failed,
                             }
-                            Failed => Failed,
                         }
                     }
+                    Failed => Failed,
                 }
-                Failed => Failed,
             }
         }
     }
 }
 fn parse_eolEscapeSequence<'input>(input: &'input str, state: &mut ParseState,
                                    pos: usize) -> RuleResult<char> {
-    {
-        let start_pos = pos;
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "eolEscapeSequence" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let start_pos = pos;
+                {
+                    let seq_res = slice_eq(input, state, pos, "\\");
+                    match seq_res {
+                        Matched(pos, _) => {
+                            {
+                                let seq_res = parse_eol(input, state, pos);
+                                match seq_res {
+                                    Matched(pos, eol) => {
+                                        {
+                                            let match_str =
+                                                &input[start_pos..pos];
+                                            Matched(pos, { '\n' })
+                                        }
+                                    }
+                                    Failed => Failed,
+                                }
+                            }
+                        }
+                        Failed => Failed,
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "eolEscapeSequence" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "eolEscapeSequence" , line , col),
+        }
+        __peg_result
+    } else {
         {
-            let seq_res = slice_eq(input, state, pos, "\\");
-            match seq_res {
-                Matched(pos, _) => {
-                    {
-                        let seq_res = parse_eol(input, state, pos);
-                        match seq_res {
-                            Matched(pos, eol) => {
-                                {
-                                    let match_str = &input[start_pos..pos];
-                                    Matched(pos, { '\n' })
+            let start_pos = pos;
+            {
+                let seq_res = slice_eq(input, state, pos, "\\");
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res = parse_eol(input, state, pos);
+                            match seq_res {
+                                Matched(pos, eol) => {
+                                    {
+                                        let match_str =
+                                            &input[start_pos..pos];
+                                        Matched(pos, { '\n' })
+                                    }
                                 }
+                                Failed => Failed,
                             }
-                            Failed => Failed,
                         }
                     }
+                    Failed => Failed,
                 }
-                Failed => Failed,
             }
         }
     }
 }
 fn parse_digit<'input>(input: &'input str, state: &mut ParseState, pos: usize)
  -> RuleResult<()> {
-    if input.len() > pos {
-        let (ch, next) = char_range_at(input, pos);
-        match ch {
-            '0' ...'9' => Matched(next, ()),
-            _ => state.mark_failure(pos, "[0-9]"),
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "digit"
+                 , line , col);
+        let mut __peg_closure = move || {
+            if input.len() > pos {
+                let (ch, next) = char_range_at(input, pos);
+                match ch {
+                    '0' ...'9' => Matched(next, ()),
+                    _ => state.mark_failure(pos, "[0-9]"),
+                }
+            } else { state.mark_failure(pos, "[0-9]") } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "digit" , line ,
+                     col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "digit"
+                     , line , col),
         }
-    } else { state.mark_failure(pos, "[0-9]") }
+        __peg_result
+    } else {
+        if input.len() > pos {
+            let (ch, next) = char_range_at(input, pos);
+            match ch {
+                '0' ...'9' => Matched(next, ()),
+                _ => state.mark_failure(pos, "[0-9]"),
+            }
+        } else { state.mark_failure(pos, "[0-9]") }
+    }
 }
 fn parse_hexDigit<'input>(input: &'input str, state: &mut ParseState,
                           pos: usize) -> RuleResult<()> {
-    if input.len() > pos {
-        let (ch, next) = char_range_at(input, pos);
-        match ch {
-            '0' ...'9' | 'a' ...'f' | 'A' ...'F' => Matched(next, ()),
-            _ => state.mark_failure(pos, "[0-9a-fA-F]"),
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "hexDigit" , line , col);
+        let mut __peg_closure = move || {
+            if input.len() > pos {
+                let (ch, next) = char_range_at(input, pos);
+                match ch {
+                    '0' ...'9' | 'a' ...'f' | 'A' ...'F' => Matched(next, ()),
+                    _ => state.mark_failure(pos, "[0-9a-fA-F]"),
+                }
+            } else { state.mark_failure(pos, "[0-9a-fA-F]") } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "hexDigit" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "hexDigit" , line , col),
         }
-    } else { state.mark_failure(pos, "[0-9a-fA-F]") }
+        __peg_result
+    } else {
+        if input.len() > pos {
+            let (ch, next) = char_range_at(input, pos);
+            match ch {
+                '0' ...'9' | 'a' ...'f' | 'A' ...'F' => Matched(next, ()),
+                _ => state.mark_failure(pos, "[0-9a-fA-F]"),
+            }
+        } else { state.mark_failure(pos, "[0-9a-fA-F]") }
+    }
 }
 fn parse_letter<'input>(input: &'input str, state: &mut ParseState,
                         pos: usize) -> RuleResult<()> {
-    {
-        let choice_res = parse_lowerCaseLetter(input, state, pos);
-        match choice_res {
-            Matched(pos, value) => Matched(pos, value),
-            Failed => parse_upperCaseLetter(input, state, pos),
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "letter"
+                 , line , col);
+        let mut __peg_closure = move || {
+            {
+                let choice_res = parse_lowerCaseLetter(input, state, pos);
+                match choice_res {
+                    Matched(pos, value) => Matched(pos, value),
+                    Failed => parse_upperCaseLetter(input, state, pos),
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "letter" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "letter"
+                     , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let choice_res = parse_lowerCaseLetter(input, state, pos);
+            match choice_res {
+                Matched(pos, value) => Matched(pos, value),
+                Failed => parse_upperCaseLetter(input, state, pos),
+            }
         }
     }
 }
 fn parse_lowerCaseLetter<'input>(input: &'input str, state: &mut ParseState,
                                  pos: usize) -> RuleResult<()> {
-    if input.len() > pos {
-        let (ch, next) = char_range_at(input, pos);
-        match ch {
-            'a' ...'z' => Matched(next, ()),
-            _ => state.mark_failure(pos, "[a-z]"),
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "lowerCaseLetter" , line , col);
+        let mut __peg_closure = move || {
+            if input.len() > pos {
+                let (ch, next) = char_range_at(input, pos);
+                match ch {
+                    'a' ...'z' => Matched(next, ()),
+                    _ => state.mark_failure(pos, "[a-z]"),
+                }
+            } else { state.mark_failure(pos, "[a-z]") } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "lowerCaseLetter" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "lowerCaseLetter" , line , col),
         }
-    } else { state.mark_failure(pos, "[a-z]") }
+        __peg_result
+    } else {
+        if input.len() > pos {
+            let (ch, next) = char_range_at(input, pos);
+            match ch {
+                'a' ...'z' => Matched(next, ()),
+                _ => state.mark_failure(pos, "[a-z]"),
+            }
+        } else { state.mark_failure(pos, "[a-z]") }
+    }
 }
 fn parse_upperCaseLetter<'input>(input: &'input str, state: &mut ParseState,
                                  pos: usize) -> RuleResult<()> {
-    if input.len() > pos {
-        let (ch, next) = char_range_at(input, pos);
-        match ch {
-            'A' ...'Z' => Matched(next, ()),
-            _ => state.mark_failure(pos, "[A-Z]"),
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "upperCaseLetter" , line , col);
+        let mut __peg_closure = move || {
+            if input.len() > pos {
+                let (ch, next) = char_range_at(input, pos);
+                match ch {
+                    'A' ...'Z' => Matched(next, ()),
+                    _ => state.mark_failure(pos, "[A-Z]"),
+                }
+            } else { state.mark_failure(pos, "[A-Z]") } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "upperCaseLetter" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "upperCaseLetter" , line , col),
         }
-    } else { state.mark_failure(pos, "[A-Z]") }
+        __peg_result
+    } else {
+        if input.len() > pos {
+            let (ch, next) = char_range_at(input, pos);
+            match ch {
+                'A' ...'Z' => Matched(next, ()),
+                _ => state.mark_failure(pos, "[A-Z]"),
+            }
+        } else { state.mark_failure(pos, "[A-Z]") }
+    }
 }
 fn parse___<'input>(input: &'input str, state: &mut ParseState, pos: usize)
  -> RuleResult<()> {
-    {
-        let mut repeat_pos = pos;
-        loop  {
-            let pos = repeat_pos;
-            let step_res =
-                {
-                    let choice_res = parse_whitespace(input, state, pos);
-                    match choice_res {
-                        Matched(pos, value) => Matched(pos, value),
-                        Failed => {
-                            let choice_res = parse_eol(input, state, pos);
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "__" ,
+                 line , col);
+        let mut __peg_closure = move || {
+            {
+                let mut repeat_pos = pos;
+                loop  {
+                    let pos = repeat_pos;
+                    let step_res =
+                        {
+                            let choice_res =
+                                parse_whitespace(input, state, pos);
                             match choice_res {
                                 Matched(pos, value) => Matched(pos, value),
-                                Failed => parse_comment(input, state, pos),
+                                Failed => {
+                                    let choice_res =
+                                        parse_eol(input, state, pos);
+                                    match choice_res {
+                                        Matched(pos, value) =>
+                                        Matched(pos, value),
+                                        Failed =>
+                                        parse_comment(input, state, pos),
+                                    }
+                                }
                             }
-                        }
+                        };
+                    match step_res {
+                        Matched(newpos, value) => { repeat_pos = newpos; }
+                        Failed => { break ; }
                     }
-                };
-            match step_res {
-                Matched(newpos, value) => { repeat_pos = newpos; }
-                Failed => { break ; }
+                }
+                Matched(repeat_pos, ())
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "__" , line ,
+                     col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "__" ,
+                     line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let mut repeat_pos = pos;
+            loop  {
+                let pos = repeat_pos;
+                let step_res =
+                    {
+                        let choice_res = parse_whitespace(input, state, pos);
+                        match choice_res {
+                            Matched(pos, value) => Matched(pos, value),
+                            Failed => {
+                                let choice_res = parse_eol(input, state, pos);
+                                match choice_res {
+                                    Matched(pos, value) =>
+                                    Matched(pos, value),
+                                    Failed =>
+                                    parse_comment(input, state, pos),
+                                }
+                            }
+                        }
+                    };
+                match step_res {
+                    Matched(newpos, value) => { repeat_pos = newpos; }
+                    Failed => { break ; }
+                }
             }
+            Matched(repeat_pos, ())
         }
-        Matched(repeat_pos, ())
     }
 }
 fn parse_comment<'input>(input: &'input str, state: &mut ParseState,
                          pos: usize) -> RuleResult<()> {
-    {
-        let choice_res = parse_singleLineComment(input, state, pos);
-        match choice_res {
-            Matched(pos, value) => Matched(pos, value),
-            Failed => parse_multiLineComment(input, state, pos),
-        }
-    }
-}
-fn parse_singleLineComment<'input>(input: &'input str, state: &mut ParseState,
-                                   pos: usize) -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "//");
-        match seq_res {
-            Matched(pos, _) => {
-                {
-                    let mut repeat_pos = pos;
-                    loop  {
-                        let pos = repeat_pos;
-                        let step_res =
-                            {
-                                let seq_res =
-                                    {
-                                        let assert_res =
-                                            parse_eolChar(input, state, pos);
-                                        match assert_res {
-                                            Failed => Matched(pos, ()),
-                                            Matched(..) => Failed,
-                                        }
-                                    };
-                                match seq_res {
-                                    Matched(pos, _) => {
-                                        any_char(input, state, pos)
-                                    }
-                                    Failed => Failed,
-                                }
-                            };
-                        match step_res {
-                            Matched(newpos, value) => { repeat_pos = newpos; }
-                            Failed => { break ; }
-                        }
-                    }
-                    Matched(repeat_pos, ())
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "comment" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let choice_res = parse_singleLineComment(input, state, pos);
+                match choice_res {
+                    Matched(pos, value) => Matched(pos, value),
+                    Failed => parse_multiLineComment(input, state, pos),
                 }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "comment" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "comment" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let choice_res = parse_singleLineComment(input, state, pos);
+            match choice_res {
+                Matched(pos, value) => Matched(pos, value),
+                Failed => parse_multiLineComment(input, state, pos),
             }
-            Failed => Failed,
         }
     }
 }
-fn parse_multiLineComment<'input>(input: &'input str, state: &mut ParseState,
-                                  pos: usize) -> RuleResult<()> {
-    {
-        let seq_res = slice_eq(input, state, pos, "/*");
-        match seq_res {
-            Matched(pos, _) => {
-                {
-                    let seq_res =
+fn parse_singleLineComment<'input>(input: &'input str, state: &mut ParseState,
+                                   pos: usize) -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "singleLineComment" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "//");
+                match seq_res {
+                    Matched(pos, _) => {
                         {
                             let mut repeat_pos = pos;
                             loop  {
@@ -4630,8 +10341,8 @@ fn parse_multiLineComment<'input>(input: &'input str, state: &mut ParseState,
                                         let seq_res =
                                             {
                                                 let assert_res =
-                                                    slice_eq(input, state,
-                                                             pos, "*/");
+                                                    parse_eolChar(input,
+                                                                  state, pos);
                                                 match assert_res {
                                                     Failed =>
                                                     Matched(pos, ()),
@@ -4653,41 +10364,263 @@ fn parse_multiLineComment<'input>(input: &'input str, state: &mut ParseState,
                                 }
                             }
                             Matched(repeat_pos, ())
-                        };
-                    match seq_res {
-                        Matched(pos, _) => {
-                            slice_eq(input, state, pos, "*/")
                         }
-                        Failed => Failed,
+                    }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "singleLineComment" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "singleLineComment" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "//");
+            match seq_res {
+                Matched(pos, _) => {
+                    {
+                        let mut repeat_pos = pos;
+                        loop  {
+                            let pos = repeat_pos;
+                            let step_res =
+                                {
+                                    let seq_res =
+                                        {
+                                            let assert_res =
+                                                parse_eolChar(input, state,
+                                                              pos);
+                                            match assert_res {
+                                                Failed => Matched(pos, ()),
+                                                Matched(..) => Failed,
+                                            }
+                                        };
+                                    match seq_res {
+                                        Matched(pos, _) => {
+                                            any_char(input, state, pos)
+                                        }
+                                        Failed => Failed,
+                                    }
+                                };
+                            match step_res {
+                                Matched(newpos, value) => {
+                                    repeat_pos = newpos;
+                                }
+                                Failed => { break ; }
+                            }
+                        }
+                        Matched(repeat_pos, ())
+                    }
+                }
+                Failed => Failed,
+            }
+        }
+    }
+}
+fn parse_multiLineComment<'input>(input: &'input str, state: &mut ParseState,
+                                  pos: usize) -> RuleResult<()> {
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "multiLineComment" , line , col);
+        let mut __peg_closure = move || {
+            {
+                let seq_res = slice_eq(input, state, pos, "/*");
+                match seq_res {
+                    Matched(pos, _) => {
+                        {
+                            let seq_res =
+                                {
+                                    let mut repeat_pos = pos;
+                                    loop  {
+                                        let pos = repeat_pos;
+                                        let step_res =
+                                            {
+                                                let seq_res =
+                                                    {
+                                                        let assert_res =
+                                                            slice_eq(input,
+                                                                     state,
+                                                                     pos,
+                                                                     "*/");
+                                                        match assert_res {
+                                                            Failed =>
+                                                            Matched(pos, ()),
+                                                            Matched(..) =>
+                                                            Failed,
+                                                        }
+                                                    };
+                                                match seq_res {
+                                                    Matched(pos, _) => {
+                                                        any_char(input, state,
+                                                                 pos)
+                                                    }
+                                                    Failed => Failed,
+                                                }
+                                            };
+                                        match step_res {
+                                            Matched(newpos, value) => {
+                                                repeat_pos = newpos;
+                                            }
+                                            Failed => { break ; }
+                                        }
+                                    }
+                                    Matched(repeat_pos, ())
+                                };
+                            match seq_res {
+                                Matched(pos, _) => {
+                                    slice_eq(input, state, pos, "*/")
+                                }
+                                Failed => Failed,
+                            }
+                        }
+                    }
+                    Failed => Failed,
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" ,
+                     "multiLineComment" , line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "multiLineComment" , line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let seq_res = slice_eq(input, state, pos, "/*");
+            match seq_res {
+                Matched(pos, _) => {
+                    {
+                        let seq_res =
+                            {
+                                let mut repeat_pos = pos;
+                                loop  {
+                                    let pos = repeat_pos;
+                                    let step_res =
+                                        {
+                                            let seq_res =
+                                                {
+                                                    let assert_res =
+                                                        slice_eq(input, state,
+                                                                 pos, "*/");
+                                                    match assert_res {
+                                                        Failed =>
+                                                        Matched(pos, ()),
+                                                        Matched(..) => Failed,
+                                                    }
+                                                };
+                                            match seq_res {
+                                                Matched(pos, _) => {
+                                                    any_char(input, state,
+                                                             pos)
+                                                }
+                                                Failed => Failed,
+                                            }
+                                        };
+                                    match step_res {
+                                        Matched(newpos, value) => {
+                                            repeat_pos = newpos;
+                                        }
+                                        Failed => { break ; }
+                                    }
+                                }
+                                Matched(repeat_pos, ())
+                            };
+                        match seq_res {
+                            Matched(pos, _) => {
+                                slice_eq(input, state, pos, "*/")
+                            }
+                            Failed => Failed,
+                        }
                     }
                 }
+                Failed => Failed,
             }
-            Failed => Failed,
         }
     }
 }
 fn parse_eol<'input>(input: &'input str, state: &mut ParseState, pos: usize)
  -> RuleResult<()> {
-    {
-        let choice_res = slice_eq(input, state, pos, "\n");
-        match choice_res {
-            Matched(pos, value) => Matched(pos, value),
-            Failed => {
-                let choice_res = slice_eq(input, state, pos, "\r\n");
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" , "eol" ,
+                 line , col);
+        let mut __peg_closure = move || {
+            {
+                let choice_res = slice_eq(input, state, pos, "\n");
                 match choice_res {
                     Matched(pos, value) => Matched(pos, value),
                     Failed => {
-                        let choice_res = slice_eq(input, state, pos, "\r");
+                        let choice_res = slice_eq(input, state, pos, "\r\n");
                         match choice_res {
                             Matched(pos, value) => Matched(pos, value),
                             Failed => {
                                 let choice_res =
-                                    slice_eq(input, state, pos, "\u{2028}");
+                                    slice_eq(input, state, pos, "\r");
                                 match choice_res {
                                     Matched(pos, value) =>
                                     Matched(pos, value),
-                                    Failed =>
-                                    slice_eq(input, state, pos, "\u{2029}"),
+                                    Failed => {
+                                        let choice_res =
+                                            slice_eq(input, state, pos,
+                                                     "\u{2028}");
+                                        match choice_res {
+                                            Matched(pos, value) =>
+                                            Matched(pos, value),
+                                            Failed =>
+                                            slice_eq(input, state, pos,
+                                                     "\u{2029}"),
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "eol" , line ,
+                     col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" , "eol" ,
+                     line , col),
+        }
+        __peg_result
+    } else {
+        {
+            let choice_res = slice_eq(input, state, pos, "\n");
+            match choice_res {
+                Matched(pos, value) => Matched(pos, value),
+                Failed => {
+                    let choice_res = slice_eq(input, state, pos, "\r\n");
+                    match choice_res {
+                        Matched(pos, value) => Matched(pos, value),
+                        Failed => {
+                            let choice_res =
+                                slice_eq(input, state, pos, "\r");
+                            match choice_res {
+                                Matched(pos, value) => Matched(pos, value),
+                                Failed => {
+                                    let choice_res =
+                                        slice_eq(input, state, pos,
+                                                 "\u{2028}");
+                                    match choice_res {
+                                        Matched(pos, value) =>
+                                        Matched(pos, value),
+                                        Failed =>
+                                        slice_eq(input, state, pos,
+                                                 "\u{2029}"),
+                                    }
                                 }
                             }
                         }
@@ -4699,29 +10632,85 @@ fn parse_eol<'input>(input: &'input str, state: &mut ParseState, pos: usize)
 }
 fn parse_eolChar<'input>(input: &'input str, state: &mut ParseState,
                          pos: usize) -> RuleResult<()> {
-    if input.len() > pos {
-        let (ch, next) = char_range_at(input, pos);
-        match ch {
-            '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched(next, ()),
-            _ => state.mark_failure(pos, "[\n\r\u{2028}\u{2029}]"),
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "eolChar" , line , col);
+        let mut __peg_closure = move || {
+            if input.len() > pos {
+                let (ch, next) = char_range_at(input, pos);
+                match ch {
+                    '\n' | '\r' | '\u{2028}' | '\u{2029}' =>
+                    Matched(next, ()),
+                    _ => state.mark_failure(pos, "[\n\r\u{2028}\u{2029}]"),
+                }
+            } else { state.mark_failure(pos, "[\n\r\u{2028}\u{2029}]") } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "eolChar" , line
+                     , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "eolChar" , line , col),
         }
-    } else { state.mark_failure(pos, "[\n\r\u{2028}\u{2029}]") }
+        __peg_result
+    } else {
+        if input.len() > pos {
+            let (ch, next) = char_range_at(input, pos);
+            match ch {
+                '\n' | '\r' | '\u{2028}' | '\u{2029}' => Matched(next, ()),
+                _ => state.mark_failure(pos, "[\n\r\u{2028}\u{2029}]"),
+            }
+        } else { state.mark_failure(pos, "[\n\r\u{2028}\u{2029}]") }
+    }
 }
 fn parse_whitespace<'input>(input: &'input str, state: &mut ParseState,
                             pos: usize) -> RuleResult<()> {
-    if input.len() > pos {
-        let (ch, next) = char_range_at(input, pos);
-        match ch {
-            ' ' | '\t' | '\u{a0}' | '\u{feff}' | '\u{1680}' | '\u{180e}' |
-            '\u{2000}' ...'\u{200a}' | '\u{202f}' | '\u{205f}' | '\u{3000}' =>
-            Matched(next, ()),
-            _ =>
-            state.mark_failure(pos,
-                               "[ \t\u{a0}\u{feff}\u{1680}\u{180e}\u{2000}-\u{200a}\u{202f}\u{205f}\u{3000}]"),
+    if cfg!(feature = "peg_trace") {
+        let (line, col) = pos_to_line(input, pos);
+        println!("[PEG_TRACE] Attempting to match rule {} at {}:{}" ,
+                 "whitespace" , line , col);
+        let mut __peg_closure = move || {
+            if input.len() > pos {
+                let (ch, next) = char_range_at(input, pos);
+                match ch {
+                    ' ' | '\t' | '\u{a0}' | '\u{feff}' | '\u{1680}' |
+                    '\u{180e}' | '\u{2000}' ...'\u{200a}' | '\u{202f}' |
+                    '\u{205f}' | '\u{3000}' => Matched(next, ()),
+                    _ =>
+                    state.mark_failure(pos,
+                                       "[ \t\u{a0}\u{feff}\u{1680}\u{180e}\u{2000}-\u{200a}\u{202f}\u{205f}\u{3000}]"),
+                }
+            } else {
+                state.mark_failure(pos,
+                                   "[ \t\u{a0}\u{feff}\u{1680}\u{180e}\u{2000}-\u{200a}\u{202f}\u{205f}\u{3000}]")
+            } };
+        let __peg_result = __peg_closure();
+        match __peg_result {
+            Matched(_, _) =>
+            println!("[PEG_TRACE] Matched rule {} at {}:{}" , "whitespace" ,
+                     line , col),
+            Failed =>
+            println!("[PEG_TRACE] Failed to match rule {} at {}:{}" ,
+                     "whitespace" , line , col),
         }
+        __peg_result
     } else {
-        state.mark_failure(pos,
-                           "[ \t\u{a0}\u{feff}\u{1680}\u{180e}\u{2000}-\u{200a}\u{202f}\u{205f}\u{3000}]")
+        if input.len() > pos {
+            let (ch, next) = char_range_at(input, pos);
+            match ch {
+                ' ' | '\t' | '\u{a0}' | '\u{feff}' | '\u{1680}' | '\u{180e}' |
+                '\u{2000}' ...'\u{200a}' | '\u{202f}' | '\u{205f}' |
+                '\u{3000}' => Matched(next, ()),
+                _ =>
+                state.mark_failure(pos,
+                                   "[ \t\u{a0}\u{feff}\u{1680}\u{180e}\u{2000}-\u{200a}\u{202f}\u{205f}\u{3000}]"),
+            }
+        } else {
+            state.mark_failure(pos,
+                               "[ \t\u{a0}\u{feff}\u{1680}\u{180e}\u{2000}-\u{200a}\u{202f}\u{205f}\u{3000}]")
+        }
     }
 }
 pub fn grammar<'input>(input: &'input str) -> ParseResult<Grammar> {
diff --git a/src/translate.rs b/src/translate.rs
index 066771a..3c83044 100644
--- a/src/translate.rs
+++ b/src/translate.rs
@@ -245,12 +245,27 @@ pub fn header_items(ctxt: &rustast::ExtCtxt) -> Vec<rustast::P<rustast::Item>> {
 
 
 fn compile_rule(ctxt: &rustast::ExtCtxt, rule: &Rule) -> rustast::P<rustast::Item> {
+	let ref rule_name = rule.name;
 	let name = rustast::str_to_ident(&format!("parse_{}", rule.name));
 	let ret = rustast::parse_type(&rule.ret_type);
 	let body = compile_expr(ctxt, &*rule.expr, (&rule.ret_type as &str) != "()");
 	(quote_item!(ctxt,
 		fn $name<'input>(input: &'input str, state: &mut ParseState, pos: usize) -> RuleResult<$ret> {
-			$body
+			if cfg!(feature = "peg_trace") {
+				let (line, col) = pos_to_line(input, pos);
+				println!("[PEG_TRACE] Attempting to match rule {} at {}:{}", $rule_name, line, col);
+				let mut __peg_closure = move || {
+					$body
+				};
+				let __peg_result = __peg_closure();
+				match __peg_result {
+					Matched(_, _) => println!("[PEG_TRACE] Matched rule {} at {}:{}", $rule_name, line, col),
+					Failed => println!("[PEG_TRACE] Failed to match rule {} at {}:{}", $rule_name, line, col)
+				}
+				__peg_result
+			} else {
+				$body
+			}
 		}
 	)).unwrap()
 }


Test patch: