note: pub mod ntcc {
    #![allow(dead_code)]
    #![allow(unused_parens, unused_variables, unused_mut, unused_imports)]
    extern crate oak_runtime;
    use oak_runtime::parse_state::MergeSuccess;
    #[inline]
    fn parse_sequence_in_rule_dotdot_12<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_dotdot_12(stream)
    }
    #[inline]
    pub fn parse_tell<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_tell(stream)
    }
    #[inline]
    pub fn recognize_par_kw<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_par_kw_37(stream)
    }
    #[inline]
    fn recognize_star_in_rule_integer_75<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        {
            let mut state =
                oak_runtime::ParseState::stateless(stream.clone());
            let mut next =
                recognize_class_char_in_rule_integer_74(state.stream());
            while state.soft_merge(next) {
                next =
                    recognize_class_char_in_rule_integer_74(state.stream());
            }
            {
                if state.stream_eq(&stream) {
                    state.to_error()
                } else { state }
            }
        }
    }
    #[inline]
    pub fn parse_min_bound<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_min_bound(stream)
    }
    #[inline]
    pub fn recognize_oror<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_oror_61(stream)
    }
    #[inline]
    pub fn parse_expression2<S>(mut stream: S)
     -> oak_runtime::ParseState<S, Vec<()>> where S: oak_runtime::CharStream {
        parse_choice_in_rule_expression2_28(stream)
    }
    #[inline]
    pub fn recognize_var_decl<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_var_decl_71(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_sum_body_51<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_or(stream).and_then(|success| { let stream = success.stream;
                                      recognize_when(stream) })
    }
    #[inline]
    pub fn parse_right_arrow<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_right_arrow(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_oror_61<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_oror_60(stream).and_then(|success| {
                                                               let stream =
                                                                   success.stream;
                                                               recognize_spacing(stream)
                                                           })
    }
    #[inline]
    fn recognize_sequence_in_rule_when_88<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_when_kw(stream).and_then(|success| {
                                           let stream = success.stream;
                                           recognize_entails(stream).and_then(|success|
                                                                                  {
                                                                              let stream =
                                                                                  success.stream;
                                                                              recognize_right_arrow(stream).and_then(|success|
                                                                                                                         {
                                                                                                                     let stream =
                                                                                                                         success.stream;
                                                                                                                     recognize_expression(stream)
                                                                                                                 })
                                                                          })
                                       })
    }
    #[inline]
    pub fn parse_end_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_end_kw(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_gt_64<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_gt_63(stream).and_then(|success| {
                                                             let stream =
                                                                 success.stream;
                                                             recognize_spacing(stream)
                                                         })
    }
    #[inline]
    pub fn recognize_async_kw<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_async_kw_39(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_entailed_by_20<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_entailed_by_20(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_par_kw_37<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_par_kw_36(stream).and_then(|success| {
                                                                 let stream =
                                                                     success.stream;
                                                                 recognize_spacing(stream)
                                                             })
    }
    #[inline]
    fn parse_sequence_in_rule_dom_kw_41<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_dom_kw_41(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_le_85<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_le_84(stream).and_then(|success| {
                                                             let stream =
                                                                 success.stream;
                                                             recognize_spacing(stream)
                                                         })
    }
    #[inline]
    fn recognize_sequence_in_rule_range_23<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_range_bound(stream).and_then(|success| {
                                               let stream = success.stream;
                                               recognize_dotdot(stream).and_then(|success|
                                                                                     {
                                                                                 let stream =
                                                                                     success.stream;
                                                                                 recognize_range_bound(stream)
                                                                             })
                                           })
    }
    #[inline]
    fn recognize_str_literal_in_rule_entail_55<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "|=")
    }
    #[inline]
    fn recognize_sequence_in_rule_let_in_50<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_let_kw(stream).and_then(|success| {
                                          let stream = success.stream;
                                          recognize_var_decl(stream).and_then(|success|
                                                                                  {
                                                                              let stream =
                                                                                  success.stream;
                                                                              recognize_in_kw(stream).and_then(|success|
                                                                                                                   {
                                                                                                               let stream =
                                                                                                                   success.stream;
                                                                                                               recognize_expression(stream)
                                                                                                           })
                                                                          })
                                      })
    }
    #[inline]
    fn recognize_str_literal_in_rule_max_kw_21<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "max")
    }
    #[inline]
    pub fn parse_next<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_next(stream)
    }
    #[inline]
    pub fn recognize_when<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_when_88(stream)
    }
    #[inline]
    pub fn recognize_range<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_range_23(stream)
    }
    #[inline]
    pub fn parse_var_ident<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_var_ident(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_next_81<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_next_kw(stream).and_then(|success| {
                                           let stream = success.stream;
                                           recognize_expression(stream) })
    }
    #[inline]
    fn recognize_sequence_in_rule_in_kw_53<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_in_kw_52(stream).and_then(|success| {
                                                                let stream =
                                                                    success.stream;
                                                                recognize_spacing(stream)
                                                            })
    }
    #[inline]
    fn parse_sequence_in_rule_par_27<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_par_27(stream)
    }
    #[inline]
    pub fn recognize_end_kw<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_end_kw_59(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_par_body_54<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_par_body_54(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_dotdot_12<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_dotdot_11(stream).and_then(|success| {
                                                                 let stream =
                                                                     success.stream;
                                                                 recognize_spacing(stream)
                                                             })
    }
    #[inline]
    pub fn parse_async<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_async(stream)
    }
    #[inline]
    pub fn recognize_eq_bind<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_eq_bind_94(stream)
    }
    #[inline]
    pub fn parse_max_bound<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_max_bound(stream)
    }
    #[inline]
    pub fn recognize_entailed_by<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_entailed_by_20(stream)
    }
    #[inline]
    pub fn recognize_max_kw<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_max_kw_22(stream)
    }
    #[inline]
    pub fn recognize_expression<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_expression2(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_lt_34<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "<")
    }
    #[inline]
    fn parse_choice_in_rule_constraint_operand_4<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_choice_in_rule_constraint_operand_4(stream)
    }
    #[inline]
    fn recognize_optional_in_rule_sum_65<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::optional_recognizer(recognize_or(stream.clone()), stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_when_kw_1<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_when_kw_0(stream).and_then(|success| {
                                                                 let stream =
                                                                     success.stream;
                                                                 recognize_spacing(stream)
                                                             })
    }
    #[inline]
    fn recognize_choice_in_rule_constraint_operand_4<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_integer(stream.clone()).or_else_merge(||
                                                            recognize_var_ident(stream))
    }
    #[inline]
    fn recognize_sequence_in_rule_sum_68<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_pick_kw(stream).and_then(|success| {
                                           let stream = success.stream;
                                           recognize_optional_in_rule_sum_65(stream).and_then(|success|
                                                                                                  {
                                                                                              let stream =
                                                                                                  success.stream;
                                                                                              recognize_when(stream).and_then(|success|
                                                                                                                                  {
                                                                                                                              let stream =
                                                                                                                                  success.stream;
                                                                                                                              recognize_star_in_rule_sum_66(stream).and_then(|success|
                                                                                                                                                                                 {
                                                                                                                                                                             let stream =
                                                                                                                                                                                 success.stream;
                                                                                                                                                                             recognize_optional_in_rule_sum_67(stream)
                                                                                                                                                                         })
                                                                                                                          })
                                                                                          })
                                       })
    }
    #[inline]
    pub fn recognize_constraint<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_constraint_70(stream)
    }
    #[inline]
    pub fn recognize_unless_kw<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_unless_kw_78(stream)
    }
    #[inline]
    pub fn parse_entail<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_entail(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_eq_16<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_eq_15(stream).and_then(|success| {
                                                             let stream =
                                                                 success.stream;
                                                             recognize_spacing(stream)
                                                         })
    }
    #[inline]
    fn parse_sequence_in_rule_min_bound_46<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_min_bound_46(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_or_72<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "|")
    }
    #[inline]
    pub fn recognize_par_body<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_par_body_54(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_neq_49<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_neq_48(stream).and_then(|success| {
                                                              let stream =
                                                                  success.stream;
                                                              recognize_spacing(stream)
                                                          })
    }
    #[inline]
    fn recognize_sequence_in_rule_tell_5<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_store_kw(stream).and_then(|success| {
                                            let stream = success.stream;
                                            recognize_left_arrow(stream).and_then(|success|
                                                                                      {
                                                                                  let stream =
                                                                                      success.stream;
                                                                                  recognize_constraint(stream)
                                                                              })
                                        })
    }
    #[inline]
    fn recognize_star_in_rule_par_25<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        {
            let mut state =
                oak_runtime::ParseState::stateless(stream.clone());
            let mut next = recognize_par_body(state.stream());
            while state.soft_merge(next) {
                next = recognize_par_body(state.stream());
            }
            state
        }
    }
    #[inline]
    fn recognize_sequence_in_rule_ge_96<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_ge_95(stream).and_then(|success| {
                                                             let stream =
                                                                 success.stream;
                                                             recognize_spacing(stream)
                                                         })
    }
    #[inline]
    fn parse_sequence_in_rule_entails_69<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_entails_69(stream)
    }
    #[inline]
    fn recognize_class_char_in_rule_spacing_89<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        {
            let past = stream.clone();
            match stream.next() {
                Some(current) if
                (current >= ' ' && current <= ' ') ||
                    (current >= '\n' && current <= '\n') ||
                    (current >= '\t' && current <= '\t') => {
                    oak_runtime::ParseState::stateless(stream)
                }
                _ => { oak_runtime::ParseState::error(past, "[\" \n\t\"]") }
            }
        }
    }
    #[inline]
    fn parse_sequence_in_rule_right_arrow_92<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_right_arrow_92(stream)
    }
    #[inline]
    fn recognize_not_predicate_in_rule_var_ident_7<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::not_predicate(recognize_class_char_in_rule_var_ident_6(stream.clone()),
                                   stream)
    }
    #[inline]
    pub fn parse_domain<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_domain(stream)
    }
    #[inline]
    pub fn parse_skip_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_skip_kw(stream)
    }
    #[inline]
    pub fn parse_range<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_range(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_left_arrow_14<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_left_arrow_14(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_let_kw_82<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "let")
    }
    #[inline]
    fn parse_sequence_in_rule_eq_bind_94<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_eq_bind_94(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_when_kw_0<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "when")
    }
    #[inline]
    fn parse_sequence_in_rule_par_kw_37<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_par_kw_37(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_skip_kw_32<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "skip")
    }
    #[inline]
    pub fn parse_in_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_in_kw(stream)
    }
    #[inline]
    pub fn parse_constraint_operand<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_constraint_operand(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_unless_47<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_unless_47(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_neq_48<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "<>")
    }
    #[inline]
    fn parse_sequence_in_rule_gt_64<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_gt_64(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_entail_56<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_entail_56(stream)
    }
    #[inline]
    pub fn parse_left_arrow<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_left_arrow(stream)
    }
    #[inline]
    pub fn parse_spacing<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_spacing(stream)
    }
    #[inline]
    pub fn recognize_le<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_le_85(stream)
    }
    #[inline]
    pub fn parse_ntcc<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_ntcc(stream)
    }
    #[inline]
    pub fn parse_neq<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
     S: oak_runtime::CharStream {
        recognize_neq(stream)
    }
    #[inline]
    pub fn parse_comparison<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_comparison(stream)
    }
    #[inline]
    pub fn parse_unless<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_unless(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_sum_body_51<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_sum_body_51(stream)
    }
    #[inline]
    fn parse_choice_in_rule_var_range_17<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_choice_in_rule_var_range_17(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_domain_31<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_domain_31(stream)
    }
    #[inline]
    pub fn parse_store_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_store_kw(stream)
    }
    #[inline]
    pub fn recognize_ge<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_ge_96(stream)
    }
    #[inline]
    fn recognize_choice_in_rule_comparison_18<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_le(stream.clone()).or_else_merge(||
                                                       recognize_neq(stream.clone()).or_else_merge(||
                                                                                                       recognize_lt(stream.clone()).or_else_merge(||
                                                                                                                                                      recognize_ge(stream.clone()).or_else_merge(||
                                                                                                                                                                                                     recognize_gt(stream.clone()).or_else_merge(||
                                                                                                                                                                                                                                                    recognize_eq(stream))))))
    }
    #[inline]
    pub fn parse_sum<S>(mut stream: S) -> oak_runtime::ParseState<S, Vec<()>>
     where S: oak_runtime::CharStream {
        parse_sequence_in_rule_sum_68(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_par_27<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_par_kw(stream).and_then(|success| {
                                          let stream = success.stream;
                                          recognize_optional_in_rule_par_24(stream).and_then(|success|
                                                                                                 {
                                                                                             let stream =
                                                                                                 success.stream;
                                                                                             recognize_expression(stream).and_then(|success|
                                                                                                                                       {
                                                                                                                                   let stream =
                                                                                                                                       success.stream;
                                                                                                                                   recognize_star_in_rule_par_25(stream).and_then(|success|
                                                                                                                                                                                      {
                                                                                                                                                                                  let stream =
                                                                                                                                                                                      success.stream;
                                                                                                                                                                                  recognize_optional_in_rule_par_26(stream)
                                                                                                                                                                              })
                                                                                                                               })
                                                                                         })
                                      })
    }
    #[inline]
    pub fn parse_rep<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
     S: oak_runtime::CharStream {
        recognize_rep(stream)
    }
    #[inline]
    pub fn recognize_var_range<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_choice_in_rule_var_range_17(stream)
    }
    #[inline]
    fn parse_choice_in_rule_comparison_18<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_choice_in_rule_comparison_18(stream)
    }
    #[inline]
    pub fn parse_eq<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
     S: oak_runtime::CharStream {
        recognize_eq(stream)
    }
    #[inline]
    pub fn recognize_unless<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_unless_47(stream)
    }
    #[inline]
    pub fn parse_var_decl<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_var_decl(stream)
    }
    #[inline]
    pub fn recognize_or<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_or_73(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_domain_31<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_dom_kw(stream).and_then(|success| {
                                          let stream = success.stream;
                                          recognize_var_ident(stream) })
    }
    #[inline]
    fn recognize_sequence_in_rule_store_kw_45<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_store_kw_44(stream).and_then(|success| {
                                                                   let stream =
                                                                       success.stream;
                                                                   recognize_spacing(stream)
                                                               })
    }
    #[inline]
    fn parse_sequence_in_rule_async_kw_39<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_async_kw_39(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_ge_95<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, ">=")
    }
    #[inline]
    fn parse_sequence_in_rule_when_kw_1<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_when_kw_1(stream)
    }
    #[inline]
    pub fn parse_var_range<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_var_range(stream)
    }
    #[inline]
    pub fn recognize_constraint_operand<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_choice_in_rule_constraint_operand_4(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_unless_47<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_unless_kw(stream).and_then(|success| {
                                             let stream = success.stream;
                                             recognize_entailed_by(stream).and_then(|success|
                                                                                        {
                                                                                    let stream =
                                                                                        success.stream;
                                                                                    recognize_next(stream)
                                                                                })
                                         })
    }
    #[inline]
    fn parse_optional_in_rule_sum_67<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_optional_in_rule_sum_67(stream)
    }
    #[inline]
    fn recognize_choice_in_rule_var_range_17<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_range(stream.clone()).or_else_merge(||
                                                          recognize_domain(stream))
    }
    #[inline]
    pub fn parse_integer<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_integer(stream)
    }
    #[inline]
    fn recognize_optional_in_rule_par_24<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::optional_recognizer(recognize_oror(stream.clone()),
                                         stream)
    }
    #[inline]
    pub fn recognize_gt<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_gt_64(stream)
    }
    #[inline]
    pub fn parse_dom_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_dom_kw(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_dotdot_11<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "..")
    }
    #[inline]
    pub fn parse_oror<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_oror(stream)
    }
    #[inline]
    pub fn parse_async_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_async_kw(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_var_ident_10<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_var_ident_10(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_le_84<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "<=")
    }
    #[inline]
    fn recognize_str_literal_in_rule_left_arrow_13<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "<-")
    }
    #[inline]
    fn recognize_class_char_in_rule_var_ident_6<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        {
            let past = stream.clone();
            match stream.next() {
                Some(current) if (current >= '0' && current <= '9') => {
                    oak_runtime::ParseState::stateless(stream)
                }
                _ => { oak_runtime::ParseState::error(past, "[\"0-9\"]") }
            }
        }
    }
    #[inline]
    fn recognize_sequence_in_rule_end_kw_59<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_end_kw_58(stream).and_then(|success| {
                                                                 let stream =
                                                                     success.stream;
                                                                 recognize_spacing(stream)
                                                             })
    }
    #[inline]
    fn recognize_str_literal_in_rule_min_kw_42<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "min")
    }
    #[inline]
    fn recognize_choice_in_rule_expression2_28<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sum(stream.clone()).or_else_merge(||
                                                        recognize_par(stream.clone()).or_else_merge(||
                                                                                                        recognize_tell(stream.clone()).or_else_merge(||
                                                                                                                                                         recognize_next(stream.clone()).or_else_merge(||
                                                                                                                                                                                                          recognize_async(stream.clone()).or_else_merge(||
                                                                                                                                                                                                                                                            recognize_rep(stream.clone()).or_else_merge(||
                                                                                                                                                                                                                                                                                                            recognize_unless(stream.clone()).or_else_merge(||
                                                                                                                                                                                                                                                                                                                                                               recognize_let_in(stream.clone()).or_else_merge(||
                                                                                                                                                                                                                                                                                                                                                                                                                  recognize_skip_kw(stream)))))))))
    }
    #[inline]
    fn recognize_sequence_in_rule_skip_kw_33<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_skip_kw_32(stream).and_then(|success| {
                                                                  let stream =
                                                                      success.stream;
                                                                  recognize_spacing(stream)
                                                              })
    }
    #[inline]
    pub fn recognize_dom_kw<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_dom_kw_41(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_constraint_70<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_constraint_operand(stream).and_then(|success| {
                                                      let stream =
                                                          success.stream;
                                                      recognize_comparison(stream).and_then(|success|
                                                                                                {
                                                                                            let stream =
                                                                                                success.stream;
                                                                                            recognize_constraint_operand(stream)
                                                                                        })
                                                  })
    }
    #[inline]
    pub fn parse_min_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_min_kw(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_par_body_54<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_oror(stream).and_then(|success| {
                                        let stream = success.stream;
                                        recognize_expression(stream) })
    }
    #[inline]
    fn recognize_sequence_in_rule_async_kw_39<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_async_kw_38(stream).and_then(|success| {
                                                                   let stream =
                                                                       success.stream;
                                                                   recognize_spacing(stream)
                                                               })
    }
    #[inline]
    fn parse_sequence_in_rule_integer_76<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_integer_76(stream)
    }
    #[inline]
    fn recognize_star_in_rule_sum_66<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        {
            let mut state =
                oak_runtime::ParseState::stateless(stream.clone());
            let mut next = recognize_sum_body(state.stream());
            while state.soft_merge(next) {
                next = recognize_sum_body(state.stream());
            }
            state
        }
    }
    #[inline]
    pub fn recognize_var_ident<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_var_ident_10(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_async_19<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_async_19(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_lt_35<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_lt_35(stream)
    }
    #[inline]
    pub fn parse_range_bound<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_range_bound(stream)
    }
    #[inline]
    pub fn recognize_comparison<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_choice_in_rule_comparison_18(stream)
    }
    #[inline]
    pub fn parse_gt<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
     S: oak_runtime::CharStream {
        recognize_gt(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_ntcc_2<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_spacing(stream).and_then(|success| {
                                           let stream = success.stream;
                                           recognize_expression(stream) })
    }
    #[inline]
    fn recognize_class_char_in_rule_var_ident_8<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        {
            let past = stream.clone();
            match stream.next() {
                Some(current) if
                (current >= 'a' && current <= 'z') ||
                    (current >= 'A' && current <= 'Z') ||
                    (current >= '0' && current <= '9') ||
                    (current >= '_' && current <= '_') => {
                    oak_runtime::ParseState::stateless(stream)
                }
                _ => {
                    oak_runtime::ParseState::error(past, "[\"a-zA-Z0-9_\"]")
                }
            }
        }
    }
    #[inline]
    fn parse_sequence_in_rule_pick_kw_80<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_pick_kw_80(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_in_kw_53<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_in_kw_53(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_store_kw_44<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "store")
    }
    #[inline]
    fn recognize_sequence_in_rule_right_arrow_92<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_right_arrow_91(stream).and_then(|success|
                                                                          {
                                                                      let stream =
                                                                          success.stream;
                                                                      recognize_spacing(stream)
                                                                  })
    }
    #[inline]
    fn parse_sequence_in_rule_min_kw_43<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_min_kw_43(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_rep_kw_29<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "rep")
    }
    #[inline]
    fn parse_sequence_in_rule_unless_kw_78<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_unless_kw_78(stream)
    }
    #[inline]
    fn recognize_choice_in_rule_range_bound_57<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_integer(stream.clone()).or_else_merge(||
                                                            recognize_min_bound(stream.clone()).or_else_merge(||
                                                                                                                  recognize_max_bound(stream)))
    }
    #[inline]
    fn recognize_sequence_in_rule_next_kw_87<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_next_kw_86(stream).and_then(|success| {
                                                                  let stream =
                                                                      success.stream;
                                                                  recognize_spacing(stream)
                                                              })
    }
    #[inline]
    pub fn recognize_next_kw<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_next_kw_87(stream)
    }
    #[inline]
    fn recognize_star_in_rule_spacing_90<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        {
            let mut state =
                oak_runtime::ParseState::stateless(stream.clone());
            let mut next =
                recognize_class_char_in_rule_spacing_89(state.stream());
            while state.soft_merge(next) {
                next =
                    recognize_class_char_in_rule_spacing_89(state.stream());
            }
            state
        }
    }
    #[inline]
    pub fn recognize_sum<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_sum_68(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_end_kw_58<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "end")
    }
    #[inline]
    fn recognize_sequence_in_rule_or_73<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_or_72(stream).and_then(|success| {
                                                             let stream =
                                                                 success.stream;
                                                             recognize_spacing(stream)
                                                         })
    }
    #[inline]
    fn recognize_sequence_in_rule_dom_kw_41<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_dom_kw_40(stream).and_then(|success| {
                                                                 let stream =
                                                                     success.stream;
                                                                 recognize_spacing(stream)
                                                             })
    }
    #[inline]
    pub fn parse_lt<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
     S: oak_runtime::CharStream {
        recognize_lt(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_max_kw_22<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_max_kw_21(stream).and_then(|success| {
                                                                 let stream =
                                                                     success.stream;
                                                                 recognize_spacing(stream)
                                                             })
    }
    #[inline]
    fn parse_sequence_in_rule_ge_96<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_ge_96(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_left_arrow_14<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_left_arrow_13(stream).and_then(|success|
                                                                         {
                                                                     let stream =
                                                                         success.stream;
                                                                     recognize_spacing(stream)
                                                                 })
    }
    #[inline]
    fn parse_sequence_in_rule_tell_5<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_tell_5(stream)
    }
    #[inline]
    pub fn recognize_async<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_async_19(stream)
    }
    #[inline]
    pub fn parse_dotdot<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_dotdot(stream)
    }
    #[inline]
    pub fn recognize_left_arrow<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_left_arrow_14(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_next_kw_86<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "next")
    }
    #[inline]
    fn recognize_sequence_in_rule_eq_bind_94<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_eq_bind_93(stream).and_then(|success| {
                                                                  let stream =
                                                                      success.stream;
                                                                  recognize_spacing(stream)
                                                              })
    }
    #[inline]
    pub fn parse_entails<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_entails(stream)
    }
    #[inline]
    pub fn parse_sum_body<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sum_body(stream)
    }
    #[inline]
    pub fn recognize_integer<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_integer_76(stream)
    }
    #[inline]
    pub fn parse_constraint<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_constraint(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_var_decl_71<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_var_decl_71(stream)
    }
    #[inline]
    pub fn recognize_domain<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_domain_31(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_neq_49<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_neq_49(stream)
    }
    #[inline]
    pub fn parse_le<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
     S: oak_runtime::CharStream {
        recognize_le(stream)
    }
    #[inline]
    pub fn parse_next_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_next_kw(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_next_81<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_next_81(stream)
    }
    #[inline]
    pub fn recognize_sum_body<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_sum_body_51(stream)
    }
    #[inline]
    fn parse_star_in_rule_spacing_90<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_star_in_rule_spacing_90(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_gt_63<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, ">")
    }
    #[inline]
    fn recognize_sequence_in_rule_entail_56<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_entail_55(stream).and_then(|success| {
                                                                 let stream =
                                                                     success.stream;
                                                                 recognize_spacing(stream)
                                                             })
    }
    #[inline]
    fn recognize_sequence_in_rule_min_bound_46<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_min_kw(stream).and_then(|success| {
                                          let stream = success.stream;
                                          recognize_var_ident(stream) })
    }
    #[inline]
    pub fn parse_par<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
     S: oak_runtime::CharStream {
        recognize_par(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_rep_kw_30<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_rep_kw_30(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_async_19<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_async_kw(stream).and_then(|success| {
                                            let stream = success.stream;
                                            recognize_expression(stream) })
    }
    #[inline]
    pub fn parse_or<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
     S: oak_runtime::CharStream {
        recognize_or(stream)
    }
    #[inline]
    pub fn recognize_min_bound<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_min_bound_46(stream)
    }
    #[inline]
    pub fn recognize_neq<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_neq_49(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_max_bound_62<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_max_kw(stream).and_then(|success| {
                                          let stream = success.stream;
                                          recognize_var_ident(stream) })
    }
    #[inline]
    pub fn parse_expression<S>(mut stream: S)
     -> oak_runtime::ParseState<S, Vec<()>> where S: oak_runtime::CharStream {
        parse_expression2(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_let_kw_83<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_let_kw_83(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_entailed_by_20<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_constraint(stream).and_then(|success| {
                                              let stream = success.stream;
                                              recognize_entail(stream).and_then(|success|
                                                                                    {
                                                                                let stream =
                                                                                    success.stream;
                                                                                recognize_store_kw(stream)
                                                                            })
                                          })
    }
    #[inline]
    fn parse_sequence_in_rule_skip_kw_33<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_skip_kw_33(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_oror_61<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_oror_61(stream)
    }
    #[inline]
    pub fn recognize_when_kw<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_when_kw_1(stream)
    }
    #[inline]
    pub fn parse_unless_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_unless_kw(stream)
    }
    #[inline]
    pub fn recognize_let_in<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_let_in_50(stream)
    }
    #[inline]
    pub fn recognize_entail<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_entail_56(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_end_kw_59<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_end_kw_59(stream)
    }
    #[inline]
    pub fn recognize_tell<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_tell_5(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_var_decl_71<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_var_ident(stream).and_then(|success| {
                                             let stream = success.stream;
                                             recognize_eq_bind(stream).and_then(|success|
                                                                                    {
                                                                                let stream =
                                                                                    success.stream;
                                                                                recognize_var_range(stream)
                                                                            })
                                         })
    }
    #[inline]
    fn parse_sequence_in_rule_next_kw_87<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_next_kw_87(stream)
    }
    #[inline]
    pub fn recognize_right_arrow<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_right_arrow_92(stream)
    }
    #[inline]
    fn recognize_star_in_rule_var_ident_9<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        {
            let mut state =
                oak_runtime::ParseState::stateless(stream.clone());
            let mut next =
                recognize_class_char_in_rule_var_ident_8(state.stream());
            while state.soft_merge(next) {
                next =
                    recognize_class_char_in_rule_var_ident_8(state.stream());
            }
            {
                if state.stream_eq(&stream) {
                    state.to_error()
                } else { state }
            }
        }
    }
    #[inline]
    pub fn recognize_entails<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_entails_69(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_unless_kw_78<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_unless_kw_77(stream).and_then(|success|
                                                                        {
                                                                    let stream =
                                                                        success.stream;
                                                                    recognize_spacing(stream)
                                                                })
    }
    #[inline]
    pub fn recognize_range_bound<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_choice_in_rule_range_bound_57(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_rep_3<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_rep_3(stream)
    }
    #[inline]
    pub fn recognize_lt<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_lt_35(stream)
    }
    #[inline]
    pub fn parse_rep_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_rep_kw(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_let_kw_83<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_let_kw_82(stream).and_then(|success| {
                                                                 let stream =
                                                                     success.stream;
                                                                 recognize_spacing(stream)
                                                             })
    }
    #[inline]
    fn parse_choice_in_rule_range_bound_57<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_choice_in_rule_range_bound_57(stream)
    }
    #[inline]
    pub fn parse_let_in<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_let_in(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_max_kw_22<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_max_kw_22(stream)
    }
    #[inline]
    pub fn recognize_rep<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_rep_3(stream)
    }
    #[inline]
    fn recognize_class_char_in_rule_integer_74<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        {
            let past = stream.clone();
            match stream.next() {
                Some(current) if (current >= '0' && current <= '9') => {
                    oak_runtime::ParseState::stateless(stream)
                }
                _ => { oak_runtime::ParseState::error(past, "[\"0-9\"]") }
            }
        }
    }
    #[inline]
    fn recognize_str_literal_in_rule_right_arrow_91<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "->")
    }
    #[inline]
    fn recognize_str_literal_in_rule_eq_15<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "==")
    }
    #[inline]
    pub fn parse_entailed_by<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_entailed_by(stream)
    }
    #[inline]
    pub fn recognize_min_kw<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_min_kw_43(stream)
    }
    #[inline]
    pub fn recognize_dotdot<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_dotdot_12(stream)
    }
    #[inline]
    pub fn parse_par_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_par_kw(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_unless_kw_77<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "unless")
    }
    #[inline]
    fn recognize_sequence_in_rule_lt_35<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_lt_34(stream).and_then(|success| {
                                                             let stream =
                                                                 success.stream;
                                                             recognize_spacing(stream)
                                                         })
    }
    #[inline]
    fn parse_sequence_in_rule_max_bound_62<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_max_bound_62(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_or_73<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_or_73(stream)
    }
    #[inline]
    pub fn recognize_let_kw<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_let_kw_83(stream)
    }
    #[inline]
    pub fn recognize_eq<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_eq_16(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_eq_bind_93<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "=")
    }
    #[inline]
    pub fn parse_ge<S>(mut stream: S) -> oak_runtime::ParseState<S, ()> where
     S: oak_runtime::CharStream {
        recognize_ge(stream)
    }
    #[inline]
    pub fn recognize_spacing<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_star_in_rule_spacing_90(stream)
    }
    #[inline]
    pub fn parse_pick_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_pick_kw(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_dom_kw_40<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "dom")
    }
    #[inline]
    pub fn parse_par_body<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_par_body(stream)
    }
    #[inline]
    fn parse_choice_in_rule_expression2_28<S>(mut stream: S)
     -> oak_runtime::ParseState<S, Vec<()>> where S: oak_runtime::CharStream {
        parse_sum(stream.clone()).or_else_merge(||
                                                    parse_par(stream.clone()).or_else_merge(||
                                                                                                parse_tell(stream.clone()).or_else_merge(||
                                                                                                                                             parse_next(stream.clone()).or_else_merge(||
                                                                                                                                                                                          parse_async(stream.clone()).or_else_merge(||
                                                                                                                                                                                                                                        parse_rep(stream.clone()).or_else_merge(||
                                                                                                                                                                                                                                                                                    parse_unless(stream.clone()).or_else_merge(||
                                                                                                                                                                                                                                                                                                                                   parse_let_in(stream.clone()).or_else_merge(||
                                                                                                                                                                                                                                                                                                                                                                                  parse_skip_kw(stream)))))))))
    }
    #[inline]
    fn parse_sequence_in_rule_eq_16<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_eq_16(stream)
    }
    #[inline]
    pub fn recognize_ntcc<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_ntcc_2(stream)
    }
    #[inline]
    pub fn recognize_in_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_in_kw_53(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_min_kw_43<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_min_kw_42(stream).and_then(|success| {
                                                                 let stream =
                                                                     success.stream;
                                                                 recognize_spacing(stream)
                                                             })
    }
    #[inline]
    pub fn parse_let_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_let_kw(stream)
    }
    #[inline]
    pub fn recognize_skip_kw<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_skip_kw_33(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_le_85<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_le_85(stream)
    }
    #[inline]
    pub fn parse_when<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_when(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_async_kw_38<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "async")
    }
    #[inline]
    fn parse_sequence_in_rule_range_23<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_range_23(stream)
    }
    #[inline]
    fn recognize_optional_in_rule_sum_67<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::optional_recognizer(recognize_end_kw(stream.clone()),
                                         stream)
    }
    #[inline]
    fn parse_sequence_in_rule_store_kw_45<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_store_kw_45(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_rep_3<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_rep_kw(stream).and_then(|success| {
                                          let stream = success.stream;
                                          recognize_expression(stream) })
    }
    #[inline]
    fn recognize_str_literal_in_rule_pick_kw_79<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "pick")
    }
    #[inline]
    fn parse_star_in_rule_sum_66<S>(mut stream: S)
     -> oak_runtime::ParseState<S, Vec<()>> where S: oak_runtime::CharStream {
        {
            let mut state =
                oak_runtime::ParseState::success(stream.clone(), vec!());
            let mut next = parse_sum_body(state.stream());
            while state.soft_merge(next) {
                next = parse_sum_body(state.stream());
            }
            state
        }
    }
    #[inline]
    fn recognize_sequence_in_rule_pick_kw_80<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_pick_kw_79(stream).and_then(|success| {
                                                                  let stream =
                                                                      success.stream;
                                                                  recognize_spacing(stream)
                                                              })
    }
    #[inline]
    pub fn recognize_max_bound<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_max_bound_62(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_in_kw_52<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "in")
    }
    #[inline]
    fn parse_sequence_in_rule_ntcc_2<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_ntcc_2(stream)
    }
    #[inline]
    fn parse_optional_in_rule_sum_65<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_optional_in_rule_sum_65(stream)
    }
    #[inline]
    fn recognize_optional_in_rule_par_26<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::optional_recognizer(recognize_end_kw(stream.clone()),
                                         stream)
    }
    #[inline]
    pub fn recognize_rep_kw<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_rep_kw_30(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_oror_60<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "||")
    }
    #[inline]
    pub fn recognize_expression2<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_choice_in_rule_expression2_28(stream)
    }
    #[inline]
    pub fn parse_max_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_max_kw(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_constraint_70<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_constraint_70(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_let_in_50<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_let_in_50(stream)
    }
    #[inline]
    fn parse_sequence_in_rule_when_88<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_when_88(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_entails_69<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_store_kw(stream).and_then(|success| {
                                            let stream = success.stream;
                                            recognize_entail(stream).and_then(|success|
                                                                                  {
                                                                              let stream =
                                                                                  success.stream;
                                                                              recognize_constraint(stream)
                                                                          })
                                        })
    }
    #[inline]
    pub fn parse_eq_bind<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_eq_bind(stream)
    }
    #[inline]
    pub fn recognize_pick_kw<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_pick_kw_80(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_var_ident_10<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_not_predicate_in_rule_var_ident_7(stream).and_then(|success|
                                                                         {
                                                                     let stream =
                                                                         success.stream;
                                                                     recognize_star_in_rule_var_ident_9(stream).and_then(|success|
                                                                                                                             {
                                                                                                                         let stream =
                                                                                                                             success.stream;
                                                                                                                         recognize_spacing(stream)
                                                                                                                     })
                                                                 })
    }
    #[inline]
    fn parse_sequence_in_rule_sum_68<S>(mut stream: S)
     -> oak_runtime::ParseState<S, Vec<()>> where S: oak_runtime::CharStream {
        parse_pick_kw(stream).and_then(move |state4| {
                                       let stream = state4.stream.clone();
                                       parse_optional_in_rule_sum_65(stream).and_then(move
                                                                                          |state3|
                                                                                          {
                                                                                      let stream =
                                                                                          state3.stream.clone();
                                                                                      parse_when(stream).and_then(move
                                                                                                                      |state2|
                                                                                                                      {
                                                                                                                  let stream =
                                                                                                                      state2.stream.clone();
                                                                                                                  parse_star_in_rule_sum_66(stream).and_then(move
                                                                                                                                                                 |state1|
                                                                                                                                                                 {
                                                                                                                                                             let stream =
                                                                                                                                                                 state1.stream.clone();
                                                                                                                                                             parse_optional_in_rule_sum_67(stream).and_then(move
                                                                                                                                                                                                                |state0|
                                                                                                                                                                                                                {
                                                                                                                                                                                                            let stream =
                                                                                                                                                                                                                state0.stream.clone();
                                                                                                                                                                                                            oak_runtime::ParseState::success(stream,
                                                                                                                                                                                                                                             state1.data)
                                                                                                                                                                                                        })
                                                                                                                                                         })
                                                                                                              })
                                                                                  })
                                   })
    }
    #[inline]
    pub fn parse_when_kw<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_when_kw(stream)
    }
    #[inline]
    fn recognize_sequence_in_rule_integer_76<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_star_in_rule_integer_75(stream).and_then(|success| {
                                                           let stream =
                                                               success.stream;
                                                           recognize_spacing(stream)
                                                       })
    }
    #[inline]
    fn recognize_sequence_in_rule_rep_kw_30<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_str_literal_in_rule_rep_kw_29(stream).and_then(|success| {
                                                                 let stream =
                                                                     success.stream;
                                                                 recognize_spacing(stream)
                                                             })
    }
    #[inline]
    pub fn recognize_store_kw<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_store_kw_45(stream)
    }
    #[inline]
    fn recognize_str_literal_in_rule_par_kw_36<S>(mut stream: S)
     -> oak_runtime::ParseState<S, ()> where S: oak_runtime::CharStream {
        oak_runtime::recognize_match_literal(stream, "par")
    }
    #[inline]
    pub fn recognize_par<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_par_27(stream)
    }
    #[inline]
    pub fn recognize_next<S>(mut stream: S) -> oak_runtime::ParseState<S, ()>
     where S: oak_runtime::CharStream {
        recognize_sequence_in_rule_next_81(stream)
    }
}
tests/testoak.rs:1:1: 137:2 error: mismatched types:
 expected `oak_runtime::parse_state::ParseState<S, collections::vec::Vec<()>>`,
    found `oak_runtime::parse_state::ParseState<S, ()>`
(expected struct `collections::vec::Vec`,
    found ()) [E0308]
(internal compiler error: unprintable span)
tests/testoak.rs:15:1: 320:1 note: in expansion of grammar!
tests/grammars/ntcc.rs:18:1: 137:2 note: expansion site
tests/testoak.rs:1:1: 137:2 help: run `rustc --explain E0308` to see a detailed explanation
error: aborting due to previous error
Could not compile `oak`.

To learn more, run the command again with --verbose.
