m2_syn/gen/
tokens.rs

1// @generated by `cargo run -p m2-syn-macros --bin generate`; do not edit.
2
3#[doc(hidden)]
4mod __m2_syn_delimiters {
5    use ::m2_syn::{
6        DelimiterKind, DelimiterToken, Parse, ParseStream, PrettyNode, PrettyTree, Span, Spanned,
7        ToTokens, TokenParseError, TokenStream, parse_delimiter,
8    };
9    #[derive(Debug, Clone, Copy, PartialEq, Eq, Spanned)]
10    pub struct _EmptyDelimiter {
11        span: Span,
12    }
13    #[doc(hidden)]
14    #[allow(non_snake_case)]
15    pub fn _EmptyDelimiter<S: Spanned>(span: S) -> _EmptyDelimiter {
16        <_EmptyDelimiter as DelimiterToken>::new(span.span())
17    }
18    impl DelimiterToken for _EmptyDelimiter {
19        const KIND: DelimiterKind = DelimiterKind::Empty;
20        fn new(span: Span) -> Self {
21            Self { span }
22        }
23    }
24    impl Parse for _EmptyDelimiter {
25        fn parse(input: &mut ParseStream) -> Result<Self, TokenParseError> {
26            parse_delimiter(input)
27        }
28    }
29    impl ToTokens for _EmptyDelimiter {
30        fn to_tokens(&self, output: &mut TokenStream) {
31            self.surround(output, TokenStream::new());
32        }
33    }
34    impl PrettyTree for _EmptyDelimiter {
35        fn pretty_tree(&self) -> PrettyNode {
36            PrettyNode::delimiter(Self::KIND, self.span())
37        }
38    }
39    #[derive(Debug, Clone, Copy, PartialEq, Eq, Spanned)]
40    pub struct _SemicolonDelimiter {
41        span: Span,
42    }
43    #[doc(hidden)]
44    #[allow(non_snake_case)]
45    pub fn _SemicolonDelimiter<S: Spanned>(span: S) -> _SemicolonDelimiter {
46        <_SemicolonDelimiter as DelimiterToken>::new(span.span())
47    }
48    impl DelimiterToken for _SemicolonDelimiter {
49        const KIND: DelimiterKind = DelimiterKind::Semicolon;
50        fn new(span: Span) -> Self {
51            Self { span }
52        }
53    }
54    impl Parse for _SemicolonDelimiter {
55        fn parse(input: &mut ParseStream) -> Result<Self, TokenParseError> {
56            parse_delimiter(input)
57        }
58    }
59    impl ToTokens for _SemicolonDelimiter {
60        fn to_tokens(&self, output: &mut TokenStream) {
61            self.surround(output, TokenStream::new());
62        }
63    }
64    impl PrettyTree for _SemicolonDelimiter {
65        fn pretty_tree(&self) -> PrettyNode {
66            PrettyNode::delimiter(Self::KIND, self.span())
67        }
68    }
69    #[derive(Debug, Clone, Copy, PartialEq, Eq, Spanned)]
70    pub struct _ParenthesisDelimiter {
71        span: Span,
72    }
73    #[doc(hidden)]
74    #[allow(non_snake_case)]
75    pub fn _ParenthesisDelimiter<S: Spanned>(span: S) -> _ParenthesisDelimiter {
76        <_ParenthesisDelimiter as DelimiterToken>::new(span.span())
77    }
78    impl DelimiterToken for _ParenthesisDelimiter {
79        const KIND: DelimiterKind = DelimiterKind::Parenthesis;
80        fn new(span: Span) -> Self {
81            Self { span }
82        }
83    }
84    impl Parse for _ParenthesisDelimiter {
85        fn parse(input: &mut ParseStream) -> Result<Self, TokenParseError> {
86            parse_delimiter(input)
87        }
88    }
89    impl ToTokens for _ParenthesisDelimiter {
90        fn to_tokens(&self, output: &mut TokenStream) {
91            self.surround(output, TokenStream::new());
92        }
93    }
94    impl PrettyTree for _ParenthesisDelimiter {
95        fn pretty_tree(&self) -> PrettyNode {
96            PrettyNode::delimiter(Self::KIND, self.span())
97        }
98    }
99    #[derive(Debug, Clone, Copy, PartialEq, Eq, Spanned)]
100    pub struct _BracketDelimiter {
101        span: Span,
102    }
103    #[doc(hidden)]
104    #[allow(non_snake_case)]
105    pub fn _BracketDelimiter<S: Spanned>(span: S) -> _BracketDelimiter {
106        <_BracketDelimiter as DelimiterToken>::new(span.span())
107    }
108    impl DelimiterToken for _BracketDelimiter {
109        const KIND: DelimiterKind = DelimiterKind::Bracket;
110        fn new(span: Span) -> Self {
111            Self { span }
112        }
113    }
114    impl Parse for _BracketDelimiter {
115        fn parse(input: &mut ParseStream) -> Result<Self, TokenParseError> {
116            parse_delimiter(input)
117        }
118    }
119    impl ToTokens for _BracketDelimiter {
120        fn to_tokens(&self, output: &mut TokenStream) {
121            self.surround(output, TokenStream::new());
122        }
123    }
124    impl PrettyTree for _BracketDelimiter {
125        fn pretty_tree(&self) -> PrettyNode {
126            PrettyNode::delimiter(Self::KIND, self.span())
127        }
128    }
129    #[derive(Debug, Clone, Copy, PartialEq, Eq, Spanned)]
130    pub struct _BraceDelimiter {
131        span: Span,
132    }
133    #[doc(hidden)]
134    #[allow(non_snake_case)]
135    pub fn _BraceDelimiter<S: Spanned>(span: S) -> _BraceDelimiter {
136        <_BraceDelimiter as DelimiterToken>::new(span.span())
137    }
138    impl DelimiterToken for _BraceDelimiter {
139        const KIND: DelimiterKind = DelimiterKind::Brace;
140        fn new(span: Span) -> Self {
141            Self { span }
142        }
143    }
144    impl Parse for _BraceDelimiter {
145        fn parse(input: &mut ParseStream) -> Result<Self, TokenParseError> {
146            parse_delimiter(input)
147        }
148    }
149    impl ToTokens for _BraceDelimiter {
150        fn to_tokens(&self, output: &mut TokenStream) {
151            self.surround(output, TokenStream::new());
152        }
153    }
154    impl PrettyTree for _BraceDelimiter {
155        fn pretty_tree(&self) -> PrettyNode {
156            PrettyNode::delimiter(Self::KIND, self.span())
157        }
158    }
159    #[derive(Debug, Clone, Copy, PartialEq, Eq, Spanned)]
160    pub struct _AngleBarDelimiter {
161        span: Span,
162    }
163    #[doc(hidden)]
164    #[allow(non_snake_case)]
165    pub fn _AngleBarDelimiter<S: Spanned>(span: S) -> _AngleBarDelimiter {
166        <_AngleBarDelimiter as DelimiterToken>::new(span.span())
167    }
168    impl DelimiterToken for _AngleBarDelimiter {
169        const KIND: DelimiterKind = DelimiterKind::AngleBar;
170        fn new(span: Span) -> Self {
171            Self { span }
172        }
173    }
174    impl Parse for _AngleBarDelimiter {
175        fn parse(input: &mut ParseStream) -> Result<Self, TokenParseError> {
176            parse_delimiter(input)
177        }
178    }
179    impl ToTokens for _AngleBarDelimiter {
180        fn to_tokens(&self, output: &mut TokenStream) {
181            self.surround(output, TokenStream::new());
182        }
183    }
184    impl PrettyTree for _AngleBarDelimiter {
185        fn pretty_tree(&self) -> PrettyNode {
186            PrettyNode::delimiter(Self::KIND, self.span())
187        }
188    }
189}
190#[doc(hidden)]
191pub use __m2_syn_delimiters::*;
192#[macro_export]
193macro_rules! Delimiter {
194    [] => { $crate::_EmptyDelimiter };
195    [;] => { $crate::_SemicolonDelimiter };
196    [()] => { $crate::_ParenthesisDelimiter };
197    [[]] => { $crate::_BracketDelimiter };
198    [{}] => { $crate::_BraceDelimiter };
199    [<| |>] => { $crate::_AngleBarDelimiter };
200    [$($unsupported:tt)*] => { compile_error!("delimiter was not declared") };
201}
202pub(crate) const PREC_CLOSER: u8 = 6;
203pub(crate) const PREC_SEMICOLON: u8 = 8;
204pub(crate) const PREC_COMMA: u8 = 10;
205pub(crate) const PREC_CONTROL: u8 = 12;
206pub(crate) const PREC_LOOP_CLAUSE: u8 = 16;
207pub(crate) const PREC_COLLECTION: u8 = 56;
208pub(crate) const PREC_APPLICATION_RIGHT: u8 = 61;
209pub(crate) const PREC_APPLICATION: u8 = 62;
210pub(crate) const PREC_QUOTE: u8 = 74;
211pub(crate) const GENERATED_OPERATOR_SPELLINGS: &[&str] = &[
212    "!=", "#", "#?", "%", "%=", "&", "&=", "*", "*=", "**", "**=", "+", "+=", "++", "++=", "-",
213    "-=", "->", ".", "..", "..=", "..<", "..<=", ".?", "/", "/=", "//", "//=", ":", ":=", "<",
214    "<-", "<<", "<<=", "<=", "<==", "<===", "<==>", "<==>=", "=", "=!=", "==", "===", "===>",
215    "===>=", "==>", "==>=", "=>", ">", ">=", ">>", ">>=", "?", "??", "??=", "@", "@=", "@@", "@@=",
216    "@@?", "@@?=", "\\", "\\=", "\\\\", "\\\\=", "^", "^=", "^**", "^**=", "^<", "^<=", "^>",
217    "^>=", "^^", "^^=", "_", "_=", "_<", "_<=", "_>", "_>=", "|", "|=", "|-", "|-=", "|_", "|_=",
218    "||", "||=", "~", "~=", "·", "·=", "⊠", "⊠=", "⧢", "⧢=", "and", "or", "SPACE", "xor", "!",
219    "(*)", "^!", "^*", "^~", "_!", "_*", "_~", "not",
220];
221pub(crate) const GENERATED_POSTFIX_OPERATOR_SPELLINGS: &[&str] =
222    &["!", "(*)", "^!", "^*", "^~", "_!", "_*", "_~"];
223pub(crate) const GENERATED_KEYWORD_SPELLINGS: &[&str] = &[
224    "break",
225    "breakpoint",
226    "catch",
227    "continue",
228    "do",
229    "elapsedTime",
230    "elapsedTiming",
231    "else",
232    "except",
233    "finish",
234    "for",
235    "from",
236    "global",
237    "if",
238    "in",
239    "list",
240    "local",
241    "new",
242    "of",
243    "profile",
244    "return",
245    "shield",
246    "step",
247    "symbol",
248    "TEST",
249    "then",
250    "threadLocal",
251    "threadVariable",
252    "throw",
253    "time",
254    "timing",
255    "to",
256    "trap",
257    "try",
258    "when",
259    "while",
260];
261pub(crate) const GENERATED_PUNCTUATION_SPELLINGS: &[&str] = &[
262    "!=", "#", "#?", "%", "%=", "&", "&=", "*", "*=", "**", "**=", "+", "+=", "++", "++=", "-",
263    "-=", "->", ".", "..", "..=", "..<", "..<=", ".?", "/", "/=", "//", "//=", ":", ":=", "<",
264    "<-", "<<", "<<=", "<=", "<==", "<===", "<==>", "<==>=", "=", "=!=", "==", "===", "===>",
265    "===>=", "==>", "==>=", "=>", ">", ">=", ">>", ">>=", "?", "??", "??=", "@", "@=", "@@", "@@=",
266    "@@?", "@@?=", "\\", "\\=", "\\\\", "\\\\=", "^", "^=", "^**", "^**=", "^<", "^<=", "^>",
267    "^>=", "^^", "^^=", "_", "_=", "_<", "_<=", "_>", "_>=", "|", "|=", "|-", "|-=", "|_", "|_=",
268    "||", "||=", "~", "~=", "·", "·=", "⊠", "⊠=", "⧢", "⧢=", "!", "(*)", "^!", "^*", "^~", "_!",
269    "_*", "_~", ";", ",",
270];
271#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
272pub struct _BngEql {
273    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
274}
275#[doc(hidden)]
276#[allow(non_snake_case)]
277pub fn _BngEql<S: ::m2_syn::Spanned>(span: S) -> _BngEql {
278    let span = span.span();
279    _BngEql {
280        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("!=", span))),
281    }
282}
283impl ::m2_syn::Token for _BngEql {
284    const SPELLING: &'static str = "!=";
285    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
286        match token {
287            ::m2_syn::TokenTree::Punct(token) => token.text() == "!=",
288            _ => false,
289        }
290    }
291    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
292        Self::matches_token_tree(&token).then_some(Self {
293            raw: ::std::boxed::Box::new(token),
294        })
295    }
296}
297impl ::m2_syn::Parse for _BngEql {
298    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
299        input.parse_token()
300    }
301}
302impl ::m2_syn::ToTokens for _BngEql {
303    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
304        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
305    }
306}
307impl ::m2_syn::PrettyTree for _BngEql {
308    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
309        ::m2_syn::PrettyNode::token(
310            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
311            <Self as ::m2_syn::Token>::SPELLING,
312            ::m2_syn::Spanned::span(self),
313        )
314    }
315}
316impl<N> ::m2_syn::Reconstruct<N> for _BngEql
317where
318    N: ::m2_syn::ExternalCstNode,
319{
320    fn matches(node: &N) -> bool {
321        node.identity().matches("!=", false)
322    }
323    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
324        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
325            return Err(::m2_syn::ReconstructError::wrong_node(
326                "!=",
327                false,
328                node.identity(),
329            ));
330        }
331        Ok(_BngEql(node.span()))
332    }
333}
334#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
335pub struct _Hsh {
336    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
337}
338#[doc(hidden)]
339#[allow(non_snake_case)]
340pub fn _Hsh<S: ::m2_syn::Spanned>(span: S) -> _Hsh {
341    let span = span.span();
342    _Hsh {
343        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("#", span))),
344    }
345}
346impl ::m2_syn::Token for _Hsh {
347    const SPELLING: &'static str = "#";
348    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
349        match token {
350            ::m2_syn::TokenTree::Punct(token) => token.text() == "#",
351            _ => false,
352        }
353    }
354    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
355        Self::matches_token_tree(&token).then_some(Self {
356            raw: ::std::boxed::Box::new(token),
357        })
358    }
359}
360impl ::m2_syn::Parse for _Hsh {
361    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
362        input.parse_token()
363    }
364}
365impl ::m2_syn::ToTokens for _Hsh {
366    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
367        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
368    }
369}
370impl ::m2_syn::PrettyTree for _Hsh {
371    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
372        ::m2_syn::PrettyNode::token(
373            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
374            <Self as ::m2_syn::Token>::SPELLING,
375            ::m2_syn::Spanned::span(self),
376        )
377    }
378}
379impl<N> ::m2_syn::Reconstruct<N> for _Hsh
380where
381    N: ::m2_syn::ExternalCstNode,
382{
383    fn matches(node: &N) -> bool {
384        node.identity().matches("#", false)
385    }
386    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
387        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
388            return Err(::m2_syn::ReconstructError::wrong_node(
389                "#",
390                false,
391                node.identity(),
392            ));
393        }
394        Ok(_Hsh(node.span()))
395    }
396}
397#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
398pub struct _HshQsm {
399    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
400}
401#[doc(hidden)]
402#[allow(non_snake_case)]
403pub fn _HshQsm<S: ::m2_syn::Spanned>(span: S) -> _HshQsm {
404    let span = span.span();
405    _HshQsm {
406        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("#?", span))),
407    }
408}
409impl ::m2_syn::Token for _HshQsm {
410    const SPELLING: &'static str = "#?";
411    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
412        match token {
413            ::m2_syn::TokenTree::Punct(token) => token.text() == "#?",
414            _ => false,
415        }
416    }
417    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
418        Self::matches_token_tree(&token).then_some(Self {
419            raw: ::std::boxed::Box::new(token),
420        })
421    }
422}
423impl ::m2_syn::Parse for _HshQsm {
424    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
425        input.parse_token()
426    }
427}
428impl ::m2_syn::ToTokens for _HshQsm {
429    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
430        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
431    }
432}
433impl ::m2_syn::PrettyTree for _HshQsm {
434    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
435        ::m2_syn::PrettyNode::token(
436            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
437            <Self as ::m2_syn::Token>::SPELLING,
438            ::m2_syn::Spanned::span(self),
439        )
440    }
441}
442impl<N> ::m2_syn::Reconstruct<N> for _HshQsm
443where
444    N: ::m2_syn::ExternalCstNode,
445{
446    fn matches(node: &N) -> bool {
447        node.identity().matches("#?", false)
448    }
449    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
450        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
451            return Err(::m2_syn::ReconstructError::wrong_node(
452                "#?",
453                false,
454                node.identity(),
455            ));
456        }
457        Ok(_HshQsm(node.span()))
458    }
459}
460#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
461pub struct _Mod {
462    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
463}
464#[doc(hidden)]
465#[allow(non_snake_case)]
466pub fn _Mod<S: ::m2_syn::Spanned>(span: S) -> _Mod {
467    let span = span.span();
468    _Mod {
469        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("%", span))),
470    }
471}
472impl ::m2_syn::Token for _Mod {
473    const SPELLING: &'static str = "%";
474    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
475        match token {
476            ::m2_syn::TokenTree::Punct(token) => token.text() == "%",
477            _ => false,
478        }
479    }
480    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
481        Self::matches_token_tree(&token).then_some(Self {
482            raw: ::std::boxed::Box::new(token),
483        })
484    }
485}
486impl ::m2_syn::Parse for _Mod {
487    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
488        input.parse_token()
489    }
490}
491impl ::m2_syn::ToTokens for _Mod {
492    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
493        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
494    }
495}
496impl ::m2_syn::PrettyTree for _Mod {
497    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
498        ::m2_syn::PrettyNode::token(
499            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
500            <Self as ::m2_syn::Token>::SPELLING,
501            ::m2_syn::Spanned::span(self),
502        )
503    }
504}
505impl<N> ::m2_syn::Reconstruct<N> for _Mod
506where
507    N: ::m2_syn::ExternalCstNode,
508{
509    fn matches(node: &N) -> bool {
510        node.identity().matches("%", false)
511    }
512    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
513        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
514            return Err(::m2_syn::ReconstructError::wrong_node(
515                "%",
516                false,
517                node.identity(),
518            ));
519        }
520        Ok(_Mod(node.span()))
521    }
522}
523#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
524pub struct _ModEql {
525    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
526}
527#[doc(hidden)]
528#[allow(non_snake_case)]
529pub fn _ModEql<S: ::m2_syn::Spanned>(span: S) -> _ModEql {
530    let span = span.span();
531    _ModEql {
532        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("%=", span))),
533    }
534}
535impl ::m2_syn::Token for _ModEql {
536    const SPELLING: &'static str = "%=";
537    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
538        match token {
539            ::m2_syn::TokenTree::Punct(token) => token.text() == "%=",
540            _ => false,
541        }
542    }
543    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
544        Self::matches_token_tree(&token).then_some(Self {
545            raw: ::std::boxed::Box::new(token),
546        })
547    }
548}
549impl ::m2_syn::Parse for _ModEql {
550    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
551        input.parse_token()
552    }
553}
554impl ::m2_syn::ToTokens for _ModEql {
555    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
556        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
557    }
558}
559impl ::m2_syn::PrettyTree for _ModEql {
560    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
561        ::m2_syn::PrettyNode::token(
562            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
563            <Self as ::m2_syn::Token>::SPELLING,
564            ::m2_syn::Spanned::span(self),
565        )
566    }
567}
568impl<N> ::m2_syn::Reconstruct<N> for _ModEql
569where
570    N: ::m2_syn::ExternalCstNode,
571{
572    fn matches(node: &N) -> bool {
573        node.identity().matches("%=", false)
574    }
575    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
576        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
577            return Err(::m2_syn::ReconstructError::wrong_node(
578                "%=",
579                false,
580                node.identity(),
581            ));
582        }
583        Ok(_ModEql(node.span()))
584    }
585}
586#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
587pub struct _Amp {
588    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
589}
590#[doc(hidden)]
591#[allow(non_snake_case)]
592pub fn _Amp<S: ::m2_syn::Spanned>(span: S) -> _Amp {
593    let span = span.span();
594    _Amp {
595        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("&", span))),
596    }
597}
598impl ::m2_syn::Token for _Amp {
599    const SPELLING: &'static str = "&";
600    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
601        match token {
602            ::m2_syn::TokenTree::Punct(token) => token.text() == "&",
603            _ => false,
604        }
605    }
606    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
607        Self::matches_token_tree(&token).then_some(Self {
608            raw: ::std::boxed::Box::new(token),
609        })
610    }
611}
612impl ::m2_syn::Parse for _Amp {
613    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
614        input.parse_token()
615    }
616}
617impl ::m2_syn::ToTokens for _Amp {
618    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
619        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
620    }
621}
622impl ::m2_syn::PrettyTree for _Amp {
623    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
624        ::m2_syn::PrettyNode::token(
625            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
626            <Self as ::m2_syn::Token>::SPELLING,
627            ::m2_syn::Spanned::span(self),
628        )
629    }
630}
631impl<N> ::m2_syn::Reconstruct<N> for _Amp
632where
633    N: ::m2_syn::ExternalCstNode,
634{
635    fn matches(node: &N) -> bool {
636        node.identity().matches("&", false)
637    }
638    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
639        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
640            return Err(::m2_syn::ReconstructError::wrong_node(
641                "&",
642                false,
643                node.identity(),
644            ));
645        }
646        Ok(_Amp(node.span()))
647    }
648}
649#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
650pub struct _AmpEql {
651    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
652}
653#[doc(hidden)]
654#[allow(non_snake_case)]
655pub fn _AmpEql<S: ::m2_syn::Spanned>(span: S) -> _AmpEql {
656    let span = span.span();
657    _AmpEql {
658        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("&=", span))),
659    }
660}
661impl ::m2_syn::Token for _AmpEql {
662    const SPELLING: &'static str = "&=";
663    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
664        match token {
665            ::m2_syn::TokenTree::Punct(token) => token.text() == "&=",
666            _ => false,
667        }
668    }
669    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
670        Self::matches_token_tree(&token).then_some(Self {
671            raw: ::std::boxed::Box::new(token),
672        })
673    }
674}
675impl ::m2_syn::Parse for _AmpEql {
676    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
677        input.parse_token()
678    }
679}
680impl ::m2_syn::ToTokens for _AmpEql {
681    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
682        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
683    }
684}
685impl ::m2_syn::PrettyTree for _AmpEql {
686    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
687        ::m2_syn::PrettyNode::token(
688            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
689            <Self as ::m2_syn::Token>::SPELLING,
690            ::m2_syn::Spanned::span(self),
691        )
692    }
693}
694impl<N> ::m2_syn::Reconstruct<N> for _AmpEql
695where
696    N: ::m2_syn::ExternalCstNode,
697{
698    fn matches(node: &N) -> bool {
699        node.identity().matches("&=", false)
700    }
701    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
702        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
703            return Err(::m2_syn::ReconstructError::wrong_node(
704                "&=",
705                false,
706                node.identity(),
707            ));
708        }
709        Ok(_AmpEql(node.span()))
710    }
711}
712#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
713pub struct _Mul {
714    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
715}
716#[doc(hidden)]
717#[allow(non_snake_case)]
718pub fn _Mul<S: ::m2_syn::Spanned>(span: S) -> _Mul {
719    let span = span.span();
720    _Mul {
721        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("*", span))),
722    }
723}
724impl ::m2_syn::Token for _Mul {
725    const SPELLING: &'static str = "*";
726    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
727        match token {
728            ::m2_syn::TokenTree::Punct(token) => token.text() == "*",
729            _ => false,
730        }
731    }
732    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
733        Self::matches_token_tree(&token).then_some(Self {
734            raw: ::std::boxed::Box::new(token),
735        })
736    }
737}
738impl ::m2_syn::Parse for _Mul {
739    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
740        input.parse_token()
741    }
742}
743impl ::m2_syn::ToTokens for _Mul {
744    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
745        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
746    }
747}
748impl ::m2_syn::PrettyTree for _Mul {
749    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
750        ::m2_syn::PrettyNode::token(
751            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
752            <Self as ::m2_syn::Token>::SPELLING,
753            ::m2_syn::Spanned::span(self),
754        )
755    }
756}
757impl<N> ::m2_syn::Reconstruct<N> for _Mul
758where
759    N: ::m2_syn::ExternalCstNode,
760{
761    fn matches(node: &N) -> bool {
762        node.identity().matches("*", false)
763    }
764    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
765        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
766            return Err(::m2_syn::ReconstructError::wrong_node(
767                "*",
768                false,
769                node.identity(),
770            ));
771        }
772        Ok(_Mul(node.span()))
773    }
774}
775#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
776pub struct _MulEql {
777    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
778}
779#[doc(hidden)]
780#[allow(non_snake_case)]
781pub fn _MulEql<S: ::m2_syn::Spanned>(span: S) -> _MulEql {
782    let span = span.span();
783    _MulEql {
784        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("*=", span))),
785    }
786}
787impl ::m2_syn::Token for _MulEql {
788    const SPELLING: &'static str = "*=";
789    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
790        match token {
791            ::m2_syn::TokenTree::Punct(token) => token.text() == "*=",
792            _ => false,
793        }
794    }
795    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
796        Self::matches_token_tree(&token).then_some(Self {
797            raw: ::std::boxed::Box::new(token),
798        })
799    }
800}
801impl ::m2_syn::Parse for _MulEql {
802    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
803        input.parse_token()
804    }
805}
806impl ::m2_syn::ToTokens for _MulEql {
807    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
808        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
809    }
810}
811impl ::m2_syn::PrettyTree for _MulEql {
812    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
813        ::m2_syn::PrettyNode::token(
814            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
815            <Self as ::m2_syn::Token>::SPELLING,
816            ::m2_syn::Spanned::span(self),
817        )
818    }
819}
820impl<N> ::m2_syn::Reconstruct<N> for _MulEql
821where
822    N: ::m2_syn::ExternalCstNode,
823{
824    fn matches(node: &N) -> bool {
825        node.identity().matches("*=", false)
826    }
827    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
828        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
829            return Err(::m2_syn::ReconstructError::wrong_node(
830                "*=",
831                false,
832                node.identity(),
833            ));
834        }
835        Ok(_MulEql(node.span()))
836    }
837}
838#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
839pub struct _MulMul {
840    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
841}
842#[doc(hidden)]
843#[allow(non_snake_case)]
844pub fn _MulMul<S: ::m2_syn::Spanned>(span: S) -> _MulMul {
845    let span = span.span();
846    _MulMul {
847        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("**", span))),
848    }
849}
850impl ::m2_syn::Token for _MulMul {
851    const SPELLING: &'static str = "**";
852    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
853        match token {
854            ::m2_syn::TokenTree::Punct(token) => token.text() == "**",
855            _ => false,
856        }
857    }
858    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
859        Self::matches_token_tree(&token).then_some(Self {
860            raw: ::std::boxed::Box::new(token),
861        })
862    }
863}
864impl ::m2_syn::Parse for _MulMul {
865    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
866        input.parse_token()
867    }
868}
869impl ::m2_syn::ToTokens for _MulMul {
870    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
871        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
872    }
873}
874impl ::m2_syn::PrettyTree for _MulMul {
875    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
876        ::m2_syn::PrettyNode::token(
877            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
878            <Self as ::m2_syn::Token>::SPELLING,
879            ::m2_syn::Spanned::span(self),
880        )
881    }
882}
883impl<N> ::m2_syn::Reconstruct<N> for _MulMul
884where
885    N: ::m2_syn::ExternalCstNode,
886{
887    fn matches(node: &N) -> bool {
888        node.identity().matches("**", false)
889    }
890    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
891        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
892            return Err(::m2_syn::ReconstructError::wrong_node(
893                "**",
894                false,
895                node.identity(),
896            ));
897        }
898        Ok(_MulMul(node.span()))
899    }
900}
901#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
902pub struct _MulMulEql {
903    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
904}
905#[doc(hidden)]
906#[allow(non_snake_case)]
907pub fn _MulMulEql<S: ::m2_syn::Spanned>(span: S) -> _MulMulEql {
908    let span = span.span();
909    _MulMulEql {
910        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
911            "**=", span,
912        ))),
913    }
914}
915impl ::m2_syn::Token for _MulMulEql {
916    const SPELLING: &'static str = "**=";
917    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
918        match token {
919            ::m2_syn::TokenTree::Punct(token) => token.text() == "**=",
920            _ => false,
921        }
922    }
923    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
924        Self::matches_token_tree(&token).then_some(Self {
925            raw: ::std::boxed::Box::new(token),
926        })
927    }
928}
929impl ::m2_syn::Parse for _MulMulEql {
930    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
931        input.parse_token()
932    }
933}
934impl ::m2_syn::ToTokens for _MulMulEql {
935    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
936        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
937    }
938}
939impl ::m2_syn::PrettyTree for _MulMulEql {
940    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
941        ::m2_syn::PrettyNode::token(
942            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
943            <Self as ::m2_syn::Token>::SPELLING,
944            ::m2_syn::Spanned::span(self),
945        )
946    }
947}
948impl<N> ::m2_syn::Reconstruct<N> for _MulMulEql
949where
950    N: ::m2_syn::ExternalCstNode,
951{
952    fn matches(node: &N) -> bool {
953        node.identity().matches("**=", false)
954    }
955    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
956        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
957            return Err(::m2_syn::ReconstructError::wrong_node(
958                "**=",
959                false,
960                node.identity(),
961            ));
962        }
963        Ok(_MulMulEql(node.span()))
964    }
965}
966#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
967pub struct _Add {
968    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
969}
970#[doc(hidden)]
971#[allow(non_snake_case)]
972pub fn _Add<S: ::m2_syn::Spanned>(span: S) -> _Add {
973    let span = span.span();
974    _Add {
975        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("+", span))),
976    }
977}
978impl ::m2_syn::Token for _Add {
979    const SPELLING: &'static str = "+";
980    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
981        match token {
982            ::m2_syn::TokenTree::Punct(token) => token.text() == "+",
983            _ => false,
984        }
985    }
986    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
987        Self::matches_token_tree(&token).then_some(Self {
988            raw: ::std::boxed::Box::new(token),
989        })
990    }
991}
992impl ::m2_syn::Parse for _Add {
993    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
994        input.parse_token()
995    }
996}
997impl ::m2_syn::ToTokens for _Add {
998    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
999        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1000    }
1001}
1002impl ::m2_syn::PrettyTree for _Add {
1003    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1004        ::m2_syn::PrettyNode::token(
1005            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1006            <Self as ::m2_syn::Token>::SPELLING,
1007            ::m2_syn::Spanned::span(self),
1008        )
1009    }
1010}
1011impl<N> ::m2_syn::Reconstruct<N> for _Add
1012where
1013    N: ::m2_syn::ExternalCstNode,
1014{
1015    fn matches(node: &N) -> bool {
1016        node.identity().matches("+", false)
1017    }
1018    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1019        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1020            return Err(::m2_syn::ReconstructError::wrong_node(
1021                "+",
1022                false,
1023                node.identity(),
1024            ));
1025        }
1026        Ok(_Add(node.span()))
1027    }
1028}
1029#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1030pub struct _AddEql {
1031    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1032}
1033#[doc(hidden)]
1034#[allow(non_snake_case)]
1035pub fn _AddEql<S: ::m2_syn::Spanned>(span: S) -> _AddEql {
1036    let span = span.span();
1037    _AddEql {
1038        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("+=", span))),
1039    }
1040}
1041impl ::m2_syn::Token for _AddEql {
1042    const SPELLING: &'static str = "+=";
1043    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1044        match token {
1045            ::m2_syn::TokenTree::Punct(token) => token.text() == "+=",
1046            _ => false,
1047        }
1048    }
1049    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
1050        Self::matches_token_tree(&token).then_some(Self {
1051            raw: ::std::boxed::Box::new(token),
1052        })
1053    }
1054}
1055impl ::m2_syn::Parse for _AddEql {
1056    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
1057        input.parse_token()
1058    }
1059}
1060impl ::m2_syn::ToTokens for _AddEql {
1061    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1062        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1063    }
1064}
1065impl ::m2_syn::PrettyTree for _AddEql {
1066    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1067        ::m2_syn::PrettyNode::token(
1068            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1069            <Self as ::m2_syn::Token>::SPELLING,
1070            ::m2_syn::Spanned::span(self),
1071        )
1072    }
1073}
1074impl<N> ::m2_syn::Reconstruct<N> for _AddEql
1075where
1076    N: ::m2_syn::ExternalCstNode,
1077{
1078    fn matches(node: &N) -> bool {
1079        node.identity().matches("+=", false)
1080    }
1081    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1082        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1083            return Err(::m2_syn::ReconstructError::wrong_node(
1084                "+=",
1085                false,
1086                node.identity(),
1087            ));
1088        }
1089        Ok(_AddEql(node.span()))
1090    }
1091}
1092#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1093pub struct _AddAdd {
1094    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1095}
1096#[doc(hidden)]
1097#[allow(non_snake_case)]
1098pub fn _AddAdd<S: ::m2_syn::Spanned>(span: S) -> _AddAdd {
1099    let span = span.span();
1100    _AddAdd {
1101        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("++", span))),
1102    }
1103}
1104impl ::m2_syn::Token for _AddAdd {
1105    const SPELLING: &'static str = "++";
1106    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1107        match token {
1108            ::m2_syn::TokenTree::Punct(token) => token.text() == "++",
1109            _ => false,
1110        }
1111    }
1112    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
1113        Self::matches_token_tree(&token).then_some(Self {
1114            raw: ::std::boxed::Box::new(token),
1115        })
1116    }
1117}
1118impl ::m2_syn::Parse for _AddAdd {
1119    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
1120        input.parse_token()
1121    }
1122}
1123impl ::m2_syn::ToTokens for _AddAdd {
1124    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1125        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1126    }
1127}
1128impl ::m2_syn::PrettyTree for _AddAdd {
1129    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1130        ::m2_syn::PrettyNode::token(
1131            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1132            <Self as ::m2_syn::Token>::SPELLING,
1133            ::m2_syn::Spanned::span(self),
1134        )
1135    }
1136}
1137impl<N> ::m2_syn::Reconstruct<N> for _AddAdd
1138where
1139    N: ::m2_syn::ExternalCstNode,
1140{
1141    fn matches(node: &N) -> bool {
1142        node.identity().matches("++", false)
1143    }
1144    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1145        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1146            return Err(::m2_syn::ReconstructError::wrong_node(
1147                "++",
1148                false,
1149                node.identity(),
1150            ));
1151        }
1152        Ok(_AddAdd(node.span()))
1153    }
1154}
1155#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1156pub struct _AddAddEql {
1157    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1158}
1159#[doc(hidden)]
1160#[allow(non_snake_case)]
1161pub fn _AddAddEql<S: ::m2_syn::Spanned>(span: S) -> _AddAddEql {
1162    let span = span.span();
1163    _AddAddEql {
1164        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
1165            "++=", span,
1166        ))),
1167    }
1168}
1169impl ::m2_syn::Token for _AddAddEql {
1170    const SPELLING: &'static str = "++=";
1171    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1172        match token {
1173            ::m2_syn::TokenTree::Punct(token) => token.text() == "++=",
1174            _ => false,
1175        }
1176    }
1177    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
1178        Self::matches_token_tree(&token).then_some(Self {
1179            raw: ::std::boxed::Box::new(token),
1180        })
1181    }
1182}
1183impl ::m2_syn::Parse for _AddAddEql {
1184    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
1185        input.parse_token()
1186    }
1187}
1188impl ::m2_syn::ToTokens for _AddAddEql {
1189    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1190        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1191    }
1192}
1193impl ::m2_syn::PrettyTree for _AddAddEql {
1194    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1195        ::m2_syn::PrettyNode::token(
1196            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1197            <Self as ::m2_syn::Token>::SPELLING,
1198            ::m2_syn::Spanned::span(self),
1199        )
1200    }
1201}
1202impl<N> ::m2_syn::Reconstruct<N> for _AddAddEql
1203where
1204    N: ::m2_syn::ExternalCstNode,
1205{
1206    fn matches(node: &N) -> bool {
1207        node.identity().matches("++=", false)
1208    }
1209    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1210        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1211            return Err(::m2_syn::ReconstructError::wrong_node(
1212                "++=",
1213                false,
1214                node.identity(),
1215            ));
1216        }
1217        Ok(_AddAddEql(node.span()))
1218    }
1219}
1220#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1221pub struct _Sub {
1222    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1223}
1224#[doc(hidden)]
1225#[allow(non_snake_case)]
1226pub fn _Sub<S: ::m2_syn::Spanned>(span: S) -> _Sub {
1227    let span = span.span();
1228    _Sub {
1229        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("-", span))),
1230    }
1231}
1232impl ::m2_syn::Token for _Sub {
1233    const SPELLING: &'static str = "-";
1234    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1235        match token {
1236            ::m2_syn::TokenTree::Punct(token) => token.text() == "-",
1237            _ => false,
1238        }
1239    }
1240    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
1241        Self::matches_token_tree(&token).then_some(Self {
1242            raw: ::std::boxed::Box::new(token),
1243        })
1244    }
1245}
1246impl ::m2_syn::Parse for _Sub {
1247    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
1248        input.parse_token()
1249    }
1250}
1251impl ::m2_syn::ToTokens for _Sub {
1252    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1253        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1254    }
1255}
1256impl ::m2_syn::PrettyTree for _Sub {
1257    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1258        ::m2_syn::PrettyNode::token(
1259            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1260            <Self as ::m2_syn::Token>::SPELLING,
1261            ::m2_syn::Spanned::span(self),
1262        )
1263    }
1264}
1265impl<N> ::m2_syn::Reconstruct<N> for _Sub
1266where
1267    N: ::m2_syn::ExternalCstNode,
1268{
1269    fn matches(node: &N) -> bool {
1270        node.identity().matches("-", false)
1271    }
1272    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1273        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1274            return Err(::m2_syn::ReconstructError::wrong_node(
1275                "-",
1276                false,
1277                node.identity(),
1278            ));
1279        }
1280        Ok(_Sub(node.span()))
1281    }
1282}
1283#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1284pub struct _SubEql {
1285    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1286}
1287#[doc(hidden)]
1288#[allow(non_snake_case)]
1289pub fn _SubEql<S: ::m2_syn::Spanned>(span: S) -> _SubEql {
1290    let span = span.span();
1291    _SubEql {
1292        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("-=", span))),
1293    }
1294}
1295impl ::m2_syn::Token for _SubEql {
1296    const SPELLING: &'static str = "-=";
1297    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1298        match token {
1299            ::m2_syn::TokenTree::Punct(token) => token.text() == "-=",
1300            _ => false,
1301        }
1302    }
1303    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
1304        Self::matches_token_tree(&token).then_some(Self {
1305            raw: ::std::boxed::Box::new(token),
1306        })
1307    }
1308}
1309impl ::m2_syn::Parse for _SubEql {
1310    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
1311        input.parse_token()
1312    }
1313}
1314impl ::m2_syn::ToTokens for _SubEql {
1315    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1316        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1317    }
1318}
1319impl ::m2_syn::PrettyTree for _SubEql {
1320    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1321        ::m2_syn::PrettyNode::token(
1322            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1323            <Self as ::m2_syn::Token>::SPELLING,
1324            ::m2_syn::Spanned::span(self),
1325        )
1326    }
1327}
1328impl<N> ::m2_syn::Reconstruct<N> for _SubEql
1329where
1330    N: ::m2_syn::ExternalCstNode,
1331{
1332    fn matches(node: &N) -> bool {
1333        node.identity().matches("-=", false)
1334    }
1335    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1336        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1337            return Err(::m2_syn::ReconstructError::wrong_node(
1338                "-=",
1339                false,
1340                node.identity(),
1341            ));
1342        }
1343        Ok(_SubEql(node.span()))
1344    }
1345}
1346#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1347pub struct _SubGst {
1348    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1349}
1350#[doc(hidden)]
1351#[allow(non_snake_case)]
1352pub fn _SubGst<S: ::m2_syn::Spanned>(span: S) -> _SubGst {
1353    let span = span.span();
1354    _SubGst {
1355        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("->", span))),
1356    }
1357}
1358impl ::m2_syn::Token for _SubGst {
1359    const SPELLING: &'static str = "->";
1360    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1361        match token {
1362            ::m2_syn::TokenTree::Punct(token) => token.text() == "->",
1363            _ => false,
1364        }
1365    }
1366    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
1367        Self::matches_token_tree(&token).then_some(Self {
1368            raw: ::std::boxed::Box::new(token),
1369        })
1370    }
1371}
1372impl ::m2_syn::Parse for _SubGst {
1373    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
1374        input.parse_token()
1375    }
1376}
1377impl ::m2_syn::ToTokens for _SubGst {
1378    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1379        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1380    }
1381}
1382impl ::m2_syn::PrettyTree for _SubGst {
1383    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1384        ::m2_syn::PrettyNode::token(
1385            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1386            <Self as ::m2_syn::Token>::SPELLING,
1387            ::m2_syn::Spanned::span(self),
1388        )
1389    }
1390}
1391impl<N> ::m2_syn::Reconstruct<N> for _SubGst
1392where
1393    N: ::m2_syn::ExternalCstNode,
1394{
1395    fn matches(node: &N) -> bool {
1396        node.identity().matches("->", false)
1397    }
1398    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1399        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1400            return Err(::m2_syn::ReconstructError::wrong_node(
1401                "->",
1402                false,
1403                node.identity(),
1404            ));
1405        }
1406        Ok(_SubGst(node.span()))
1407    }
1408}
1409#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1410pub struct _Dot {
1411    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1412}
1413#[doc(hidden)]
1414#[allow(non_snake_case)]
1415pub fn _Dot<S: ::m2_syn::Spanned>(span: S) -> _Dot {
1416    let span = span.span();
1417    _Dot {
1418        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(".", span))),
1419    }
1420}
1421impl ::m2_syn::Token for _Dot {
1422    const SPELLING: &'static str = ".";
1423    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1424        match token {
1425            ::m2_syn::TokenTree::Punct(token) => token.text() == ".",
1426            _ => false,
1427        }
1428    }
1429    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
1430        Self::matches_token_tree(&token).then_some(Self {
1431            raw: ::std::boxed::Box::new(token),
1432        })
1433    }
1434}
1435impl ::m2_syn::Parse for _Dot {
1436    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
1437        input.parse_token()
1438    }
1439}
1440impl ::m2_syn::ToTokens for _Dot {
1441    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1442        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1443    }
1444}
1445impl ::m2_syn::PrettyTree for _Dot {
1446    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1447        ::m2_syn::PrettyNode::token(
1448            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1449            <Self as ::m2_syn::Token>::SPELLING,
1450            ::m2_syn::Spanned::span(self),
1451        )
1452    }
1453}
1454impl<N> ::m2_syn::Reconstruct<N> for _Dot
1455where
1456    N: ::m2_syn::ExternalCstNode,
1457{
1458    fn matches(node: &N) -> bool {
1459        node.identity().matches(".", false)
1460    }
1461    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1462        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1463            return Err(::m2_syn::ReconstructError::wrong_node(
1464                ".",
1465                false,
1466                node.identity(),
1467            ));
1468        }
1469        Ok(_Dot(node.span()))
1470    }
1471}
1472#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1473pub struct _DotDot {
1474    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1475}
1476#[doc(hidden)]
1477#[allow(non_snake_case)]
1478pub fn _DotDot<S: ::m2_syn::Spanned>(span: S) -> _DotDot {
1479    let span = span.span();
1480    _DotDot {
1481        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("..", span))),
1482    }
1483}
1484impl ::m2_syn::Token for _DotDot {
1485    const SPELLING: &'static str = "..";
1486    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1487        match token {
1488            ::m2_syn::TokenTree::Punct(token) => token.text() == "..",
1489            _ => false,
1490        }
1491    }
1492    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
1493        Self::matches_token_tree(&token).then_some(Self {
1494            raw: ::std::boxed::Box::new(token),
1495        })
1496    }
1497}
1498impl ::m2_syn::Parse for _DotDot {
1499    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
1500        input.parse_token()
1501    }
1502}
1503impl ::m2_syn::ToTokens for _DotDot {
1504    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1505        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1506    }
1507}
1508impl ::m2_syn::PrettyTree for _DotDot {
1509    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1510        ::m2_syn::PrettyNode::token(
1511            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1512            <Self as ::m2_syn::Token>::SPELLING,
1513            ::m2_syn::Spanned::span(self),
1514        )
1515    }
1516}
1517impl<N> ::m2_syn::Reconstruct<N> for _DotDot
1518where
1519    N: ::m2_syn::ExternalCstNode,
1520{
1521    fn matches(node: &N) -> bool {
1522        node.identity().matches("..", false)
1523    }
1524    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1525        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1526            return Err(::m2_syn::ReconstructError::wrong_node(
1527                "..",
1528                false,
1529                node.identity(),
1530            ));
1531        }
1532        Ok(_DotDot(node.span()))
1533    }
1534}
1535#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1536pub struct _DotDotEql {
1537    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1538}
1539#[doc(hidden)]
1540#[allow(non_snake_case)]
1541pub fn _DotDotEql<S: ::m2_syn::Spanned>(span: S) -> _DotDotEql {
1542    let span = span.span();
1543    _DotDotEql {
1544        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
1545            "..=", span,
1546        ))),
1547    }
1548}
1549impl ::m2_syn::Token for _DotDotEql {
1550    const SPELLING: &'static str = "..=";
1551    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1552        match token {
1553            ::m2_syn::TokenTree::Punct(token) => token.text() == "..=",
1554            _ => false,
1555        }
1556    }
1557    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
1558        Self::matches_token_tree(&token).then_some(Self {
1559            raw: ::std::boxed::Box::new(token),
1560        })
1561    }
1562}
1563impl ::m2_syn::Parse for _DotDotEql {
1564    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
1565        input.parse_token()
1566    }
1567}
1568impl ::m2_syn::ToTokens for _DotDotEql {
1569    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1570        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1571    }
1572}
1573impl ::m2_syn::PrettyTree for _DotDotEql {
1574    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1575        ::m2_syn::PrettyNode::token(
1576            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1577            <Self as ::m2_syn::Token>::SPELLING,
1578            ::m2_syn::Spanned::span(self),
1579        )
1580    }
1581}
1582impl<N> ::m2_syn::Reconstruct<N> for _DotDotEql
1583where
1584    N: ::m2_syn::ExternalCstNode,
1585{
1586    fn matches(node: &N) -> bool {
1587        node.identity().matches("..=", false)
1588    }
1589    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1590        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1591            return Err(::m2_syn::ReconstructError::wrong_node(
1592                "..=",
1593                false,
1594                node.identity(),
1595            ));
1596        }
1597        Ok(_DotDotEql(node.span()))
1598    }
1599}
1600#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1601pub struct _DotDotLst {
1602    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1603}
1604#[doc(hidden)]
1605#[allow(non_snake_case)]
1606pub fn _DotDotLst<S: ::m2_syn::Spanned>(span: S) -> _DotDotLst {
1607    let span = span.span();
1608    _DotDotLst {
1609        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
1610            "..<", span,
1611        ))),
1612    }
1613}
1614impl ::m2_syn::Token for _DotDotLst {
1615    const SPELLING: &'static str = "..<";
1616    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1617        match token {
1618            ::m2_syn::TokenTree::Punct(token) => token.text() == "..<",
1619            _ => false,
1620        }
1621    }
1622    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
1623        Self::matches_token_tree(&token).then_some(Self {
1624            raw: ::std::boxed::Box::new(token),
1625        })
1626    }
1627}
1628impl ::m2_syn::Parse for _DotDotLst {
1629    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
1630        input.parse_token()
1631    }
1632}
1633impl ::m2_syn::ToTokens for _DotDotLst {
1634    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1635        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1636    }
1637}
1638impl ::m2_syn::PrettyTree for _DotDotLst {
1639    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1640        ::m2_syn::PrettyNode::token(
1641            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1642            <Self as ::m2_syn::Token>::SPELLING,
1643            ::m2_syn::Spanned::span(self),
1644        )
1645    }
1646}
1647impl<N> ::m2_syn::Reconstruct<N> for _DotDotLst
1648where
1649    N: ::m2_syn::ExternalCstNode,
1650{
1651    fn matches(node: &N) -> bool {
1652        node.identity().matches("..<", false)
1653    }
1654    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1655        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1656            return Err(::m2_syn::ReconstructError::wrong_node(
1657                "..<",
1658                false,
1659                node.identity(),
1660            ));
1661        }
1662        Ok(_DotDotLst(node.span()))
1663    }
1664}
1665#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1666pub struct _DotDotLstEql {
1667    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1668}
1669#[doc(hidden)]
1670#[allow(non_snake_case)]
1671pub fn _DotDotLstEql<S: ::m2_syn::Spanned>(span: S) -> _DotDotLstEql {
1672    let span = span.span();
1673    _DotDotLstEql {
1674        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
1675            "..<=", span,
1676        ))),
1677    }
1678}
1679impl ::m2_syn::Token for _DotDotLstEql {
1680    const SPELLING: &'static str = "..<=";
1681    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1682        match token {
1683            ::m2_syn::TokenTree::Punct(token) => token.text() == "..<=",
1684            _ => false,
1685        }
1686    }
1687    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
1688        Self::matches_token_tree(&token).then_some(Self {
1689            raw: ::std::boxed::Box::new(token),
1690        })
1691    }
1692}
1693impl ::m2_syn::Parse for _DotDotLstEql {
1694    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
1695        input.parse_token()
1696    }
1697}
1698impl ::m2_syn::ToTokens for _DotDotLstEql {
1699    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1700        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1701    }
1702}
1703impl ::m2_syn::PrettyTree for _DotDotLstEql {
1704    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1705        ::m2_syn::PrettyNode::token(
1706            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1707            <Self as ::m2_syn::Token>::SPELLING,
1708            ::m2_syn::Spanned::span(self),
1709        )
1710    }
1711}
1712impl<N> ::m2_syn::Reconstruct<N> for _DotDotLstEql
1713where
1714    N: ::m2_syn::ExternalCstNode,
1715{
1716    fn matches(node: &N) -> bool {
1717        node.identity().matches("..<=", false)
1718    }
1719    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1720        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1721            return Err(::m2_syn::ReconstructError::wrong_node(
1722                "..<=",
1723                false,
1724                node.identity(),
1725            ));
1726        }
1727        Ok(_DotDotLstEql(node.span()))
1728    }
1729}
1730#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1731pub struct _DotQsm {
1732    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1733}
1734#[doc(hidden)]
1735#[allow(non_snake_case)]
1736pub fn _DotQsm<S: ::m2_syn::Spanned>(span: S) -> _DotQsm {
1737    let span = span.span();
1738    _DotQsm {
1739        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(".?", span))),
1740    }
1741}
1742impl ::m2_syn::Token for _DotQsm {
1743    const SPELLING: &'static str = ".?";
1744    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1745        match token {
1746            ::m2_syn::TokenTree::Punct(token) => token.text() == ".?",
1747            _ => false,
1748        }
1749    }
1750    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
1751        Self::matches_token_tree(&token).then_some(Self {
1752            raw: ::std::boxed::Box::new(token),
1753        })
1754    }
1755}
1756impl ::m2_syn::Parse for _DotQsm {
1757    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
1758        input.parse_token()
1759    }
1760}
1761impl ::m2_syn::ToTokens for _DotQsm {
1762    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1763        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1764    }
1765}
1766impl ::m2_syn::PrettyTree for _DotQsm {
1767    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1768        ::m2_syn::PrettyNode::token(
1769            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1770            <Self as ::m2_syn::Token>::SPELLING,
1771            ::m2_syn::Spanned::span(self),
1772        )
1773    }
1774}
1775impl<N> ::m2_syn::Reconstruct<N> for _DotQsm
1776where
1777    N: ::m2_syn::ExternalCstNode,
1778{
1779    fn matches(node: &N) -> bool {
1780        node.identity().matches(".?", false)
1781    }
1782    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1783        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1784            return Err(::m2_syn::ReconstructError::wrong_node(
1785                ".?",
1786                false,
1787                node.identity(),
1788            ));
1789        }
1790        Ok(_DotQsm(node.span()))
1791    }
1792}
1793#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1794pub struct _Slh {
1795    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1796}
1797#[doc(hidden)]
1798#[allow(non_snake_case)]
1799pub fn _Slh<S: ::m2_syn::Spanned>(span: S) -> _Slh {
1800    let span = span.span();
1801    _Slh {
1802        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("/", span))),
1803    }
1804}
1805impl ::m2_syn::Token for _Slh {
1806    const SPELLING: &'static str = "/";
1807    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1808        match token {
1809            ::m2_syn::TokenTree::Punct(token) => token.text() == "/",
1810            _ => false,
1811        }
1812    }
1813    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
1814        Self::matches_token_tree(&token).then_some(Self {
1815            raw: ::std::boxed::Box::new(token),
1816        })
1817    }
1818}
1819impl ::m2_syn::Parse for _Slh {
1820    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
1821        input.parse_token()
1822    }
1823}
1824impl ::m2_syn::ToTokens for _Slh {
1825    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1826        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1827    }
1828}
1829impl ::m2_syn::PrettyTree for _Slh {
1830    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1831        ::m2_syn::PrettyNode::token(
1832            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1833            <Self as ::m2_syn::Token>::SPELLING,
1834            ::m2_syn::Spanned::span(self),
1835        )
1836    }
1837}
1838impl<N> ::m2_syn::Reconstruct<N> for _Slh
1839where
1840    N: ::m2_syn::ExternalCstNode,
1841{
1842    fn matches(node: &N) -> bool {
1843        node.identity().matches("/", false)
1844    }
1845    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1846        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1847            return Err(::m2_syn::ReconstructError::wrong_node(
1848                "/",
1849                false,
1850                node.identity(),
1851            ));
1852        }
1853        Ok(_Slh(node.span()))
1854    }
1855}
1856#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1857pub struct _SlhEql {
1858    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1859}
1860#[doc(hidden)]
1861#[allow(non_snake_case)]
1862pub fn _SlhEql<S: ::m2_syn::Spanned>(span: S) -> _SlhEql {
1863    let span = span.span();
1864    _SlhEql {
1865        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("/=", span))),
1866    }
1867}
1868impl ::m2_syn::Token for _SlhEql {
1869    const SPELLING: &'static str = "/=";
1870    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1871        match token {
1872            ::m2_syn::TokenTree::Punct(token) => token.text() == "/=",
1873            _ => false,
1874        }
1875    }
1876    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
1877        Self::matches_token_tree(&token).then_some(Self {
1878            raw: ::std::boxed::Box::new(token),
1879        })
1880    }
1881}
1882impl ::m2_syn::Parse for _SlhEql {
1883    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
1884        input.parse_token()
1885    }
1886}
1887impl ::m2_syn::ToTokens for _SlhEql {
1888    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1889        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1890    }
1891}
1892impl ::m2_syn::PrettyTree for _SlhEql {
1893    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1894        ::m2_syn::PrettyNode::token(
1895            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1896            <Self as ::m2_syn::Token>::SPELLING,
1897            ::m2_syn::Spanned::span(self),
1898        )
1899    }
1900}
1901impl<N> ::m2_syn::Reconstruct<N> for _SlhEql
1902where
1903    N: ::m2_syn::ExternalCstNode,
1904{
1905    fn matches(node: &N) -> bool {
1906        node.identity().matches("/=", false)
1907    }
1908    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1909        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1910            return Err(::m2_syn::ReconstructError::wrong_node(
1911                "/=",
1912                false,
1913                node.identity(),
1914            ));
1915        }
1916        Ok(_SlhEql(node.span()))
1917    }
1918}
1919#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1920pub struct _SlhSlh {
1921    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1922}
1923#[doc(hidden)]
1924#[allow(non_snake_case)]
1925pub fn _SlhSlh<S: ::m2_syn::Spanned>(span: S) -> _SlhSlh {
1926    let span = span.span();
1927    _SlhSlh {
1928        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("//", span))),
1929    }
1930}
1931impl ::m2_syn::Token for _SlhSlh {
1932    const SPELLING: &'static str = "//";
1933    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1934        match token {
1935            ::m2_syn::TokenTree::Punct(token) => token.text() == "//",
1936            _ => false,
1937        }
1938    }
1939    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
1940        Self::matches_token_tree(&token).then_some(Self {
1941            raw: ::std::boxed::Box::new(token),
1942        })
1943    }
1944}
1945impl ::m2_syn::Parse for _SlhSlh {
1946    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
1947        input.parse_token()
1948    }
1949}
1950impl ::m2_syn::ToTokens for _SlhSlh {
1951    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1952        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
1953    }
1954}
1955impl ::m2_syn::PrettyTree for _SlhSlh {
1956    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1957        ::m2_syn::PrettyNode::token(
1958            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
1959            <Self as ::m2_syn::Token>::SPELLING,
1960            ::m2_syn::Spanned::span(self),
1961        )
1962    }
1963}
1964impl<N> ::m2_syn::Reconstruct<N> for _SlhSlh
1965where
1966    N: ::m2_syn::ExternalCstNode,
1967{
1968    fn matches(node: &N) -> bool {
1969        node.identity().matches("//", false)
1970    }
1971    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1972        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1973            return Err(::m2_syn::ReconstructError::wrong_node(
1974                "//",
1975                false,
1976                node.identity(),
1977            ));
1978        }
1979        Ok(_SlhSlh(node.span()))
1980    }
1981}
1982#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
1983pub struct _SlhSlhEql {
1984    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
1985}
1986#[doc(hidden)]
1987#[allow(non_snake_case)]
1988pub fn _SlhSlhEql<S: ::m2_syn::Spanned>(span: S) -> _SlhSlhEql {
1989    let span = span.span();
1990    _SlhSlhEql {
1991        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
1992            "//=", span,
1993        ))),
1994    }
1995}
1996impl ::m2_syn::Token for _SlhSlhEql {
1997    const SPELLING: &'static str = "//=";
1998    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
1999        match token {
2000            ::m2_syn::TokenTree::Punct(token) => token.text() == "//=",
2001            _ => false,
2002        }
2003    }
2004    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2005        Self::matches_token_tree(&token).then_some(Self {
2006            raw: ::std::boxed::Box::new(token),
2007        })
2008    }
2009}
2010impl ::m2_syn::Parse for _SlhSlhEql {
2011    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2012        input.parse_token()
2013    }
2014}
2015impl ::m2_syn::ToTokens for _SlhSlhEql {
2016    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2017        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2018    }
2019}
2020impl ::m2_syn::PrettyTree for _SlhSlhEql {
2021    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2022        ::m2_syn::PrettyNode::token(
2023            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2024            <Self as ::m2_syn::Token>::SPELLING,
2025            ::m2_syn::Spanned::span(self),
2026        )
2027    }
2028}
2029impl<N> ::m2_syn::Reconstruct<N> for _SlhSlhEql
2030where
2031    N: ::m2_syn::ExternalCstNode,
2032{
2033    fn matches(node: &N) -> bool {
2034        node.identity().matches("//=", false)
2035    }
2036    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2037        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2038            return Err(::m2_syn::ReconstructError::wrong_node(
2039                "//=",
2040                false,
2041                node.identity(),
2042            ));
2043        }
2044        Ok(_SlhSlhEql(node.span()))
2045    }
2046}
2047#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
2048pub struct _Col {
2049    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
2050}
2051#[doc(hidden)]
2052#[allow(non_snake_case)]
2053pub fn _Col<S: ::m2_syn::Spanned>(span: S) -> _Col {
2054    let span = span.span();
2055    _Col {
2056        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(":", span))),
2057    }
2058}
2059impl ::m2_syn::Token for _Col {
2060    const SPELLING: &'static str = ":";
2061    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
2062        match token {
2063            ::m2_syn::TokenTree::Punct(token) => token.text() == ":",
2064            _ => false,
2065        }
2066    }
2067    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2068        Self::matches_token_tree(&token).then_some(Self {
2069            raw: ::std::boxed::Box::new(token),
2070        })
2071    }
2072}
2073impl ::m2_syn::Parse for _Col {
2074    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2075        input.parse_token()
2076    }
2077}
2078impl ::m2_syn::ToTokens for _Col {
2079    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2080        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2081    }
2082}
2083impl ::m2_syn::PrettyTree for _Col {
2084    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2085        ::m2_syn::PrettyNode::token(
2086            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2087            <Self as ::m2_syn::Token>::SPELLING,
2088            ::m2_syn::Spanned::span(self),
2089        )
2090    }
2091}
2092impl<N> ::m2_syn::Reconstruct<N> for _Col
2093where
2094    N: ::m2_syn::ExternalCstNode,
2095{
2096    fn matches(node: &N) -> bool {
2097        node.identity().matches(":", false)
2098    }
2099    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2100        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2101            return Err(::m2_syn::ReconstructError::wrong_node(
2102                ":",
2103                false,
2104                node.identity(),
2105            ));
2106        }
2107        Ok(_Col(node.span()))
2108    }
2109}
2110#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
2111pub struct _ColEql {
2112    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
2113}
2114#[doc(hidden)]
2115#[allow(non_snake_case)]
2116pub fn _ColEql<S: ::m2_syn::Spanned>(span: S) -> _ColEql {
2117    let span = span.span();
2118    _ColEql {
2119        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(":=", span))),
2120    }
2121}
2122impl ::m2_syn::Token for _ColEql {
2123    const SPELLING: &'static str = ":=";
2124    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
2125        match token {
2126            ::m2_syn::TokenTree::Punct(token) => token.text() == ":=",
2127            _ => false,
2128        }
2129    }
2130    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2131        Self::matches_token_tree(&token).then_some(Self {
2132            raw: ::std::boxed::Box::new(token),
2133        })
2134    }
2135}
2136impl ::m2_syn::Parse for _ColEql {
2137    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2138        input.parse_token()
2139    }
2140}
2141impl ::m2_syn::ToTokens for _ColEql {
2142    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2143        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2144    }
2145}
2146impl ::m2_syn::PrettyTree for _ColEql {
2147    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2148        ::m2_syn::PrettyNode::token(
2149            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2150            <Self as ::m2_syn::Token>::SPELLING,
2151            ::m2_syn::Spanned::span(self),
2152        )
2153    }
2154}
2155impl<N> ::m2_syn::Reconstruct<N> for _ColEql
2156where
2157    N: ::m2_syn::ExternalCstNode,
2158{
2159    fn matches(node: &N) -> bool {
2160        node.identity().matches(":=", false)
2161    }
2162    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2163        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2164            return Err(::m2_syn::ReconstructError::wrong_node(
2165                ":=",
2166                false,
2167                node.identity(),
2168            ));
2169        }
2170        Ok(_ColEql(node.span()))
2171    }
2172}
2173#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
2174pub struct _Lst {
2175    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
2176}
2177#[doc(hidden)]
2178#[allow(non_snake_case)]
2179pub fn _Lst<S: ::m2_syn::Spanned>(span: S) -> _Lst {
2180    let span = span.span();
2181    _Lst {
2182        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("<", span))),
2183    }
2184}
2185impl ::m2_syn::Token for _Lst {
2186    const SPELLING: &'static str = "<";
2187    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
2188        match token {
2189            ::m2_syn::TokenTree::Punct(token) => token.text() == "<",
2190            _ => false,
2191        }
2192    }
2193    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2194        Self::matches_token_tree(&token).then_some(Self {
2195            raw: ::std::boxed::Box::new(token),
2196        })
2197    }
2198}
2199impl ::m2_syn::Parse for _Lst {
2200    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2201        input.parse_token()
2202    }
2203}
2204impl ::m2_syn::ToTokens for _Lst {
2205    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2206        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2207    }
2208}
2209impl ::m2_syn::PrettyTree for _Lst {
2210    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2211        ::m2_syn::PrettyNode::token(
2212            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2213            <Self as ::m2_syn::Token>::SPELLING,
2214            ::m2_syn::Spanned::span(self),
2215        )
2216    }
2217}
2218impl<N> ::m2_syn::Reconstruct<N> for _Lst
2219where
2220    N: ::m2_syn::ExternalCstNode,
2221{
2222    fn matches(node: &N) -> bool {
2223        node.identity().matches("<", false)
2224    }
2225    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2226        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2227            return Err(::m2_syn::ReconstructError::wrong_node(
2228                "<",
2229                false,
2230                node.identity(),
2231            ));
2232        }
2233        Ok(_Lst(node.span()))
2234    }
2235}
2236#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
2237pub struct _LstSub {
2238    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
2239}
2240#[doc(hidden)]
2241#[allow(non_snake_case)]
2242pub fn _LstSub<S: ::m2_syn::Spanned>(span: S) -> _LstSub {
2243    let span = span.span();
2244    _LstSub {
2245        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("<-", span))),
2246    }
2247}
2248impl ::m2_syn::Token for _LstSub {
2249    const SPELLING: &'static str = "<-";
2250    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
2251        match token {
2252            ::m2_syn::TokenTree::Punct(token) => token.text() == "<-",
2253            _ => false,
2254        }
2255    }
2256    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2257        Self::matches_token_tree(&token).then_some(Self {
2258            raw: ::std::boxed::Box::new(token),
2259        })
2260    }
2261}
2262impl ::m2_syn::Parse for _LstSub {
2263    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2264        input.parse_token()
2265    }
2266}
2267impl ::m2_syn::ToTokens for _LstSub {
2268    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2269        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2270    }
2271}
2272impl ::m2_syn::PrettyTree for _LstSub {
2273    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2274        ::m2_syn::PrettyNode::token(
2275            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2276            <Self as ::m2_syn::Token>::SPELLING,
2277            ::m2_syn::Spanned::span(self),
2278        )
2279    }
2280}
2281impl<N> ::m2_syn::Reconstruct<N> for _LstSub
2282where
2283    N: ::m2_syn::ExternalCstNode,
2284{
2285    fn matches(node: &N) -> bool {
2286        node.identity().matches("<-", false)
2287    }
2288    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2289        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2290            return Err(::m2_syn::ReconstructError::wrong_node(
2291                "<-",
2292                false,
2293                node.identity(),
2294            ));
2295        }
2296        Ok(_LstSub(node.span()))
2297    }
2298}
2299#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
2300pub struct _LstLst {
2301    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
2302}
2303#[doc(hidden)]
2304#[allow(non_snake_case)]
2305pub fn _LstLst<S: ::m2_syn::Spanned>(span: S) -> _LstLst {
2306    let span = span.span();
2307    _LstLst {
2308        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("<<", span))),
2309    }
2310}
2311impl ::m2_syn::Token for _LstLst {
2312    const SPELLING: &'static str = "<<";
2313    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
2314        match token {
2315            ::m2_syn::TokenTree::Punct(token) => token.text() == "<<",
2316            _ => false,
2317        }
2318    }
2319    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2320        Self::matches_token_tree(&token).then_some(Self {
2321            raw: ::std::boxed::Box::new(token),
2322        })
2323    }
2324}
2325impl ::m2_syn::Parse for _LstLst {
2326    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2327        input.parse_token()
2328    }
2329}
2330impl ::m2_syn::ToTokens for _LstLst {
2331    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2332        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2333    }
2334}
2335impl ::m2_syn::PrettyTree for _LstLst {
2336    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2337        ::m2_syn::PrettyNode::token(
2338            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2339            <Self as ::m2_syn::Token>::SPELLING,
2340            ::m2_syn::Spanned::span(self),
2341        )
2342    }
2343}
2344impl<N> ::m2_syn::Reconstruct<N> for _LstLst
2345where
2346    N: ::m2_syn::ExternalCstNode,
2347{
2348    fn matches(node: &N) -> bool {
2349        node.identity().matches("<<", false)
2350    }
2351    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2352        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2353            return Err(::m2_syn::ReconstructError::wrong_node(
2354                "<<",
2355                false,
2356                node.identity(),
2357            ));
2358        }
2359        Ok(_LstLst(node.span()))
2360    }
2361}
2362#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
2363pub struct _LstLstEql {
2364    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
2365}
2366#[doc(hidden)]
2367#[allow(non_snake_case)]
2368pub fn _LstLstEql<S: ::m2_syn::Spanned>(span: S) -> _LstLstEql {
2369    let span = span.span();
2370    _LstLstEql {
2371        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
2372            "<<=", span,
2373        ))),
2374    }
2375}
2376impl ::m2_syn::Token for _LstLstEql {
2377    const SPELLING: &'static str = "<<=";
2378    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
2379        match token {
2380            ::m2_syn::TokenTree::Punct(token) => token.text() == "<<=",
2381            _ => false,
2382        }
2383    }
2384    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2385        Self::matches_token_tree(&token).then_some(Self {
2386            raw: ::std::boxed::Box::new(token),
2387        })
2388    }
2389}
2390impl ::m2_syn::Parse for _LstLstEql {
2391    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2392        input.parse_token()
2393    }
2394}
2395impl ::m2_syn::ToTokens for _LstLstEql {
2396    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2397        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2398    }
2399}
2400impl ::m2_syn::PrettyTree for _LstLstEql {
2401    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2402        ::m2_syn::PrettyNode::token(
2403            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2404            <Self as ::m2_syn::Token>::SPELLING,
2405            ::m2_syn::Spanned::span(self),
2406        )
2407    }
2408}
2409impl<N> ::m2_syn::Reconstruct<N> for _LstLstEql
2410where
2411    N: ::m2_syn::ExternalCstNode,
2412{
2413    fn matches(node: &N) -> bool {
2414        node.identity().matches("<<=", false)
2415    }
2416    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2417        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2418            return Err(::m2_syn::ReconstructError::wrong_node(
2419                "<<=",
2420                false,
2421                node.identity(),
2422            ));
2423        }
2424        Ok(_LstLstEql(node.span()))
2425    }
2426}
2427#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
2428pub struct _LstEql {
2429    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
2430}
2431#[doc(hidden)]
2432#[allow(non_snake_case)]
2433pub fn _LstEql<S: ::m2_syn::Spanned>(span: S) -> _LstEql {
2434    let span = span.span();
2435    _LstEql {
2436        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("<=", span))),
2437    }
2438}
2439impl ::m2_syn::Token for _LstEql {
2440    const SPELLING: &'static str = "<=";
2441    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
2442        match token {
2443            ::m2_syn::TokenTree::Punct(token) => token.text() == "<=",
2444            _ => false,
2445        }
2446    }
2447    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2448        Self::matches_token_tree(&token).then_some(Self {
2449            raw: ::std::boxed::Box::new(token),
2450        })
2451    }
2452}
2453impl ::m2_syn::Parse for _LstEql {
2454    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2455        input.parse_token()
2456    }
2457}
2458impl ::m2_syn::ToTokens for _LstEql {
2459    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2460        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2461    }
2462}
2463impl ::m2_syn::PrettyTree for _LstEql {
2464    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2465        ::m2_syn::PrettyNode::token(
2466            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2467            <Self as ::m2_syn::Token>::SPELLING,
2468            ::m2_syn::Spanned::span(self),
2469        )
2470    }
2471}
2472impl<N> ::m2_syn::Reconstruct<N> for _LstEql
2473where
2474    N: ::m2_syn::ExternalCstNode,
2475{
2476    fn matches(node: &N) -> bool {
2477        node.identity().matches("<=", false)
2478    }
2479    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2480        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2481            return Err(::m2_syn::ReconstructError::wrong_node(
2482                "<=",
2483                false,
2484                node.identity(),
2485            ));
2486        }
2487        Ok(_LstEql(node.span()))
2488    }
2489}
2490#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
2491pub struct _LstEqlEql {
2492    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
2493}
2494#[doc(hidden)]
2495#[allow(non_snake_case)]
2496pub fn _LstEqlEql<S: ::m2_syn::Spanned>(span: S) -> _LstEqlEql {
2497    let span = span.span();
2498    _LstEqlEql {
2499        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
2500            "<==", span,
2501        ))),
2502    }
2503}
2504impl ::m2_syn::Token for _LstEqlEql {
2505    const SPELLING: &'static str = "<==";
2506    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
2507        match token {
2508            ::m2_syn::TokenTree::Punct(token) => token.text() == "<==",
2509            _ => false,
2510        }
2511    }
2512    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2513        Self::matches_token_tree(&token).then_some(Self {
2514            raw: ::std::boxed::Box::new(token),
2515        })
2516    }
2517}
2518impl ::m2_syn::Parse for _LstEqlEql {
2519    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2520        input.parse_token()
2521    }
2522}
2523impl ::m2_syn::ToTokens for _LstEqlEql {
2524    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2525        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2526    }
2527}
2528impl ::m2_syn::PrettyTree for _LstEqlEql {
2529    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2530        ::m2_syn::PrettyNode::token(
2531            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2532            <Self as ::m2_syn::Token>::SPELLING,
2533            ::m2_syn::Spanned::span(self),
2534        )
2535    }
2536}
2537impl<N> ::m2_syn::Reconstruct<N> for _LstEqlEql
2538where
2539    N: ::m2_syn::ExternalCstNode,
2540{
2541    fn matches(node: &N) -> bool {
2542        node.identity().matches("<==", false)
2543    }
2544    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2545        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2546            return Err(::m2_syn::ReconstructError::wrong_node(
2547                "<==",
2548                false,
2549                node.identity(),
2550            ));
2551        }
2552        Ok(_LstEqlEql(node.span()))
2553    }
2554}
2555#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
2556pub struct _LstEqlEqlEql {
2557    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
2558}
2559#[doc(hidden)]
2560#[allow(non_snake_case)]
2561pub fn _LstEqlEqlEql<S: ::m2_syn::Spanned>(span: S) -> _LstEqlEqlEql {
2562    let span = span.span();
2563    _LstEqlEqlEql {
2564        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
2565            "<===", span,
2566        ))),
2567    }
2568}
2569impl ::m2_syn::Token for _LstEqlEqlEql {
2570    const SPELLING: &'static str = "<===";
2571    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
2572        match token {
2573            ::m2_syn::TokenTree::Punct(token) => token.text() == "<===",
2574            _ => false,
2575        }
2576    }
2577    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2578        Self::matches_token_tree(&token).then_some(Self {
2579            raw: ::std::boxed::Box::new(token),
2580        })
2581    }
2582}
2583impl ::m2_syn::Parse for _LstEqlEqlEql {
2584    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2585        input.parse_token()
2586    }
2587}
2588impl ::m2_syn::ToTokens for _LstEqlEqlEql {
2589    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2590        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2591    }
2592}
2593impl ::m2_syn::PrettyTree for _LstEqlEqlEql {
2594    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2595        ::m2_syn::PrettyNode::token(
2596            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2597            <Self as ::m2_syn::Token>::SPELLING,
2598            ::m2_syn::Spanned::span(self),
2599        )
2600    }
2601}
2602impl<N> ::m2_syn::Reconstruct<N> for _LstEqlEqlEql
2603where
2604    N: ::m2_syn::ExternalCstNode,
2605{
2606    fn matches(node: &N) -> bool {
2607        node.identity().matches("<===", false)
2608    }
2609    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2610        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2611            return Err(::m2_syn::ReconstructError::wrong_node(
2612                "<===",
2613                false,
2614                node.identity(),
2615            ));
2616        }
2617        Ok(_LstEqlEqlEql(node.span()))
2618    }
2619}
2620#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
2621pub struct _LstEqlEqlGst {
2622    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
2623}
2624#[doc(hidden)]
2625#[allow(non_snake_case)]
2626pub fn _LstEqlEqlGst<S: ::m2_syn::Spanned>(span: S) -> _LstEqlEqlGst {
2627    let span = span.span();
2628    _LstEqlEqlGst {
2629        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
2630            "<==>", span,
2631        ))),
2632    }
2633}
2634impl ::m2_syn::Token for _LstEqlEqlGst {
2635    const SPELLING: &'static str = "<==>";
2636    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
2637        match token {
2638            ::m2_syn::TokenTree::Punct(token) => token.text() == "<==>",
2639            _ => false,
2640        }
2641    }
2642    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2643        Self::matches_token_tree(&token).then_some(Self {
2644            raw: ::std::boxed::Box::new(token),
2645        })
2646    }
2647}
2648impl ::m2_syn::Parse for _LstEqlEqlGst {
2649    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2650        input.parse_token()
2651    }
2652}
2653impl ::m2_syn::ToTokens for _LstEqlEqlGst {
2654    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2655        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2656    }
2657}
2658impl ::m2_syn::PrettyTree for _LstEqlEqlGst {
2659    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2660        ::m2_syn::PrettyNode::token(
2661            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2662            <Self as ::m2_syn::Token>::SPELLING,
2663            ::m2_syn::Spanned::span(self),
2664        )
2665    }
2666}
2667impl<N> ::m2_syn::Reconstruct<N> for _LstEqlEqlGst
2668where
2669    N: ::m2_syn::ExternalCstNode,
2670{
2671    fn matches(node: &N) -> bool {
2672        node.identity().matches("<==>", false)
2673    }
2674    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2675        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2676            return Err(::m2_syn::ReconstructError::wrong_node(
2677                "<==>",
2678                false,
2679                node.identity(),
2680            ));
2681        }
2682        Ok(_LstEqlEqlGst(node.span()))
2683    }
2684}
2685#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
2686pub struct _LstEqlEqlGstEql {
2687    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
2688}
2689#[doc(hidden)]
2690#[allow(non_snake_case)]
2691pub fn _LstEqlEqlGstEql<S: ::m2_syn::Spanned>(span: S) -> _LstEqlEqlGstEql {
2692    let span = span.span();
2693    _LstEqlEqlGstEql {
2694        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
2695            "<==>=", span,
2696        ))),
2697    }
2698}
2699impl ::m2_syn::Token for _LstEqlEqlGstEql {
2700    const SPELLING: &'static str = "<==>=";
2701    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
2702        match token {
2703            ::m2_syn::TokenTree::Punct(token) => token.text() == "<==>=",
2704            _ => false,
2705        }
2706    }
2707    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2708        Self::matches_token_tree(&token).then_some(Self {
2709            raw: ::std::boxed::Box::new(token),
2710        })
2711    }
2712}
2713impl ::m2_syn::Parse for _LstEqlEqlGstEql {
2714    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2715        input.parse_token()
2716    }
2717}
2718impl ::m2_syn::ToTokens for _LstEqlEqlGstEql {
2719    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2720        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2721    }
2722}
2723impl ::m2_syn::PrettyTree for _LstEqlEqlGstEql {
2724    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2725        ::m2_syn::PrettyNode::token(
2726            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2727            <Self as ::m2_syn::Token>::SPELLING,
2728            ::m2_syn::Spanned::span(self),
2729        )
2730    }
2731}
2732impl<N> ::m2_syn::Reconstruct<N> for _LstEqlEqlGstEql
2733where
2734    N: ::m2_syn::ExternalCstNode,
2735{
2736    fn matches(node: &N) -> bool {
2737        node.identity().matches("<==>=", false)
2738    }
2739    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2740        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2741            return Err(::m2_syn::ReconstructError::wrong_node(
2742                "<==>=",
2743                false,
2744                node.identity(),
2745            ));
2746        }
2747        Ok(_LstEqlEqlGstEql(node.span()))
2748    }
2749}
2750#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
2751pub struct _Eql {
2752    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
2753}
2754#[doc(hidden)]
2755#[allow(non_snake_case)]
2756pub fn _Eql<S: ::m2_syn::Spanned>(span: S) -> _Eql {
2757    let span = span.span();
2758    _Eql {
2759        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("=", span))),
2760    }
2761}
2762impl ::m2_syn::Token for _Eql {
2763    const SPELLING: &'static str = "=";
2764    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
2765        match token {
2766            ::m2_syn::TokenTree::Punct(token) => token.text() == "=",
2767            _ => false,
2768        }
2769    }
2770    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2771        Self::matches_token_tree(&token).then_some(Self {
2772            raw: ::std::boxed::Box::new(token),
2773        })
2774    }
2775}
2776impl ::m2_syn::Parse for _Eql {
2777    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2778        input.parse_token()
2779    }
2780}
2781impl ::m2_syn::ToTokens for _Eql {
2782    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2783        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2784    }
2785}
2786impl ::m2_syn::PrettyTree for _Eql {
2787    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2788        ::m2_syn::PrettyNode::token(
2789            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2790            <Self as ::m2_syn::Token>::SPELLING,
2791            ::m2_syn::Spanned::span(self),
2792        )
2793    }
2794}
2795impl<N> ::m2_syn::Reconstruct<N> for _Eql
2796where
2797    N: ::m2_syn::ExternalCstNode,
2798{
2799    fn matches(node: &N) -> bool {
2800        node.identity().matches("=", false)
2801    }
2802    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2803        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2804            return Err(::m2_syn::ReconstructError::wrong_node(
2805                "=",
2806                false,
2807                node.identity(),
2808            ));
2809        }
2810        Ok(_Eql(node.span()))
2811    }
2812}
2813#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
2814pub struct _EqlBngEql {
2815    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
2816}
2817#[doc(hidden)]
2818#[allow(non_snake_case)]
2819pub fn _EqlBngEql<S: ::m2_syn::Spanned>(span: S) -> _EqlBngEql {
2820    let span = span.span();
2821    _EqlBngEql {
2822        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
2823            "=!=", span,
2824        ))),
2825    }
2826}
2827impl ::m2_syn::Token for _EqlBngEql {
2828    const SPELLING: &'static str = "=!=";
2829    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
2830        match token {
2831            ::m2_syn::TokenTree::Punct(token) => token.text() == "=!=",
2832            _ => false,
2833        }
2834    }
2835    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2836        Self::matches_token_tree(&token).then_some(Self {
2837            raw: ::std::boxed::Box::new(token),
2838        })
2839    }
2840}
2841impl ::m2_syn::Parse for _EqlBngEql {
2842    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2843        input.parse_token()
2844    }
2845}
2846impl ::m2_syn::ToTokens for _EqlBngEql {
2847    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2848        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2849    }
2850}
2851impl ::m2_syn::PrettyTree for _EqlBngEql {
2852    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2853        ::m2_syn::PrettyNode::token(
2854            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2855            <Self as ::m2_syn::Token>::SPELLING,
2856            ::m2_syn::Spanned::span(self),
2857        )
2858    }
2859}
2860impl<N> ::m2_syn::Reconstruct<N> for _EqlBngEql
2861where
2862    N: ::m2_syn::ExternalCstNode,
2863{
2864    fn matches(node: &N) -> bool {
2865        node.identity().matches("=!=", false)
2866    }
2867    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2868        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2869            return Err(::m2_syn::ReconstructError::wrong_node(
2870                "=!=",
2871                false,
2872                node.identity(),
2873            ));
2874        }
2875        Ok(_EqlBngEql(node.span()))
2876    }
2877}
2878#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
2879pub struct _EqlEql {
2880    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
2881}
2882#[doc(hidden)]
2883#[allow(non_snake_case)]
2884pub fn _EqlEql<S: ::m2_syn::Spanned>(span: S) -> _EqlEql {
2885    let span = span.span();
2886    _EqlEql {
2887        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("==", span))),
2888    }
2889}
2890impl ::m2_syn::Token for _EqlEql {
2891    const SPELLING: &'static str = "==";
2892    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
2893        match token {
2894            ::m2_syn::TokenTree::Punct(token) => token.text() == "==",
2895            _ => false,
2896        }
2897    }
2898    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2899        Self::matches_token_tree(&token).then_some(Self {
2900            raw: ::std::boxed::Box::new(token),
2901        })
2902    }
2903}
2904impl ::m2_syn::Parse for _EqlEql {
2905    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2906        input.parse_token()
2907    }
2908}
2909impl ::m2_syn::ToTokens for _EqlEql {
2910    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2911        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2912    }
2913}
2914impl ::m2_syn::PrettyTree for _EqlEql {
2915    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2916        ::m2_syn::PrettyNode::token(
2917            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2918            <Self as ::m2_syn::Token>::SPELLING,
2919            ::m2_syn::Spanned::span(self),
2920        )
2921    }
2922}
2923impl<N> ::m2_syn::Reconstruct<N> for _EqlEql
2924where
2925    N: ::m2_syn::ExternalCstNode,
2926{
2927    fn matches(node: &N) -> bool {
2928        node.identity().matches("==", false)
2929    }
2930    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2931        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2932            return Err(::m2_syn::ReconstructError::wrong_node(
2933                "==",
2934                false,
2935                node.identity(),
2936            ));
2937        }
2938        Ok(_EqlEql(node.span()))
2939    }
2940}
2941#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
2942pub struct _EqlEqlEql {
2943    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
2944}
2945#[doc(hidden)]
2946#[allow(non_snake_case)]
2947pub fn _EqlEqlEql<S: ::m2_syn::Spanned>(span: S) -> _EqlEqlEql {
2948    let span = span.span();
2949    _EqlEqlEql {
2950        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
2951            "===", span,
2952        ))),
2953    }
2954}
2955impl ::m2_syn::Token for _EqlEqlEql {
2956    const SPELLING: &'static str = "===";
2957    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
2958        match token {
2959            ::m2_syn::TokenTree::Punct(token) => token.text() == "===",
2960            _ => false,
2961        }
2962    }
2963    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
2964        Self::matches_token_tree(&token).then_some(Self {
2965            raw: ::std::boxed::Box::new(token),
2966        })
2967    }
2968}
2969impl ::m2_syn::Parse for _EqlEqlEql {
2970    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
2971        input.parse_token()
2972    }
2973}
2974impl ::m2_syn::ToTokens for _EqlEqlEql {
2975    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2976        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
2977    }
2978}
2979impl ::m2_syn::PrettyTree for _EqlEqlEql {
2980    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2981        ::m2_syn::PrettyNode::token(
2982            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
2983            <Self as ::m2_syn::Token>::SPELLING,
2984            ::m2_syn::Spanned::span(self),
2985        )
2986    }
2987}
2988impl<N> ::m2_syn::Reconstruct<N> for _EqlEqlEql
2989where
2990    N: ::m2_syn::ExternalCstNode,
2991{
2992    fn matches(node: &N) -> bool {
2993        node.identity().matches("===", false)
2994    }
2995    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2996        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2997            return Err(::m2_syn::ReconstructError::wrong_node(
2998                "===",
2999                false,
3000                node.identity(),
3001            ));
3002        }
3003        Ok(_EqlEqlEql(node.span()))
3004    }
3005}
3006#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3007pub struct _EqlEqlEqlGst {
3008    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3009}
3010#[doc(hidden)]
3011#[allow(non_snake_case)]
3012pub fn _EqlEqlEqlGst<S: ::m2_syn::Spanned>(span: S) -> _EqlEqlEqlGst {
3013    let span = span.span();
3014    _EqlEqlEqlGst {
3015        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
3016            "===>", span,
3017        ))),
3018    }
3019}
3020impl ::m2_syn::Token for _EqlEqlEqlGst {
3021    const SPELLING: &'static str = "===>";
3022    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3023        match token {
3024            ::m2_syn::TokenTree::Punct(token) => token.text() == "===>",
3025            _ => false,
3026        }
3027    }
3028    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3029        Self::matches_token_tree(&token).then_some(Self {
3030            raw: ::std::boxed::Box::new(token),
3031        })
3032    }
3033}
3034impl ::m2_syn::Parse for _EqlEqlEqlGst {
3035    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3036        input.parse_token()
3037    }
3038}
3039impl ::m2_syn::ToTokens for _EqlEqlEqlGst {
3040    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3041        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3042    }
3043}
3044impl ::m2_syn::PrettyTree for _EqlEqlEqlGst {
3045    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3046        ::m2_syn::PrettyNode::token(
3047            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
3048            <Self as ::m2_syn::Token>::SPELLING,
3049            ::m2_syn::Spanned::span(self),
3050        )
3051    }
3052}
3053impl<N> ::m2_syn::Reconstruct<N> for _EqlEqlEqlGst
3054where
3055    N: ::m2_syn::ExternalCstNode,
3056{
3057    fn matches(node: &N) -> bool {
3058        node.identity().matches("===>", false)
3059    }
3060    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3061        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3062            return Err(::m2_syn::ReconstructError::wrong_node(
3063                "===>",
3064                false,
3065                node.identity(),
3066            ));
3067        }
3068        Ok(_EqlEqlEqlGst(node.span()))
3069    }
3070}
3071#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3072pub struct _EqlEqlEqlGstEql {
3073    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3074}
3075#[doc(hidden)]
3076#[allow(non_snake_case)]
3077pub fn _EqlEqlEqlGstEql<S: ::m2_syn::Spanned>(span: S) -> _EqlEqlEqlGstEql {
3078    let span = span.span();
3079    _EqlEqlEqlGstEql {
3080        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
3081            "===>=", span,
3082        ))),
3083    }
3084}
3085impl ::m2_syn::Token for _EqlEqlEqlGstEql {
3086    const SPELLING: &'static str = "===>=";
3087    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3088        match token {
3089            ::m2_syn::TokenTree::Punct(token) => token.text() == "===>=",
3090            _ => false,
3091        }
3092    }
3093    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3094        Self::matches_token_tree(&token).then_some(Self {
3095            raw: ::std::boxed::Box::new(token),
3096        })
3097    }
3098}
3099impl ::m2_syn::Parse for _EqlEqlEqlGstEql {
3100    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3101        input.parse_token()
3102    }
3103}
3104impl ::m2_syn::ToTokens for _EqlEqlEqlGstEql {
3105    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3106        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3107    }
3108}
3109impl ::m2_syn::PrettyTree for _EqlEqlEqlGstEql {
3110    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3111        ::m2_syn::PrettyNode::token(
3112            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
3113            <Self as ::m2_syn::Token>::SPELLING,
3114            ::m2_syn::Spanned::span(self),
3115        )
3116    }
3117}
3118impl<N> ::m2_syn::Reconstruct<N> for _EqlEqlEqlGstEql
3119where
3120    N: ::m2_syn::ExternalCstNode,
3121{
3122    fn matches(node: &N) -> bool {
3123        node.identity().matches("===>=", false)
3124    }
3125    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3126        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3127            return Err(::m2_syn::ReconstructError::wrong_node(
3128                "===>=",
3129                false,
3130                node.identity(),
3131            ));
3132        }
3133        Ok(_EqlEqlEqlGstEql(node.span()))
3134    }
3135}
3136#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3137pub struct _EqlEqlGst {
3138    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3139}
3140#[doc(hidden)]
3141#[allow(non_snake_case)]
3142pub fn _EqlEqlGst<S: ::m2_syn::Spanned>(span: S) -> _EqlEqlGst {
3143    let span = span.span();
3144    _EqlEqlGst {
3145        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
3146            "==>", span,
3147        ))),
3148    }
3149}
3150impl ::m2_syn::Token for _EqlEqlGst {
3151    const SPELLING: &'static str = "==>";
3152    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3153        match token {
3154            ::m2_syn::TokenTree::Punct(token) => token.text() == "==>",
3155            _ => false,
3156        }
3157    }
3158    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3159        Self::matches_token_tree(&token).then_some(Self {
3160            raw: ::std::boxed::Box::new(token),
3161        })
3162    }
3163}
3164impl ::m2_syn::Parse for _EqlEqlGst {
3165    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3166        input.parse_token()
3167    }
3168}
3169impl ::m2_syn::ToTokens for _EqlEqlGst {
3170    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3171        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3172    }
3173}
3174impl ::m2_syn::PrettyTree for _EqlEqlGst {
3175    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3176        ::m2_syn::PrettyNode::token(
3177            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
3178            <Self as ::m2_syn::Token>::SPELLING,
3179            ::m2_syn::Spanned::span(self),
3180        )
3181    }
3182}
3183impl<N> ::m2_syn::Reconstruct<N> for _EqlEqlGst
3184where
3185    N: ::m2_syn::ExternalCstNode,
3186{
3187    fn matches(node: &N) -> bool {
3188        node.identity().matches("==>", false)
3189    }
3190    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3191        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3192            return Err(::m2_syn::ReconstructError::wrong_node(
3193                "==>",
3194                false,
3195                node.identity(),
3196            ));
3197        }
3198        Ok(_EqlEqlGst(node.span()))
3199    }
3200}
3201#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3202pub struct _EqlEqlGstEql {
3203    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3204}
3205#[doc(hidden)]
3206#[allow(non_snake_case)]
3207pub fn _EqlEqlGstEql<S: ::m2_syn::Spanned>(span: S) -> _EqlEqlGstEql {
3208    let span = span.span();
3209    _EqlEqlGstEql {
3210        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
3211            "==>=", span,
3212        ))),
3213    }
3214}
3215impl ::m2_syn::Token for _EqlEqlGstEql {
3216    const SPELLING: &'static str = "==>=";
3217    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3218        match token {
3219            ::m2_syn::TokenTree::Punct(token) => token.text() == "==>=",
3220            _ => false,
3221        }
3222    }
3223    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3224        Self::matches_token_tree(&token).then_some(Self {
3225            raw: ::std::boxed::Box::new(token),
3226        })
3227    }
3228}
3229impl ::m2_syn::Parse for _EqlEqlGstEql {
3230    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3231        input.parse_token()
3232    }
3233}
3234impl ::m2_syn::ToTokens for _EqlEqlGstEql {
3235    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3236        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3237    }
3238}
3239impl ::m2_syn::PrettyTree for _EqlEqlGstEql {
3240    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3241        ::m2_syn::PrettyNode::token(
3242            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
3243            <Self as ::m2_syn::Token>::SPELLING,
3244            ::m2_syn::Spanned::span(self),
3245        )
3246    }
3247}
3248impl<N> ::m2_syn::Reconstruct<N> for _EqlEqlGstEql
3249where
3250    N: ::m2_syn::ExternalCstNode,
3251{
3252    fn matches(node: &N) -> bool {
3253        node.identity().matches("==>=", false)
3254    }
3255    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3256        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3257            return Err(::m2_syn::ReconstructError::wrong_node(
3258                "==>=",
3259                false,
3260                node.identity(),
3261            ));
3262        }
3263        Ok(_EqlEqlGstEql(node.span()))
3264    }
3265}
3266#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3267pub struct _EqlGst {
3268    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3269}
3270#[doc(hidden)]
3271#[allow(non_snake_case)]
3272pub fn _EqlGst<S: ::m2_syn::Spanned>(span: S) -> _EqlGst {
3273    let span = span.span();
3274    _EqlGst {
3275        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("=>", span))),
3276    }
3277}
3278impl ::m2_syn::Token for _EqlGst {
3279    const SPELLING: &'static str = "=>";
3280    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3281        match token {
3282            ::m2_syn::TokenTree::Punct(token) => token.text() == "=>",
3283            _ => false,
3284        }
3285    }
3286    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3287        Self::matches_token_tree(&token).then_some(Self {
3288            raw: ::std::boxed::Box::new(token),
3289        })
3290    }
3291}
3292impl ::m2_syn::Parse for _EqlGst {
3293    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3294        input.parse_token()
3295    }
3296}
3297impl ::m2_syn::ToTokens for _EqlGst {
3298    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3299        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3300    }
3301}
3302impl ::m2_syn::PrettyTree for _EqlGst {
3303    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3304        ::m2_syn::PrettyNode::token(
3305            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
3306            <Self as ::m2_syn::Token>::SPELLING,
3307            ::m2_syn::Spanned::span(self),
3308        )
3309    }
3310}
3311impl<N> ::m2_syn::Reconstruct<N> for _EqlGst
3312where
3313    N: ::m2_syn::ExternalCstNode,
3314{
3315    fn matches(node: &N) -> bool {
3316        node.identity().matches("=>", false)
3317    }
3318    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3319        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3320            return Err(::m2_syn::ReconstructError::wrong_node(
3321                "=>",
3322                false,
3323                node.identity(),
3324            ));
3325        }
3326        Ok(_EqlGst(node.span()))
3327    }
3328}
3329#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3330pub struct _Gst {
3331    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3332}
3333#[doc(hidden)]
3334#[allow(non_snake_case)]
3335pub fn _Gst<S: ::m2_syn::Spanned>(span: S) -> _Gst {
3336    let span = span.span();
3337    _Gst {
3338        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(">", span))),
3339    }
3340}
3341impl ::m2_syn::Token for _Gst {
3342    const SPELLING: &'static str = ">";
3343    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3344        match token {
3345            ::m2_syn::TokenTree::Punct(token) => token.text() == ">",
3346            _ => false,
3347        }
3348    }
3349    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3350        Self::matches_token_tree(&token).then_some(Self {
3351            raw: ::std::boxed::Box::new(token),
3352        })
3353    }
3354}
3355impl ::m2_syn::Parse for _Gst {
3356    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3357        input.parse_token()
3358    }
3359}
3360impl ::m2_syn::ToTokens for _Gst {
3361    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3362        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3363    }
3364}
3365impl ::m2_syn::PrettyTree for _Gst {
3366    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3367        ::m2_syn::PrettyNode::token(
3368            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
3369            <Self as ::m2_syn::Token>::SPELLING,
3370            ::m2_syn::Spanned::span(self),
3371        )
3372    }
3373}
3374impl<N> ::m2_syn::Reconstruct<N> for _Gst
3375where
3376    N: ::m2_syn::ExternalCstNode,
3377{
3378    fn matches(node: &N) -> bool {
3379        node.identity().matches(">", false)
3380    }
3381    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3382        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3383            return Err(::m2_syn::ReconstructError::wrong_node(
3384                ">",
3385                false,
3386                node.identity(),
3387            ));
3388        }
3389        Ok(_Gst(node.span()))
3390    }
3391}
3392#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3393pub struct _GstEql {
3394    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3395}
3396#[doc(hidden)]
3397#[allow(non_snake_case)]
3398pub fn _GstEql<S: ::m2_syn::Spanned>(span: S) -> _GstEql {
3399    let span = span.span();
3400    _GstEql {
3401        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(">=", span))),
3402    }
3403}
3404impl ::m2_syn::Token for _GstEql {
3405    const SPELLING: &'static str = ">=";
3406    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3407        match token {
3408            ::m2_syn::TokenTree::Punct(token) => token.text() == ">=",
3409            _ => false,
3410        }
3411    }
3412    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3413        Self::matches_token_tree(&token).then_some(Self {
3414            raw: ::std::boxed::Box::new(token),
3415        })
3416    }
3417}
3418impl ::m2_syn::Parse for _GstEql {
3419    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3420        input.parse_token()
3421    }
3422}
3423impl ::m2_syn::ToTokens for _GstEql {
3424    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3425        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3426    }
3427}
3428impl ::m2_syn::PrettyTree for _GstEql {
3429    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3430        ::m2_syn::PrettyNode::token(
3431            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
3432            <Self as ::m2_syn::Token>::SPELLING,
3433            ::m2_syn::Spanned::span(self),
3434        )
3435    }
3436}
3437impl<N> ::m2_syn::Reconstruct<N> for _GstEql
3438where
3439    N: ::m2_syn::ExternalCstNode,
3440{
3441    fn matches(node: &N) -> bool {
3442        node.identity().matches(">=", false)
3443    }
3444    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3445        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3446            return Err(::m2_syn::ReconstructError::wrong_node(
3447                ">=",
3448                false,
3449                node.identity(),
3450            ));
3451        }
3452        Ok(_GstEql(node.span()))
3453    }
3454}
3455#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3456pub struct _GstGst {
3457    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3458}
3459#[doc(hidden)]
3460#[allow(non_snake_case)]
3461pub fn _GstGst<S: ::m2_syn::Spanned>(span: S) -> _GstGst {
3462    let span = span.span();
3463    _GstGst {
3464        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(">>", span))),
3465    }
3466}
3467impl ::m2_syn::Token for _GstGst {
3468    const SPELLING: &'static str = ">>";
3469    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3470        match token {
3471            ::m2_syn::TokenTree::Punct(token) => token.text() == ">>",
3472            _ => false,
3473        }
3474    }
3475    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3476        Self::matches_token_tree(&token).then_some(Self {
3477            raw: ::std::boxed::Box::new(token),
3478        })
3479    }
3480}
3481impl ::m2_syn::Parse for _GstGst {
3482    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3483        input.parse_token()
3484    }
3485}
3486impl ::m2_syn::ToTokens for _GstGst {
3487    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3488        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3489    }
3490}
3491impl ::m2_syn::PrettyTree for _GstGst {
3492    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3493        ::m2_syn::PrettyNode::token(
3494            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
3495            <Self as ::m2_syn::Token>::SPELLING,
3496            ::m2_syn::Spanned::span(self),
3497        )
3498    }
3499}
3500impl<N> ::m2_syn::Reconstruct<N> for _GstGst
3501where
3502    N: ::m2_syn::ExternalCstNode,
3503{
3504    fn matches(node: &N) -> bool {
3505        node.identity().matches(">>", false)
3506    }
3507    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3508        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3509            return Err(::m2_syn::ReconstructError::wrong_node(
3510                ">>",
3511                false,
3512                node.identity(),
3513            ));
3514        }
3515        Ok(_GstGst(node.span()))
3516    }
3517}
3518#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3519pub struct _GstGstEql {
3520    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3521}
3522#[doc(hidden)]
3523#[allow(non_snake_case)]
3524pub fn _GstGstEql<S: ::m2_syn::Spanned>(span: S) -> _GstGstEql {
3525    let span = span.span();
3526    _GstGstEql {
3527        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
3528            ">>=", span,
3529        ))),
3530    }
3531}
3532impl ::m2_syn::Token for _GstGstEql {
3533    const SPELLING: &'static str = ">>=";
3534    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3535        match token {
3536            ::m2_syn::TokenTree::Punct(token) => token.text() == ">>=",
3537            _ => false,
3538        }
3539    }
3540    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3541        Self::matches_token_tree(&token).then_some(Self {
3542            raw: ::std::boxed::Box::new(token),
3543        })
3544    }
3545}
3546impl ::m2_syn::Parse for _GstGstEql {
3547    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3548        input.parse_token()
3549    }
3550}
3551impl ::m2_syn::ToTokens for _GstGstEql {
3552    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3553        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3554    }
3555}
3556impl ::m2_syn::PrettyTree for _GstGstEql {
3557    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3558        ::m2_syn::PrettyNode::token(
3559            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
3560            <Self as ::m2_syn::Token>::SPELLING,
3561            ::m2_syn::Spanned::span(self),
3562        )
3563    }
3564}
3565impl<N> ::m2_syn::Reconstruct<N> for _GstGstEql
3566where
3567    N: ::m2_syn::ExternalCstNode,
3568{
3569    fn matches(node: &N) -> bool {
3570        node.identity().matches(">>=", false)
3571    }
3572    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3573        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3574            return Err(::m2_syn::ReconstructError::wrong_node(
3575                ">>=",
3576                false,
3577                node.identity(),
3578            ));
3579        }
3580        Ok(_GstGstEql(node.span()))
3581    }
3582}
3583#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3584pub struct _Qsm {
3585    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3586}
3587#[doc(hidden)]
3588#[allow(non_snake_case)]
3589pub fn _Qsm<S: ::m2_syn::Spanned>(span: S) -> _Qsm {
3590    let span = span.span();
3591    _Qsm {
3592        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("?", span))),
3593    }
3594}
3595impl ::m2_syn::Token for _Qsm {
3596    const SPELLING: &'static str = "?";
3597    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3598        match token {
3599            ::m2_syn::TokenTree::Punct(token) => token.text() == "?",
3600            _ => false,
3601        }
3602    }
3603    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3604        Self::matches_token_tree(&token).then_some(Self {
3605            raw: ::std::boxed::Box::new(token),
3606        })
3607    }
3608}
3609impl ::m2_syn::Parse for _Qsm {
3610    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3611        input.parse_token()
3612    }
3613}
3614impl ::m2_syn::ToTokens for _Qsm {
3615    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3616        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3617    }
3618}
3619impl ::m2_syn::PrettyTree for _Qsm {
3620    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3621        ::m2_syn::PrettyNode::token(
3622            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
3623            <Self as ::m2_syn::Token>::SPELLING,
3624            ::m2_syn::Spanned::span(self),
3625        )
3626    }
3627}
3628impl<N> ::m2_syn::Reconstruct<N> for _Qsm
3629where
3630    N: ::m2_syn::ExternalCstNode,
3631{
3632    fn matches(node: &N) -> bool {
3633        node.identity().matches("?", false)
3634    }
3635    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3636        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3637            return Err(::m2_syn::ReconstructError::wrong_node(
3638                "?",
3639                false,
3640                node.identity(),
3641            ));
3642        }
3643        Ok(_Qsm(node.span()))
3644    }
3645}
3646#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3647pub struct _QsmQsm {
3648    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3649}
3650#[doc(hidden)]
3651#[allow(non_snake_case)]
3652pub fn _QsmQsm<S: ::m2_syn::Spanned>(span: S) -> _QsmQsm {
3653    let span = span.span();
3654    _QsmQsm {
3655        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("??", span))),
3656    }
3657}
3658impl ::m2_syn::Token for _QsmQsm {
3659    const SPELLING: &'static str = "??";
3660    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3661        match token {
3662            ::m2_syn::TokenTree::Punct(token) => token.text() == "??",
3663            _ => false,
3664        }
3665    }
3666    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3667        Self::matches_token_tree(&token).then_some(Self {
3668            raw: ::std::boxed::Box::new(token),
3669        })
3670    }
3671}
3672impl ::m2_syn::Parse for _QsmQsm {
3673    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3674        input.parse_token()
3675    }
3676}
3677impl ::m2_syn::ToTokens for _QsmQsm {
3678    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3679        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3680    }
3681}
3682impl ::m2_syn::PrettyTree for _QsmQsm {
3683    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3684        ::m2_syn::PrettyNode::token(
3685            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
3686            <Self as ::m2_syn::Token>::SPELLING,
3687            ::m2_syn::Spanned::span(self),
3688        )
3689    }
3690}
3691impl<N> ::m2_syn::Reconstruct<N> for _QsmQsm
3692where
3693    N: ::m2_syn::ExternalCstNode,
3694{
3695    fn matches(node: &N) -> bool {
3696        node.identity().matches("??", false)
3697    }
3698    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3699        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3700            return Err(::m2_syn::ReconstructError::wrong_node(
3701                "??",
3702                false,
3703                node.identity(),
3704            ));
3705        }
3706        Ok(_QsmQsm(node.span()))
3707    }
3708}
3709#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3710pub struct _QsmQsmEql {
3711    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3712}
3713#[doc(hidden)]
3714#[allow(non_snake_case)]
3715pub fn _QsmQsmEql<S: ::m2_syn::Spanned>(span: S) -> _QsmQsmEql {
3716    let span = span.span();
3717    _QsmQsmEql {
3718        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
3719            "??=", span,
3720        ))),
3721    }
3722}
3723impl ::m2_syn::Token for _QsmQsmEql {
3724    const SPELLING: &'static str = "??=";
3725    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3726        match token {
3727            ::m2_syn::TokenTree::Punct(token) => token.text() == "??=",
3728            _ => false,
3729        }
3730    }
3731    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3732        Self::matches_token_tree(&token).then_some(Self {
3733            raw: ::std::boxed::Box::new(token),
3734        })
3735    }
3736}
3737impl ::m2_syn::Parse for _QsmQsmEql {
3738    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3739        input.parse_token()
3740    }
3741}
3742impl ::m2_syn::ToTokens for _QsmQsmEql {
3743    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3744        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3745    }
3746}
3747impl ::m2_syn::PrettyTree for _QsmQsmEql {
3748    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3749        ::m2_syn::PrettyNode::token(
3750            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
3751            <Self as ::m2_syn::Token>::SPELLING,
3752            ::m2_syn::Spanned::span(self),
3753        )
3754    }
3755}
3756impl<N> ::m2_syn::Reconstruct<N> for _QsmQsmEql
3757where
3758    N: ::m2_syn::ExternalCstNode,
3759{
3760    fn matches(node: &N) -> bool {
3761        node.identity().matches("??=", false)
3762    }
3763    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3764        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3765            return Err(::m2_syn::ReconstructError::wrong_node(
3766                "??=",
3767                false,
3768                node.identity(),
3769            ));
3770        }
3771        Ok(_QsmQsmEql(node.span()))
3772    }
3773}
3774#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3775pub struct _Att {
3776    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3777}
3778#[doc(hidden)]
3779#[allow(non_snake_case)]
3780pub fn _Att<S: ::m2_syn::Spanned>(span: S) -> _Att {
3781    let span = span.span();
3782    _Att {
3783        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("@", span))),
3784    }
3785}
3786impl ::m2_syn::Token for _Att {
3787    const SPELLING: &'static str = "@";
3788    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3789        match token {
3790            ::m2_syn::TokenTree::Punct(token) => token.text() == "@",
3791            _ => false,
3792        }
3793    }
3794    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3795        Self::matches_token_tree(&token).then_some(Self {
3796            raw: ::std::boxed::Box::new(token),
3797        })
3798    }
3799}
3800impl ::m2_syn::Parse for _Att {
3801    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3802        input.parse_token()
3803    }
3804}
3805impl ::m2_syn::ToTokens for _Att {
3806    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3807        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3808    }
3809}
3810impl ::m2_syn::PrettyTree for _Att {
3811    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3812        ::m2_syn::PrettyNode::token(
3813            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
3814            <Self as ::m2_syn::Token>::SPELLING,
3815            ::m2_syn::Spanned::span(self),
3816        )
3817    }
3818}
3819impl<N> ::m2_syn::Reconstruct<N> for _Att
3820where
3821    N: ::m2_syn::ExternalCstNode,
3822{
3823    fn matches(node: &N) -> bool {
3824        node.identity().matches("@", false)
3825    }
3826    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3827        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3828            return Err(::m2_syn::ReconstructError::wrong_node(
3829                "@",
3830                false,
3831                node.identity(),
3832            ));
3833        }
3834        Ok(_Att(node.span()))
3835    }
3836}
3837#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3838pub struct _AttEql {
3839    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3840}
3841#[doc(hidden)]
3842#[allow(non_snake_case)]
3843pub fn _AttEql<S: ::m2_syn::Spanned>(span: S) -> _AttEql {
3844    let span = span.span();
3845    _AttEql {
3846        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("@=", span))),
3847    }
3848}
3849impl ::m2_syn::Token for _AttEql {
3850    const SPELLING: &'static str = "@=";
3851    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3852        match token {
3853            ::m2_syn::TokenTree::Punct(token) => token.text() == "@=",
3854            _ => false,
3855        }
3856    }
3857    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3858        Self::matches_token_tree(&token).then_some(Self {
3859            raw: ::std::boxed::Box::new(token),
3860        })
3861    }
3862}
3863impl ::m2_syn::Parse for _AttEql {
3864    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3865        input.parse_token()
3866    }
3867}
3868impl ::m2_syn::ToTokens for _AttEql {
3869    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3870        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3871    }
3872}
3873impl ::m2_syn::PrettyTree for _AttEql {
3874    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3875        ::m2_syn::PrettyNode::token(
3876            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
3877            <Self as ::m2_syn::Token>::SPELLING,
3878            ::m2_syn::Spanned::span(self),
3879        )
3880    }
3881}
3882impl<N> ::m2_syn::Reconstruct<N> for _AttEql
3883where
3884    N: ::m2_syn::ExternalCstNode,
3885{
3886    fn matches(node: &N) -> bool {
3887        node.identity().matches("@=", false)
3888    }
3889    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3890        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3891            return Err(::m2_syn::ReconstructError::wrong_node(
3892                "@=",
3893                false,
3894                node.identity(),
3895            ));
3896        }
3897        Ok(_AttEql(node.span()))
3898    }
3899}
3900#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3901pub struct _AttAtt {
3902    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3903}
3904#[doc(hidden)]
3905#[allow(non_snake_case)]
3906pub fn _AttAtt<S: ::m2_syn::Spanned>(span: S) -> _AttAtt {
3907    let span = span.span();
3908    _AttAtt {
3909        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("@@", span))),
3910    }
3911}
3912impl ::m2_syn::Token for _AttAtt {
3913    const SPELLING: &'static str = "@@";
3914    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3915        match token {
3916            ::m2_syn::TokenTree::Punct(token) => token.text() == "@@",
3917            _ => false,
3918        }
3919    }
3920    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3921        Self::matches_token_tree(&token).then_some(Self {
3922            raw: ::std::boxed::Box::new(token),
3923        })
3924    }
3925}
3926impl ::m2_syn::Parse for _AttAtt {
3927    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3928        input.parse_token()
3929    }
3930}
3931impl ::m2_syn::ToTokens for _AttAtt {
3932    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3933        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3934    }
3935}
3936impl ::m2_syn::PrettyTree for _AttAtt {
3937    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3938        ::m2_syn::PrettyNode::token(
3939            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
3940            <Self as ::m2_syn::Token>::SPELLING,
3941            ::m2_syn::Spanned::span(self),
3942        )
3943    }
3944}
3945impl<N> ::m2_syn::Reconstruct<N> for _AttAtt
3946where
3947    N: ::m2_syn::ExternalCstNode,
3948{
3949    fn matches(node: &N) -> bool {
3950        node.identity().matches("@@", false)
3951    }
3952    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3953        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3954            return Err(::m2_syn::ReconstructError::wrong_node(
3955                "@@",
3956                false,
3957                node.identity(),
3958            ));
3959        }
3960        Ok(_AttAtt(node.span()))
3961    }
3962}
3963#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
3964pub struct _AttAttEql {
3965    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
3966}
3967#[doc(hidden)]
3968#[allow(non_snake_case)]
3969pub fn _AttAttEql<S: ::m2_syn::Spanned>(span: S) -> _AttAttEql {
3970    let span = span.span();
3971    _AttAttEql {
3972        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
3973            "@@=", span,
3974        ))),
3975    }
3976}
3977impl ::m2_syn::Token for _AttAttEql {
3978    const SPELLING: &'static str = "@@=";
3979    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
3980        match token {
3981            ::m2_syn::TokenTree::Punct(token) => token.text() == "@@=",
3982            _ => false,
3983        }
3984    }
3985    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
3986        Self::matches_token_tree(&token).then_some(Self {
3987            raw: ::std::boxed::Box::new(token),
3988        })
3989    }
3990}
3991impl ::m2_syn::Parse for _AttAttEql {
3992    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
3993        input.parse_token()
3994    }
3995}
3996impl ::m2_syn::ToTokens for _AttAttEql {
3997    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3998        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
3999    }
4000}
4001impl ::m2_syn::PrettyTree for _AttAttEql {
4002    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4003        ::m2_syn::PrettyNode::token(
4004            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4005            <Self as ::m2_syn::Token>::SPELLING,
4006            ::m2_syn::Spanned::span(self),
4007        )
4008    }
4009}
4010impl<N> ::m2_syn::Reconstruct<N> for _AttAttEql
4011where
4012    N: ::m2_syn::ExternalCstNode,
4013{
4014    fn matches(node: &N) -> bool {
4015        node.identity().matches("@@=", false)
4016    }
4017    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4018        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4019            return Err(::m2_syn::ReconstructError::wrong_node(
4020                "@@=",
4021                false,
4022                node.identity(),
4023            ));
4024        }
4025        Ok(_AttAttEql(node.span()))
4026    }
4027}
4028#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4029pub struct _AttAttQsm {
4030    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4031}
4032#[doc(hidden)]
4033#[allow(non_snake_case)]
4034pub fn _AttAttQsm<S: ::m2_syn::Spanned>(span: S) -> _AttAttQsm {
4035    let span = span.span();
4036    _AttAttQsm {
4037        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
4038            "@@?", span,
4039        ))),
4040    }
4041}
4042impl ::m2_syn::Token for _AttAttQsm {
4043    const SPELLING: &'static str = "@@?";
4044    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
4045        match token {
4046            ::m2_syn::TokenTree::Punct(token) => token.text() == "@@?",
4047            _ => false,
4048        }
4049    }
4050    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
4051        Self::matches_token_tree(&token).then_some(Self {
4052            raw: ::std::boxed::Box::new(token),
4053        })
4054    }
4055}
4056impl ::m2_syn::Parse for _AttAttQsm {
4057    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
4058        input.parse_token()
4059    }
4060}
4061impl ::m2_syn::ToTokens for _AttAttQsm {
4062    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4063        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
4064    }
4065}
4066impl ::m2_syn::PrettyTree for _AttAttQsm {
4067    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4068        ::m2_syn::PrettyNode::token(
4069            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4070            <Self as ::m2_syn::Token>::SPELLING,
4071            ::m2_syn::Spanned::span(self),
4072        )
4073    }
4074}
4075impl<N> ::m2_syn::Reconstruct<N> for _AttAttQsm
4076where
4077    N: ::m2_syn::ExternalCstNode,
4078{
4079    fn matches(node: &N) -> bool {
4080        node.identity().matches("@@?", false)
4081    }
4082    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4083        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4084            return Err(::m2_syn::ReconstructError::wrong_node(
4085                "@@?",
4086                false,
4087                node.identity(),
4088            ));
4089        }
4090        Ok(_AttAttQsm(node.span()))
4091    }
4092}
4093#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4094pub struct _AttAttQsmEql {
4095    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4096}
4097#[doc(hidden)]
4098#[allow(non_snake_case)]
4099pub fn _AttAttQsmEql<S: ::m2_syn::Spanned>(span: S) -> _AttAttQsmEql {
4100    let span = span.span();
4101    _AttAttQsmEql {
4102        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
4103            "@@?=", span,
4104        ))),
4105    }
4106}
4107impl ::m2_syn::Token for _AttAttQsmEql {
4108    const SPELLING: &'static str = "@@?=";
4109    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
4110        match token {
4111            ::m2_syn::TokenTree::Punct(token) => token.text() == "@@?=",
4112            _ => false,
4113        }
4114    }
4115    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
4116        Self::matches_token_tree(&token).then_some(Self {
4117            raw: ::std::boxed::Box::new(token),
4118        })
4119    }
4120}
4121impl ::m2_syn::Parse for _AttAttQsmEql {
4122    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
4123        input.parse_token()
4124    }
4125}
4126impl ::m2_syn::ToTokens for _AttAttQsmEql {
4127    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4128        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
4129    }
4130}
4131impl ::m2_syn::PrettyTree for _AttAttQsmEql {
4132    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4133        ::m2_syn::PrettyNode::token(
4134            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4135            <Self as ::m2_syn::Token>::SPELLING,
4136            ::m2_syn::Spanned::span(self),
4137        )
4138    }
4139}
4140impl<N> ::m2_syn::Reconstruct<N> for _AttAttQsmEql
4141where
4142    N: ::m2_syn::ExternalCstNode,
4143{
4144    fn matches(node: &N) -> bool {
4145        node.identity().matches("@@?=", false)
4146    }
4147    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4148        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4149            return Err(::m2_syn::ReconstructError::wrong_node(
4150                "@@?=",
4151                false,
4152                node.identity(),
4153            ));
4154        }
4155        Ok(_AttAttQsmEql(node.span()))
4156    }
4157}
4158#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4159pub struct _Bsl {
4160    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4161}
4162#[doc(hidden)]
4163#[allow(non_snake_case)]
4164pub fn _Bsl<S: ::m2_syn::Spanned>(span: S) -> _Bsl {
4165    let span = span.span();
4166    _Bsl {
4167        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("\\", span))),
4168    }
4169}
4170impl ::m2_syn::Token for _Bsl {
4171    const SPELLING: &'static str = "\\";
4172    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
4173        match token {
4174            ::m2_syn::TokenTree::Punct(token) => token.text() == "\\",
4175            _ => false,
4176        }
4177    }
4178    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
4179        Self::matches_token_tree(&token).then_some(Self {
4180            raw: ::std::boxed::Box::new(token),
4181        })
4182    }
4183}
4184impl ::m2_syn::Parse for _Bsl {
4185    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
4186        input.parse_token()
4187    }
4188}
4189impl ::m2_syn::ToTokens for _Bsl {
4190    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4191        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
4192    }
4193}
4194impl ::m2_syn::PrettyTree for _Bsl {
4195    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4196        ::m2_syn::PrettyNode::token(
4197            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4198            <Self as ::m2_syn::Token>::SPELLING,
4199            ::m2_syn::Spanned::span(self),
4200        )
4201    }
4202}
4203impl<N> ::m2_syn::Reconstruct<N> for _Bsl
4204where
4205    N: ::m2_syn::ExternalCstNode,
4206{
4207    fn matches(node: &N) -> bool {
4208        node.identity().matches("\\", false)
4209    }
4210    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4211        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4212            return Err(::m2_syn::ReconstructError::wrong_node(
4213                "\\",
4214                false,
4215                node.identity(),
4216            ));
4217        }
4218        Ok(_Bsl(node.span()))
4219    }
4220}
4221#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4222pub struct _BslEql {
4223    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4224}
4225#[doc(hidden)]
4226#[allow(non_snake_case)]
4227pub fn _BslEql<S: ::m2_syn::Spanned>(span: S) -> _BslEql {
4228    let span = span.span();
4229    _BslEql {
4230        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
4231            "\\=", span,
4232        ))),
4233    }
4234}
4235impl ::m2_syn::Token for _BslEql {
4236    const SPELLING: &'static str = "\\=";
4237    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
4238        match token {
4239            ::m2_syn::TokenTree::Punct(token) => token.text() == "\\=",
4240            _ => false,
4241        }
4242    }
4243    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
4244        Self::matches_token_tree(&token).then_some(Self {
4245            raw: ::std::boxed::Box::new(token),
4246        })
4247    }
4248}
4249impl ::m2_syn::Parse for _BslEql {
4250    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
4251        input.parse_token()
4252    }
4253}
4254impl ::m2_syn::ToTokens for _BslEql {
4255    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4256        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
4257    }
4258}
4259impl ::m2_syn::PrettyTree for _BslEql {
4260    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4261        ::m2_syn::PrettyNode::token(
4262            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4263            <Self as ::m2_syn::Token>::SPELLING,
4264            ::m2_syn::Spanned::span(self),
4265        )
4266    }
4267}
4268impl<N> ::m2_syn::Reconstruct<N> for _BslEql
4269where
4270    N: ::m2_syn::ExternalCstNode,
4271{
4272    fn matches(node: &N) -> bool {
4273        node.identity().matches("\\=", false)
4274    }
4275    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4276        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4277            return Err(::m2_syn::ReconstructError::wrong_node(
4278                "\\=",
4279                false,
4280                node.identity(),
4281            ));
4282        }
4283        Ok(_BslEql(node.span()))
4284    }
4285}
4286#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4287pub struct _BslBsl {
4288    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4289}
4290#[doc(hidden)]
4291#[allow(non_snake_case)]
4292pub fn _BslBsl<S: ::m2_syn::Spanned>(span: S) -> _BslBsl {
4293    let span = span.span();
4294    _BslBsl {
4295        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
4296            "\\\\", span,
4297        ))),
4298    }
4299}
4300impl ::m2_syn::Token for _BslBsl {
4301    const SPELLING: &'static str = "\\\\";
4302    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
4303        match token {
4304            ::m2_syn::TokenTree::Punct(token) => token.text() == "\\\\",
4305            _ => false,
4306        }
4307    }
4308    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
4309        Self::matches_token_tree(&token).then_some(Self {
4310            raw: ::std::boxed::Box::new(token),
4311        })
4312    }
4313}
4314impl ::m2_syn::Parse for _BslBsl {
4315    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
4316        input.parse_token()
4317    }
4318}
4319impl ::m2_syn::ToTokens for _BslBsl {
4320    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4321        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
4322    }
4323}
4324impl ::m2_syn::PrettyTree for _BslBsl {
4325    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4326        ::m2_syn::PrettyNode::token(
4327            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4328            <Self as ::m2_syn::Token>::SPELLING,
4329            ::m2_syn::Spanned::span(self),
4330        )
4331    }
4332}
4333impl<N> ::m2_syn::Reconstruct<N> for _BslBsl
4334where
4335    N: ::m2_syn::ExternalCstNode,
4336{
4337    fn matches(node: &N) -> bool {
4338        node.identity().matches("\\\\", false)
4339    }
4340    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4341        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4342            return Err(::m2_syn::ReconstructError::wrong_node(
4343                "\\\\",
4344                false,
4345                node.identity(),
4346            ));
4347        }
4348        Ok(_BslBsl(node.span()))
4349    }
4350}
4351#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4352pub struct _BslBslEql {
4353    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4354}
4355#[doc(hidden)]
4356#[allow(non_snake_case)]
4357pub fn _BslBslEql<S: ::m2_syn::Spanned>(span: S) -> _BslBslEql {
4358    let span = span.span();
4359    _BslBslEql {
4360        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
4361            "\\\\=", span,
4362        ))),
4363    }
4364}
4365impl ::m2_syn::Token for _BslBslEql {
4366    const SPELLING: &'static str = "\\\\=";
4367    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
4368        match token {
4369            ::m2_syn::TokenTree::Punct(token) => token.text() == "\\\\=",
4370            _ => false,
4371        }
4372    }
4373    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
4374        Self::matches_token_tree(&token).then_some(Self {
4375            raw: ::std::boxed::Box::new(token),
4376        })
4377    }
4378}
4379impl ::m2_syn::Parse for _BslBslEql {
4380    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
4381        input.parse_token()
4382    }
4383}
4384impl ::m2_syn::ToTokens for _BslBslEql {
4385    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4386        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
4387    }
4388}
4389impl ::m2_syn::PrettyTree for _BslBslEql {
4390    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4391        ::m2_syn::PrettyNode::token(
4392            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4393            <Self as ::m2_syn::Token>::SPELLING,
4394            ::m2_syn::Spanned::span(self),
4395        )
4396    }
4397}
4398impl<N> ::m2_syn::Reconstruct<N> for _BslBslEql
4399where
4400    N: ::m2_syn::ExternalCstNode,
4401{
4402    fn matches(node: &N) -> bool {
4403        node.identity().matches("\\\\=", false)
4404    }
4405    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4406        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4407            return Err(::m2_syn::ReconstructError::wrong_node(
4408                "\\\\=",
4409                false,
4410                node.identity(),
4411            ));
4412        }
4413        Ok(_BslBslEql(node.span()))
4414    }
4415}
4416#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4417pub struct _Crt {
4418    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4419}
4420#[doc(hidden)]
4421#[allow(non_snake_case)]
4422pub fn _Crt<S: ::m2_syn::Spanned>(span: S) -> _Crt {
4423    let span = span.span();
4424    _Crt {
4425        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^", span))),
4426    }
4427}
4428impl ::m2_syn::Token for _Crt {
4429    const SPELLING: &'static str = "^";
4430    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
4431        match token {
4432            ::m2_syn::TokenTree::Punct(token) => token.text() == "^",
4433            _ => false,
4434        }
4435    }
4436    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
4437        Self::matches_token_tree(&token).then_some(Self {
4438            raw: ::std::boxed::Box::new(token),
4439        })
4440    }
4441}
4442impl ::m2_syn::Parse for _Crt {
4443    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
4444        input.parse_token()
4445    }
4446}
4447impl ::m2_syn::ToTokens for _Crt {
4448    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4449        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
4450    }
4451}
4452impl ::m2_syn::PrettyTree for _Crt {
4453    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4454        ::m2_syn::PrettyNode::token(
4455            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4456            <Self as ::m2_syn::Token>::SPELLING,
4457            ::m2_syn::Spanned::span(self),
4458        )
4459    }
4460}
4461impl<N> ::m2_syn::Reconstruct<N> for _Crt
4462where
4463    N: ::m2_syn::ExternalCstNode,
4464{
4465    fn matches(node: &N) -> bool {
4466        node.identity().matches("^", false)
4467    }
4468    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4469        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4470            return Err(::m2_syn::ReconstructError::wrong_node(
4471                "^",
4472                false,
4473                node.identity(),
4474            ));
4475        }
4476        Ok(_Crt(node.span()))
4477    }
4478}
4479#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4480pub struct _CrtEql {
4481    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4482}
4483#[doc(hidden)]
4484#[allow(non_snake_case)]
4485pub fn _CrtEql<S: ::m2_syn::Spanned>(span: S) -> _CrtEql {
4486    let span = span.span();
4487    _CrtEql {
4488        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^=", span))),
4489    }
4490}
4491impl ::m2_syn::Token for _CrtEql {
4492    const SPELLING: &'static str = "^=";
4493    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
4494        match token {
4495            ::m2_syn::TokenTree::Punct(token) => token.text() == "^=",
4496            _ => false,
4497        }
4498    }
4499    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
4500        Self::matches_token_tree(&token).then_some(Self {
4501            raw: ::std::boxed::Box::new(token),
4502        })
4503    }
4504}
4505impl ::m2_syn::Parse for _CrtEql {
4506    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
4507        input.parse_token()
4508    }
4509}
4510impl ::m2_syn::ToTokens for _CrtEql {
4511    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4512        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
4513    }
4514}
4515impl ::m2_syn::PrettyTree for _CrtEql {
4516    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4517        ::m2_syn::PrettyNode::token(
4518            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4519            <Self as ::m2_syn::Token>::SPELLING,
4520            ::m2_syn::Spanned::span(self),
4521        )
4522    }
4523}
4524impl<N> ::m2_syn::Reconstruct<N> for _CrtEql
4525where
4526    N: ::m2_syn::ExternalCstNode,
4527{
4528    fn matches(node: &N) -> bool {
4529        node.identity().matches("^=", false)
4530    }
4531    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4532        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4533            return Err(::m2_syn::ReconstructError::wrong_node(
4534                "^=",
4535                false,
4536                node.identity(),
4537            ));
4538        }
4539        Ok(_CrtEql(node.span()))
4540    }
4541}
4542#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4543pub struct _CrtMulMul {
4544    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4545}
4546#[doc(hidden)]
4547#[allow(non_snake_case)]
4548pub fn _CrtMulMul<S: ::m2_syn::Spanned>(span: S) -> _CrtMulMul {
4549    let span = span.span();
4550    _CrtMulMul {
4551        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
4552            "^**", span,
4553        ))),
4554    }
4555}
4556impl ::m2_syn::Token for _CrtMulMul {
4557    const SPELLING: &'static str = "^**";
4558    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
4559        match token {
4560            ::m2_syn::TokenTree::Punct(token) => token.text() == "^**",
4561            _ => false,
4562        }
4563    }
4564    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
4565        Self::matches_token_tree(&token).then_some(Self {
4566            raw: ::std::boxed::Box::new(token),
4567        })
4568    }
4569}
4570impl ::m2_syn::Parse for _CrtMulMul {
4571    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
4572        input.parse_token()
4573    }
4574}
4575impl ::m2_syn::ToTokens for _CrtMulMul {
4576    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4577        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
4578    }
4579}
4580impl ::m2_syn::PrettyTree for _CrtMulMul {
4581    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4582        ::m2_syn::PrettyNode::token(
4583            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4584            <Self as ::m2_syn::Token>::SPELLING,
4585            ::m2_syn::Spanned::span(self),
4586        )
4587    }
4588}
4589impl<N> ::m2_syn::Reconstruct<N> for _CrtMulMul
4590where
4591    N: ::m2_syn::ExternalCstNode,
4592{
4593    fn matches(node: &N) -> bool {
4594        node.identity().matches("^**", false)
4595    }
4596    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4597        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4598            return Err(::m2_syn::ReconstructError::wrong_node(
4599                "^**",
4600                false,
4601                node.identity(),
4602            ));
4603        }
4604        Ok(_CrtMulMul(node.span()))
4605    }
4606}
4607#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4608pub struct _CrtMulMulEql {
4609    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4610}
4611#[doc(hidden)]
4612#[allow(non_snake_case)]
4613pub fn _CrtMulMulEql<S: ::m2_syn::Spanned>(span: S) -> _CrtMulMulEql {
4614    let span = span.span();
4615    _CrtMulMulEql {
4616        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
4617            "^**=", span,
4618        ))),
4619    }
4620}
4621impl ::m2_syn::Token for _CrtMulMulEql {
4622    const SPELLING: &'static str = "^**=";
4623    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
4624        match token {
4625            ::m2_syn::TokenTree::Punct(token) => token.text() == "^**=",
4626            _ => false,
4627        }
4628    }
4629    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
4630        Self::matches_token_tree(&token).then_some(Self {
4631            raw: ::std::boxed::Box::new(token),
4632        })
4633    }
4634}
4635impl ::m2_syn::Parse for _CrtMulMulEql {
4636    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
4637        input.parse_token()
4638    }
4639}
4640impl ::m2_syn::ToTokens for _CrtMulMulEql {
4641    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4642        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
4643    }
4644}
4645impl ::m2_syn::PrettyTree for _CrtMulMulEql {
4646    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4647        ::m2_syn::PrettyNode::token(
4648            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4649            <Self as ::m2_syn::Token>::SPELLING,
4650            ::m2_syn::Spanned::span(self),
4651        )
4652    }
4653}
4654impl<N> ::m2_syn::Reconstruct<N> for _CrtMulMulEql
4655where
4656    N: ::m2_syn::ExternalCstNode,
4657{
4658    fn matches(node: &N) -> bool {
4659        node.identity().matches("^**=", false)
4660    }
4661    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4662        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4663            return Err(::m2_syn::ReconstructError::wrong_node(
4664                "^**=",
4665                false,
4666                node.identity(),
4667            ));
4668        }
4669        Ok(_CrtMulMulEql(node.span()))
4670    }
4671}
4672#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4673pub struct _CrtLst {
4674    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4675}
4676#[doc(hidden)]
4677#[allow(non_snake_case)]
4678pub fn _CrtLst<S: ::m2_syn::Spanned>(span: S) -> _CrtLst {
4679    let span = span.span();
4680    _CrtLst {
4681        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^<", span))),
4682    }
4683}
4684impl ::m2_syn::Token for _CrtLst {
4685    const SPELLING: &'static str = "^<";
4686    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
4687        match token {
4688            ::m2_syn::TokenTree::Punct(token) => token.text() == "^<",
4689            _ => false,
4690        }
4691    }
4692    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
4693        Self::matches_token_tree(&token).then_some(Self {
4694            raw: ::std::boxed::Box::new(token),
4695        })
4696    }
4697}
4698impl ::m2_syn::Parse for _CrtLst {
4699    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
4700        input.parse_token()
4701    }
4702}
4703impl ::m2_syn::ToTokens for _CrtLst {
4704    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4705        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
4706    }
4707}
4708impl ::m2_syn::PrettyTree for _CrtLst {
4709    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4710        ::m2_syn::PrettyNode::token(
4711            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4712            <Self as ::m2_syn::Token>::SPELLING,
4713            ::m2_syn::Spanned::span(self),
4714        )
4715    }
4716}
4717impl<N> ::m2_syn::Reconstruct<N> for _CrtLst
4718where
4719    N: ::m2_syn::ExternalCstNode,
4720{
4721    fn matches(node: &N) -> bool {
4722        node.identity().matches("^<", false)
4723    }
4724    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4725        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4726            return Err(::m2_syn::ReconstructError::wrong_node(
4727                "^<",
4728                false,
4729                node.identity(),
4730            ));
4731        }
4732        Ok(_CrtLst(node.span()))
4733    }
4734}
4735#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4736pub struct _CrtLstEql {
4737    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4738}
4739#[doc(hidden)]
4740#[allow(non_snake_case)]
4741pub fn _CrtLstEql<S: ::m2_syn::Spanned>(span: S) -> _CrtLstEql {
4742    let span = span.span();
4743    _CrtLstEql {
4744        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
4745            "^<=", span,
4746        ))),
4747    }
4748}
4749impl ::m2_syn::Token for _CrtLstEql {
4750    const SPELLING: &'static str = "^<=";
4751    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
4752        match token {
4753            ::m2_syn::TokenTree::Punct(token) => token.text() == "^<=",
4754            _ => false,
4755        }
4756    }
4757    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
4758        Self::matches_token_tree(&token).then_some(Self {
4759            raw: ::std::boxed::Box::new(token),
4760        })
4761    }
4762}
4763impl ::m2_syn::Parse for _CrtLstEql {
4764    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
4765        input.parse_token()
4766    }
4767}
4768impl ::m2_syn::ToTokens for _CrtLstEql {
4769    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4770        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
4771    }
4772}
4773impl ::m2_syn::PrettyTree for _CrtLstEql {
4774    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4775        ::m2_syn::PrettyNode::token(
4776            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4777            <Self as ::m2_syn::Token>::SPELLING,
4778            ::m2_syn::Spanned::span(self),
4779        )
4780    }
4781}
4782impl<N> ::m2_syn::Reconstruct<N> for _CrtLstEql
4783where
4784    N: ::m2_syn::ExternalCstNode,
4785{
4786    fn matches(node: &N) -> bool {
4787        node.identity().matches("^<=", false)
4788    }
4789    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4790        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4791            return Err(::m2_syn::ReconstructError::wrong_node(
4792                "^<=",
4793                false,
4794                node.identity(),
4795            ));
4796        }
4797        Ok(_CrtLstEql(node.span()))
4798    }
4799}
4800#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4801pub struct _CrtGst {
4802    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4803}
4804#[doc(hidden)]
4805#[allow(non_snake_case)]
4806pub fn _CrtGst<S: ::m2_syn::Spanned>(span: S) -> _CrtGst {
4807    let span = span.span();
4808    _CrtGst {
4809        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^>", span))),
4810    }
4811}
4812impl ::m2_syn::Token for _CrtGst {
4813    const SPELLING: &'static str = "^>";
4814    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
4815        match token {
4816            ::m2_syn::TokenTree::Punct(token) => token.text() == "^>",
4817            _ => false,
4818        }
4819    }
4820    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
4821        Self::matches_token_tree(&token).then_some(Self {
4822            raw: ::std::boxed::Box::new(token),
4823        })
4824    }
4825}
4826impl ::m2_syn::Parse for _CrtGst {
4827    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
4828        input.parse_token()
4829    }
4830}
4831impl ::m2_syn::ToTokens for _CrtGst {
4832    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4833        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
4834    }
4835}
4836impl ::m2_syn::PrettyTree for _CrtGst {
4837    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4838        ::m2_syn::PrettyNode::token(
4839            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4840            <Self as ::m2_syn::Token>::SPELLING,
4841            ::m2_syn::Spanned::span(self),
4842        )
4843    }
4844}
4845impl<N> ::m2_syn::Reconstruct<N> for _CrtGst
4846where
4847    N: ::m2_syn::ExternalCstNode,
4848{
4849    fn matches(node: &N) -> bool {
4850        node.identity().matches("^>", false)
4851    }
4852    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4853        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4854            return Err(::m2_syn::ReconstructError::wrong_node(
4855                "^>",
4856                false,
4857                node.identity(),
4858            ));
4859        }
4860        Ok(_CrtGst(node.span()))
4861    }
4862}
4863#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4864pub struct _CrtGstEql {
4865    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4866}
4867#[doc(hidden)]
4868#[allow(non_snake_case)]
4869pub fn _CrtGstEql<S: ::m2_syn::Spanned>(span: S) -> _CrtGstEql {
4870    let span = span.span();
4871    _CrtGstEql {
4872        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
4873            "^>=", span,
4874        ))),
4875    }
4876}
4877impl ::m2_syn::Token for _CrtGstEql {
4878    const SPELLING: &'static str = "^>=";
4879    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
4880        match token {
4881            ::m2_syn::TokenTree::Punct(token) => token.text() == "^>=",
4882            _ => false,
4883        }
4884    }
4885    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
4886        Self::matches_token_tree(&token).then_some(Self {
4887            raw: ::std::boxed::Box::new(token),
4888        })
4889    }
4890}
4891impl ::m2_syn::Parse for _CrtGstEql {
4892    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
4893        input.parse_token()
4894    }
4895}
4896impl ::m2_syn::ToTokens for _CrtGstEql {
4897    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4898        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
4899    }
4900}
4901impl ::m2_syn::PrettyTree for _CrtGstEql {
4902    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4903        ::m2_syn::PrettyNode::token(
4904            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4905            <Self as ::m2_syn::Token>::SPELLING,
4906            ::m2_syn::Spanned::span(self),
4907        )
4908    }
4909}
4910impl<N> ::m2_syn::Reconstruct<N> for _CrtGstEql
4911where
4912    N: ::m2_syn::ExternalCstNode,
4913{
4914    fn matches(node: &N) -> bool {
4915        node.identity().matches("^>=", false)
4916    }
4917    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4918        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4919            return Err(::m2_syn::ReconstructError::wrong_node(
4920                "^>=",
4921                false,
4922                node.identity(),
4923            ));
4924        }
4925        Ok(_CrtGstEql(node.span()))
4926    }
4927}
4928#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4929pub struct _CrtCrt {
4930    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4931}
4932#[doc(hidden)]
4933#[allow(non_snake_case)]
4934pub fn _CrtCrt<S: ::m2_syn::Spanned>(span: S) -> _CrtCrt {
4935    let span = span.span();
4936    _CrtCrt {
4937        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^^", span))),
4938    }
4939}
4940impl ::m2_syn::Token for _CrtCrt {
4941    const SPELLING: &'static str = "^^";
4942    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
4943        match token {
4944            ::m2_syn::TokenTree::Punct(token) => token.text() == "^^",
4945            _ => false,
4946        }
4947    }
4948    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
4949        Self::matches_token_tree(&token).then_some(Self {
4950            raw: ::std::boxed::Box::new(token),
4951        })
4952    }
4953}
4954impl ::m2_syn::Parse for _CrtCrt {
4955    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
4956        input.parse_token()
4957    }
4958}
4959impl ::m2_syn::ToTokens for _CrtCrt {
4960    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4961        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
4962    }
4963}
4964impl ::m2_syn::PrettyTree for _CrtCrt {
4965    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4966        ::m2_syn::PrettyNode::token(
4967            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
4968            <Self as ::m2_syn::Token>::SPELLING,
4969            ::m2_syn::Spanned::span(self),
4970        )
4971    }
4972}
4973impl<N> ::m2_syn::Reconstruct<N> for _CrtCrt
4974where
4975    N: ::m2_syn::ExternalCstNode,
4976{
4977    fn matches(node: &N) -> bool {
4978        node.identity().matches("^^", false)
4979    }
4980    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4981        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4982            return Err(::m2_syn::ReconstructError::wrong_node(
4983                "^^",
4984                false,
4985                node.identity(),
4986            ));
4987        }
4988        Ok(_CrtCrt(node.span()))
4989    }
4990}
4991#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
4992pub struct _CrtCrtEql {
4993    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
4994}
4995#[doc(hidden)]
4996#[allow(non_snake_case)]
4997pub fn _CrtCrtEql<S: ::m2_syn::Spanned>(span: S) -> _CrtCrtEql {
4998    let span = span.span();
4999    _CrtCrtEql {
5000        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
5001            "^^=", span,
5002        ))),
5003    }
5004}
5005impl ::m2_syn::Token for _CrtCrtEql {
5006    const SPELLING: &'static str = "^^=";
5007    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5008        match token {
5009            ::m2_syn::TokenTree::Punct(token) => token.text() == "^^=",
5010            _ => false,
5011        }
5012    }
5013    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5014        Self::matches_token_tree(&token).then_some(Self {
5015            raw: ::std::boxed::Box::new(token),
5016        })
5017    }
5018}
5019impl ::m2_syn::Parse for _CrtCrtEql {
5020    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5021        input.parse_token()
5022    }
5023}
5024impl ::m2_syn::ToTokens for _CrtCrtEql {
5025    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5026        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5027    }
5028}
5029impl ::m2_syn::PrettyTree for _CrtCrtEql {
5030    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5031        ::m2_syn::PrettyNode::token(
5032            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5033            <Self as ::m2_syn::Token>::SPELLING,
5034            ::m2_syn::Spanned::span(self),
5035        )
5036    }
5037}
5038impl<N> ::m2_syn::Reconstruct<N> for _CrtCrtEql
5039where
5040    N: ::m2_syn::ExternalCstNode,
5041{
5042    fn matches(node: &N) -> bool {
5043        node.identity().matches("^^=", false)
5044    }
5045    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5046        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5047            return Err(::m2_syn::ReconstructError::wrong_node(
5048                "^^=",
5049                false,
5050                node.identity(),
5051            ));
5052        }
5053        Ok(_CrtCrtEql(node.span()))
5054    }
5055}
5056#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
5057pub struct _Ubs {
5058    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
5059}
5060#[doc(hidden)]
5061#[allow(non_snake_case)]
5062pub fn _Ubs<S: ::m2_syn::Spanned>(span: S) -> _Ubs {
5063    let span = span.span();
5064    _Ubs {
5065        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("_", span))),
5066    }
5067}
5068impl ::m2_syn::Token for _Ubs {
5069    const SPELLING: &'static str = "_";
5070    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5071        match token {
5072            ::m2_syn::TokenTree::Punct(token) => token.text() == "_",
5073            _ => false,
5074        }
5075    }
5076    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5077        Self::matches_token_tree(&token).then_some(Self {
5078            raw: ::std::boxed::Box::new(token),
5079        })
5080    }
5081}
5082impl ::m2_syn::Parse for _Ubs {
5083    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5084        input.parse_token()
5085    }
5086}
5087impl ::m2_syn::ToTokens for _Ubs {
5088    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5089        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5090    }
5091}
5092impl ::m2_syn::PrettyTree for _Ubs {
5093    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5094        ::m2_syn::PrettyNode::token(
5095            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5096            <Self as ::m2_syn::Token>::SPELLING,
5097            ::m2_syn::Spanned::span(self),
5098        )
5099    }
5100}
5101impl<N> ::m2_syn::Reconstruct<N> for _Ubs
5102where
5103    N: ::m2_syn::ExternalCstNode,
5104{
5105    fn matches(node: &N) -> bool {
5106        node.identity().matches("_", false)
5107    }
5108    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5109        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5110            return Err(::m2_syn::ReconstructError::wrong_node(
5111                "_",
5112                false,
5113                node.identity(),
5114            ));
5115        }
5116        Ok(_Ubs(node.span()))
5117    }
5118}
5119#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
5120pub struct _UbsEql {
5121    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
5122}
5123#[doc(hidden)]
5124#[allow(non_snake_case)]
5125pub fn _UbsEql<S: ::m2_syn::Spanned>(span: S) -> _UbsEql {
5126    let span = span.span();
5127    _UbsEql {
5128        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("_=", span))),
5129    }
5130}
5131impl ::m2_syn::Token for _UbsEql {
5132    const SPELLING: &'static str = "_=";
5133    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5134        match token {
5135            ::m2_syn::TokenTree::Punct(token) => token.text() == "_=",
5136            _ => false,
5137        }
5138    }
5139    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5140        Self::matches_token_tree(&token).then_some(Self {
5141            raw: ::std::boxed::Box::new(token),
5142        })
5143    }
5144}
5145impl ::m2_syn::Parse for _UbsEql {
5146    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5147        input.parse_token()
5148    }
5149}
5150impl ::m2_syn::ToTokens for _UbsEql {
5151    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5152        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5153    }
5154}
5155impl ::m2_syn::PrettyTree for _UbsEql {
5156    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5157        ::m2_syn::PrettyNode::token(
5158            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5159            <Self as ::m2_syn::Token>::SPELLING,
5160            ::m2_syn::Spanned::span(self),
5161        )
5162    }
5163}
5164impl<N> ::m2_syn::Reconstruct<N> for _UbsEql
5165where
5166    N: ::m2_syn::ExternalCstNode,
5167{
5168    fn matches(node: &N) -> bool {
5169        node.identity().matches("_=", false)
5170    }
5171    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5172        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5173            return Err(::m2_syn::ReconstructError::wrong_node(
5174                "_=",
5175                false,
5176                node.identity(),
5177            ));
5178        }
5179        Ok(_UbsEql(node.span()))
5180    }
5181}
5182#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
5183pub struct _UbsLst {
5184    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
5185}
5186#[doc(hidden)]
5187#[allow(non_snake_case)]
5188pub fn _UbsLst<S: ::m2_syn::Spanned>(span: S) -> _UbsLst {
5189    let span = span.span();
5190    _UbsLst {
5191        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("_<", span))),
5192    }
5193}
5194impl ::m2_syn::Token for _UbsLst {
5195    const SPELLING: &'static str = "_<";
5196    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5197        match token {
5198            ::m2_syn::TokenTree::Punct(token) => token.text() == "_<",
5199            _ => false,
5200        }
5201    }
5202    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5203        Self::matches_token_tree(&token).then_some(Self {
5204            raw: ::std::boxed::Box::new(token),
5205        })
5206    }
5207}
5208impl ::m2_syn::Parse for _UbsLst {
5209    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5210        input.parse_token()
5211    }
5212}
5213impl ::m2_syn::ToTokens for _UbsLst {
5214    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5215        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5216    }
5217}
5218impl ::m2_syn::PrettyTree for _UbsLst {
5219    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5220        ::m2_syn::PrettyNode::token(
5221            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5222            <Self as ::m2_syn::Token>::SPELLING,
5223            ::m2_syn::Spanned::span(self),
5224        )
5225    }
5226}
5227impl<N> ::m2_syn::Reconstruct<N> for _UbsLst
5228where
5229    N: ::m2_syn::ExternalCstNode,
5230{
5231    fn matches(node: &N) -> bool {
5232        node.identity().matches("_<", false)
5233    }
5234    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5235        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5236            return Err(::m2_syn::ReconstructError::wrong_node(
5237                "_<",
5238                false,
5239                node.identity(),
5240            ));
5241        }
5242        Ok(_UbsLst(node.span()))
5243    }
5244}
5245#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
5246pub struct _UbsLstEql {
5247    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
5248}
5249#[doc(hidden)]
5250#[allow(non_snake_case)]
5251pub fn _UbsLstEql<S: ::m2_syn::Spanned>(span: S) -> _UbsLstEql {
5252    let span = span.span();
5253    _UbsLstEql {
5254        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
5255            "_<=", span,
5256        ))),
5257    }
5258}
5259impl ::m2_syn::Token for _UbsLstEql {
5260    const SPELLING: &'static str = "_<=";
5261    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5262        match token {
5263            ::m2_syn::TokenTree::Punct(token) => token.text() == "_<=",
5264            _ => false,
5265        }
5266    }
5267    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5268        Self::matches_token_tree(&token).then_some(Self {
5269            raw: ::std::boxed::Box::new(token),
5270        })
5271    }
5272}
5273impl ::m2_syn::Parse for _UbsLstEql {
5274    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5275        input.parse_token()
5276    }
5277}
5278impl ::m2_syn::ToTokens for _UbsLstEql {
5279    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5280        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5281    }
5282}
5283impl ::m2_syn::PrettyTree for _UbsLstEql {
5284    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5285        ::m2_syn::PrettyNode::token(
5286            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5287            <Self as ::m2_syn::Token>::SPELLING,
5288            ::m2_syn::Spanned::span(self),
5289        )
5290    }
5291}
5292impl<N> ::m2_syn::Reconstruct<N> for _UbsLstEql
5293where
5294    N: ::m2_syn::ExternalCstNode,
5295{
5296    fn matches(node: &N) -> bool {
5297        node.identity().matches("_<=", false)
5298    }
5299    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5300        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5301            return Err(::m2_syn::ReconstructError::wrong_node(
5302                "_<=",
5303                false,
5304                node.identity(),
5305            ));
5306        }
5307        Ok(_UbsLstEql(node.span()))
5308    }
5309}
5310#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
5311pub struct _UbsGst {
5312    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
5313}
5314#[doc(hidden)]
5315#[allow(non_snake_case)]
5316pub fn _UbsGst<S: ::m2_syn::Spanned>(span: S) -> _UbsGst {
5317    let span = span.span();
5318    _UbsGst {
5319        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("_>", span))),
5320    }
5321}
5322impl ::m2_syn::Token for _UbsGst {
5323    const SPELLING: &'static str = "_>";
5324    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5325        match token {
5326            ::m2_syn::TokenTree::Punct(token) => token.text() == "_>",
5327            _ => false,
5328        }
5329    }
5330    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5331        Self::matches_token_tree(&token).then_some(Self {
5332            raw: ::std::boxed::Box::new(token),
5333        })
5334    }
5335}
5336impl ::m2_syn::Parse for _UbsGst {
5337    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5338        input.parse_token()
5339    }
5340}
5341impl ::m2_syn::ToTokens for _UbsGst {
5342    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5343        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5344    }
5345}
5346impl ::m2_syn::PrettyTree for _UbsGst {
5347    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5348        ::m2_syn::PrettyNode::token(
5349            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5350            <Self as ::m2_syn::Token>::SPELLING,
5351            ::m2_syn::Spanned::span(self),
5352        )
5353    }
5354}
5355impl<N> ::m2_syn::Reconstruct<N> for _UbsGst
5356where
5357    N: ::m2_syn::ExternalCstNode,
5358{
5359    fn matches(node: &N) -> bool {
5360        node.identity().matches("_>", false)
5361    }
5362    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5363        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5364            return Err(::m2_syn::ReconstructError::wrong_node(
5365                "_>",
5366                false,
5367                node.identity(),
5368            ));
5369        }
5370        Ok(_UbsGst(node.span()))
5371    }
5372}
5373#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
5374pub struct _UbsGstEql {
5375    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
5376}
5377#[doc(hidden)]
5378#[allow(non_snake_case)]
5379pub fn _UbsGstEql<S: ::m2_syn::Spanned>(span: S) -> _UbsGstEql {
5380    let span = span.span();
5381    _UbsGstEql {
5382        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
5383            "_>=", span,
5384        ))),
5385    }
5386}
5387impl ::m2_syn::Token for _UbsGstEql {
5388    const SPELLING: &'static str = "_>=";
5389    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5390        match token {
5391            ::m2_syn::TokenTree::Punct(token) => token.text() == "_>=",
5392            _ => false,
5393        }
5394    }
5395    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5396        Self::matches_token_tree(&token).then_some(Self {
5397            raw: ::std::boxed::Box::new(token),
5398        })
5399    }
5400}
5401impl ::m2_syn::Parse for _UbsGstEql {
5402    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5403        input.parse_token()
5404    }
5405}
5406impl ::m2_syn::ToTokens for _UbsGstEql {
5407    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5408        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5409    }
5410}
5411impl ::m2_syn::PrettyTree for _UbsGstEql {
5412    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5413        ::m2_syn::PrettyNode::token(
5414            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5415            <Self as ::m2_syn::Token>::SPELLING,
5416            ::m2_syn::Spanned::span(self),
5417        )
5418    }
5419}
5420impl<N> ::m2_syn::Reconstruct<N> for _UbsGstEql
5421where
5422    N: ::m2_syn::ExternalCstNode,
5423{
5424    fn matches(node: &N) -> bool {
5425        node.identity().matches("_>=", false)
5426    }
5427    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5428        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5429            return Err(::m2_syn::ReconstructError::wrong_node(
5430                "_>=",
5431                false,
5432                node.identity(),
5433            ));
5434        }
5435        Ok(_UbsGstEql(node.span()))
5436    }
5437}
5438#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
5439pub struct _Pip {
5440    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
5441}
5442#[doc(hidden)]
5443#[allow(non_snake_case)]
5444pub fn _Pip<S: ::m2_syn::Spanned>(span: S) -> _Pip {
5445    let span = span.span();
5446    _Pip {
5447        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("|", span))),
5448    }
5449}
5450impl ::m2_syn::Token for _Pip {
5451    const SPELLING: &'static str = "|";
5452    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5453        match token {
5454            ::m2_syn::TokenTree::Punct(token) => token.text() == "|",
5455            _ => false,
5456        }
5457    }
5458    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5459        Self::matches_token_tree(&token).then_some(Self {
5460            raw: ::std::boxed::Box::new(token),
5461        })
5462    }
5463}
5464impl ::m2_syn::Parse for _Pip {
5465    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5466        input.parse_token()
5467    }
5468}
5469impl ::m2_syn::ToTokens for _Pip {
5470    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5471        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5472    }
5473}
5474impl ::m2_syn::PrettyTree for _Pip {
5475    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5476        ::m2_syn::PrettyNode::token(
5477            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5478            <Self as ::m2_syn::Token>::SPELLING,
5479            ::m2_syn::Spanned::span(self),
5480        )
5481    }
5482}
5483impl<N> ::m2_syn::Reconstruct<N> for _Pip
5484where
5485    N: ::m2_syn::ExternalCstNode,
5486{
5487    fn matches(node: &N) -> bool {
5488        node.identity().matches("|", false)
5489    }
5490    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5491        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5492            return Err(::m2_syn::ReconstructError::wrong_node(
5493                "|",
5494                false,
5495                node.identity(),
5496            ));
5497        }
5498        Ok(_Pip(node.span()))
5499    }
5500}
5501#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
5502pub struct _PipEql {
5503    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
5504}
5505#[doc(hidden)]
5506#[allow(non_snake_case)]
5507pub fn _PipEql<S: ::m2_syn::Spanned>(span: S) -> _PipEql {
5508    let span = span.span();
5509    _PipEql {
5510        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("|=", span))),
5511    }
5512}
5513impl ::m2_syn::Token for _PipEql {
5514    const SPELLING: &'static str = "|=";
5515    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5516        match token {
5517            ::m2_syn::TokenTree::Punct(token) => token.text() == "|=",
5518            _ => false,
5519        }
5520    }
5521    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5522        Self::matches_token_tree(&token).then_some(Self {
5523            raw: ::std::boxed::Box::new(token),
5524        })
5525    }
5526}
5527impl ::m2_syn::Parse for _PipEql {
5528    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5529        input.parse_token()
5530    }
5531}
5532impl ::m2_syn::ToTokens for _PipEql {
5533    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5534        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5535    }
5536}
5537impl ::m2_syn::PrettyTree for _PipEql {
5538    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5539        ::m2_syn::PrettyNode::token(
5540            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5541            <Self as ::m2_syn::Token>::SPELLING,
5542            ::m2_syn::Spanned::span(self),
5543        )
5544    }
5545}
5546impl<N> ::m2_syn::Reconstruct<N> for _PipEql
5547where
5548    N: ::m2_syn::ExternalCstNode,
5549{
5550    fn matches(node: &N) -> bool {
5551        node.identity().matches("|=", false)
5552    }
5553    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5554        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5555            return Err(::m2_syn::ReconstructError::wrong_node(
5556                "|=",
5557                false,
5558                node.identity(),
5559            ));
5560        }
5561        Ok(_PipEql(node.span()))
5562    }
5563}
5564#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
5565pub struct _PipSub {
5566    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
5567}
5568#[doc(hidden)]
5569#[allow(non_snake_case)]
5570pub fn _PipSub<S: ::m2_syn::Spanned>(span: S) -> _PipSub {
5571    let span = span.span();
5572    _PipSub {
5573        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("|-", span))),
5574    }
5575}
5576impl ::m2_syn::Token for _PipSub {
5577    const SPELLING: &'static str = "|-";
5578    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5579        match token {
5580            ::m2_syn::TokenTree::Punct(token) => token.text() == "|-",
5581            _ => false,
5582        }
5583    }
5584    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5585        Self::matches_token_tree(&token).then_some(Self {
5586            raw: ::std::boxed::Box::new(token),
5587        })
5588    }
5589}
5590impl ::m2_syn::Parse for _PipSub {
5591    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5592        input.parse_token()
5593    }
5594}
5595impl ::m2_syn::ToTokens for _PipSub {
5596    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5597        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5598    }
5599}
5600impl ::m2_syn::PrettyTree for _PipSub {
5601    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5602        ::m2_syn::PrettyNode::token(
5603            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5604            <Self as ::m2_syn::Token>::SPELLING,
5605            ::m2_syn::Spanned::span(self),
5606        )
5607    }
5608}
5609impl<N> ::m2_syn::Reconstruct<N> for _PipSub
5610where
5611    N: ::m2_syn::ExternalCstNode,
5612{
5613    fn matches(node: &N) -> bool {
5614        node.identity().matches("|-", false)
5615    }
5616    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5617        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5618            return Err(::m2_syn::ReconstructError::wrong_node(
5619                "|-",
5620                false,
5621                node.identity(),
5622            ));
5623        }
5624        Ok(_PipSub(node.span()))
5625    }
5626}
5627#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
5628pub struct _PipSubEql {
5629    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
5630}
5631#[doc(hidden)]
5632#[allow(non_snake_case)]
5633pub fn _PipSubEql<S: ::m2_syn::Spanned>(span: S) -> _PipSubEql {
5634    let span = span.span();
5635    _PipSubEql {
5636        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
5637            "|-=", span,
5638        ))),
5639    }
5640}
5641impl ::m2_syn::Token for _PipSubEql {
5642    const SPELLING: &'static str = "|-=";
5643    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5644        match token {
5645            ::m2_syn::TokenTree::Punct(token) => token.text() == "|-=",
5646            _ => false,
5647        }
5648    }
5649    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5650        Self::matches_token_tree(&token).then_some(Self {
5651            raw: ::std::boxed::Box::new(token),
5652        })
5653    }
5654}
5655impl ::m2_syn::Parse for _PipSubEql {
5656    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5657        input.parse_token()
5658    }
5659}
5660impl ::m2_syn::ToTokens for _PipSubEql {
5661    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5662        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5663    }
5664}
5665impl ::m2_syn::PrettyTree for _PipSubEql {
5666    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5667        ::m2_syn::PrettyNode::token(
5668            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5669            <Self as ::m2_syn::Token>::SPELLING,
5670            ::m2_syn::Spanned::span(self),
5671        )
5672    }
5673}
5674impl<N> ::m2_syn::Reconstruct<N> for _PipSubEql
5675where
5676    N: ::m2_syn::ExternalCstNode,
5677{
5678    fn matches(node: &N) -> bool {
5679        node.identity().matches("|-=", false)
5680    }
5681    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5682        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5683            return Err(::m2_syn::ReconstructError::wrong_node(
5684                "|-=",
5685                false,
5686                node.identity(),
5687            ));
5688        }
5689        Ok(_PipSubEql(node.span()))
5690    }
5691}
5692#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
5693pub struct _PipUbs {
5694    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
5695}
5696#[doc(hidden)]
5697#[allow(non_snake_case)]
5698pub fn _PipUbs<S: ::m2_syn::Spanned>(span: S) -> _PipUbs {
5699    let span = span.span();
5700    _PipUbs {
5701        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("|_", span))),
5702    }
5703}
5704impl ::m2_syn::Token for _PipUbs {
5705    const SPELLING: &'static str = "|_";
5706    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5707        match token {
5708            ::m2_syn::TokenTree::Punct(token) => token.text() == "|_",
5709            _ => false,
5710        }
5711    }
5712    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5713        Self::matches_token_tree(&token).then_some(Self {
5714            raw: ::std::boxed::Box::new(token),
5715        })
5716    }
5717}
5718impl ::m2_syn::Parse for _PipUbs {
5719    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5720        input.parse_token()
5721    }
5722}
5723impl ::m2_syn::ToTokens for _PipUbs {
5724    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5725        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5726    }
5727}
5728impl ::m2_syn::PrettyTree for _PipUbs {
5729    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5730        ::m2_syn::PrettyNode::token(
5731            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5732            <Self as ::m2_syn::Token>::SPELLING,
5733            ::m2_syn::Spanned::span(self),
5734        )
5735    }
5736}
5737impl<N> ::m2_syn::Reconstruct<N> for _PipUbs
5738where
5739    N: ::m2_syn::ExternalCstNode,
5740{
5741    fn matches(node: &N) -> bool {
5742        node.identity().matches("|_", false)
5743    }
5744    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5745        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5746            return Err(::m2_syn::ReconstructError::wrong_node(
5747                "|_",
5748                false,
5749                node.identity(),
5750            ));
5751        }
5752        Ok(_PipUbs(node.span()))
5753    }
5754}
5755#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
5756pub struct _PipUbsEql {
5757    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
5758}
5759#[doc(hidden)]
5760#[allow(non_snake_case)]
5761pub fn _PipUbsEql<S: ::m2_syn::Spanned>(span: S) -> _PipUbsEql {
5762    let span = span.span();
5763    _PipUbsEql {
5764        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
5765            "|_=", span,
5766        ))),
5767    }
5768}
5769impl ::m2_syn::Token for _PipUbsEql {
5770    const SPELLING: &'static str = "|_=";
5771    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5772        match token {
5773            ::m2_syn::TokenTree::Punct(token) => token.text() == "|_=",
5774            _ => false,
5775        }
5776    }
5777    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5778        Self::matches_token_tree(&token).then_some(Self {
5779            raw: ::std::boxed::Box::new(token),
5780        })
5781    }
5782}
5783impl ::m2_syn::Parse for _PipUbsEql {
5784    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5785        input.parse_token()
5786    }
5787}
5788impl ::m2_syn::ToTokens for _PipUbsEql {
5789    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5790        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5791    }
5792}
5793impl ::m2_syn::PrettyTree for _PipUbsEql {
5794    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5795        ::m2_syn::PrettyNode::token(
5796            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5797            <Self as ::m2_syn::Token>::SPELLING,
5798            ::m2_syn::Spanned::span(self),
5799        )
5800    }
5801}
5802impl<N> ::m2_syn::Reconstruct<N> for _PipUbsEql
5803where
5804    N: ::m2_syn::ExternalCstNode,
5805{
5806    fn matches(node: &N) -> bool {
5807        node.identity().matches("|_=", false)
5808    }
5809    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5810        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5811            return Err(::m2_syn::ReconstructError::wrong_node(
5812                "|_=",
5813                false,
5814                node.identity(),
5815            ));
5816        }
5817        Ok(_PipUbsEql(node.span()))
5818    }
5819}
5820#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
5821pub struct _PipPip {
5822    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
5823}
5824#[doc(hidden)]
5825#[allow(non_snake_case)]
5826pub fn _PipPip<S: ::m2_syn::Spanned>(span: S) -> _PipPip {
5827    let span = span.span();
5828    _PipPip {
5829        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("||", span))),
5830    }
5831}
5832impl ::m2_syn::Token for _PipPip {
5833    const SPELLING: &'static str = "||";
5834    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5835        match token {
5836            ::m2_syn::TokenTree::Punct(token) => token.text() == "||",
5837            _ => false,
5838        }
5839    }
5840    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5841        Self::matches_token_tree(&token).then_some(Self {
5842            raw: ::std::boxed::Box::new(token),
5843        })
5844    }
5845}
5846impl ::m2_syn::Parse for _PipPip {
5847    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5848        input.parse_token()
5849    }
5850}
5851impl ::m2_syn::ToTokens for _PipPip {
5852    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5853        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5854    }
5855}
5856impl ::m2_syn::PrettyTree for _PipPip {
5857    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5858        ::m2_syn::PrettyNode::token(
5859            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5860            <Self as ::m2_syn::Token>::SPELLING,
5861            ::m2_syn::Spanned::span(self),
5862        )
5863    }
5864}
5865impl<N> ::m2_syn::Reconstruct<N> for _PipPip
5866where
5867    N: ::m2_syn::ExternalCstNode,
5868{
5869    fn matches(node: &N) -> bool {
5870        node.identity().matches("||", false)
5871    }
5872    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5873        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5874            return Err(::m2_syn::ReconstructError::wrong_node(
5875                "||",
5876                false,
5877                node.identity(),
5878            ));
5879        }
5880        Ok(_PipPip(node.span()))
5881    }
5882}
5883#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
5884pub struct _PipPipEql {
5885    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
5886}
5887#[doc(hidden)]
5888#[allow(non_snake_case)]
5889pub fn _PipPipEql<S: ::m2_syn::Spanned>(span: S) -> _PipPipEql {
5890    let span = span.span();
5891    _PipPipEql {
5892        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
5893            "||=", span,
5894        ))),
5895    }
5896}
5897impl ::m2_syn::Token for _PipPipEql {
5898    const SPELLING: &'static str = "||=";
5899    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5900        match token {
5901            ::m2_syn::TokenTree::Punct(token) => token.text() == "||=",
5902            _ => false,
5903        }
5904    }
5905    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5906        Self::matches_token_tree(&token).then_some(Self {
5907            raw: ::std::boxed::Box::new(token),
5908        })
5909    }
5910}
5911impl ::m2_syn::Parse for _PipPipEql {
5912    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5913        input.parse_token()
5914    }
5915}
5916impl ::m2_syn::ToTokens for _PipPipEql {
5917    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5918        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5919    }
5920}
5921impl ::m2_syn::PrettyTree for _PipPipEql {
5922    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5923        ::m2_syn::PrettyNode::token(
5924            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5925            <Self as ::m2_syn::Token>::SPELLING,
5926            ::m2_syn::Spanned::span(self),
5927        )
5928    }
5929}
5930impl<N> ::m2_syn::Reconstruct<N> for _PipPipEql
5931where
5932    N: ::m2_syn::ExternalCstNode,
5933{
5934    fn matches(node: &N) -> bool {
5935        node.identity().matches("||=", false)
5936    }
5937    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5938        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5939            return Err(::m2_syn::ReconstructError::wrong_node(
5940                "||=",
5941                false,
5942                node.identity(),
5943            ));
5944        }
5945        Ok(_PipPipEql(node.span()))
5946    }
5947}
5948#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
5949pub struct _Tld {
5950    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
5951}
5952#[doc(hidden)]
5953#[allow(non_snake_case)]
5954pub fn _Tld<S: ::m2_syn::Spanned>(span: S) -> _Tld {
5955    let span = span.span();
5956    _Tld {
5957        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("~", span))),
5958    }
5959}
5960impl ::m2_syn::Token for _Tld {
5961    const SPELLING: &'static str = "~";
5962    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
5963        match token {
5964            ::m2_syn::TokenTree::Punct(token) => token.text() == "~",
5965            _ => false,
5966        }
5967    }
5968    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
5969        Self::matches_token_tree(&token).then_some(Self {
5970            raw: ::std::boxed::Box::new(token),
5971        })
5972    }
5973}
5974impl ::m2_syn::Parse for _Tld {
5975    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
5976        input.parse_token()
5977    }
5978}
5979impl ::m2_syn::ToTokens for _Tld {
5980    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5981        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
5982    }
5983}
5984impl ::m2_syn::PrettyTree for _Tld {
5985    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5986        ::m2_syn::PrettyNode::token(
5987            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
5988            <Self as ::m2_syn::Token>::SPELLING,
5989            ::m2_syn::Spanned::span(self),
5990        )
5991    }
5992}
5993impl<N> ::m2_syn::Reconstruct<N> for _Tld
5994where
5995    N: ::m2_syn::ExternalCstNode,
5996{
5997    fn matches(node: &N) -> bool {
5998        node.identity().matches("~", false)
5999    }
6000    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6001        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6002            return Err(::m2_syn::ReconstructError::wrong_node(
6003                "~",
6004                false,
6005                node.identity(),
6006            ));
6007        }
6008        Ok(_Tld(node.span()))
6009    }
6010}
6011#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6012pub struct _TldEql {
6013    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6014}
6015#[doc(hidden)]
6016#[allow(non_snake_case)]
6017pub fn _TldEql<S: ::m2_syn::Spanned>(span: S) -> _TldEql {
6018    let span = span.span();
6019    _TldEql {
6020        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("~=", span))),
6021    }
6022}
6023impl ::m2_syn::Token for _TldEql {
6024    const SPELLING: &'static str = "~=";
6025    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6026        match token {
6027            ::m2_syn::TokenTree::Punct(token) => token.text() == "~=",
6028            _ => false,
6029        }
6030    }
6031    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6032        Self::matches_token_tree(&token).then_some(Self {
6033            raw: ::std::boxed::Box::new(token),
6034        })
6035    }
6036}
6037impl ::m2_syn::Parse for _TldEql {
6038    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
6039        input.parse_token()
6040    }
6041}
6042impl ::m2_syn::ToTokens for _TldEql {
6043    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6044        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
6045    }
6046}
6047impl ::m2_syn::PrettyTree for _TldEql {
6048    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6049        ::m2_syn::PrettyNode::token(
6050            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
6051            <Self as ::m2_syn::Token>::SPELLING,
6052            ::m2_syn::Spanned::span(self),
6053        )
6054    }
6055}
6056impl<N> ::m2_syn::Reconstruct<N> for _TldEql
6057where
6058    N: ::m2_syn::ExternalCstNode,
6059{
6060    fn matches(node: &N) -> bool {
6061        node.identity().matches("~=", false)
6062    }
6063    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6064        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6065            return Err(::m2_syn::ReconstructError::wrong_node(
6066                "~=",
6067                false,
6068                node.identity(),
6069            ));
6070        }
6071        Ok(_TldEql(node.span()))
6072    }
6073}
6074#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6075pub struct _Cdt {
6076    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6077}
6078#[doc(hidden)]
6079#[allow(non_snake_case)]
6080pub fn _Cdt<S: ::m2_syn::Spanned>(span: S) -> _Cdt {
6081    let span = span.span();
6082    _Cdt {
6083        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("·", span))),
6084    }
6085}
6086impl ::m2_syn::Token for _Cdt {
6087    const SPELLING: &'static str = "·";
6088    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6089        match token {
6090            ::m2_syn::TokenTree::Punct(token) => token.text() == "·",
6091            _ => false,
6092        }
6093    }
6094    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6095        Self::matches_token_tree(&token).then_some(Self {
6096            raw: ::std::boxed::Box::new(token),
6097        })
6098    }
6099}
6100impl ::m2_syn::Parse for _Cdt {
6101    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
6102        input.parse_token()
6103    }
6104}
6105impl ::m2_syn::ToTokens for _Cdt {
6106    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6107        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
6108    }
6109}
6110impl ::m2_syn::PrettyTree for _Cdt {
6111    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6112        ::m2_syn::PrettyNode::token(
6113            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
6114            <Self as ::m2_syn::Token>::SPELLING,
6115            ::m2_syn::Spanned::span(self),
6116        )
6117    }
6118}
6119impl<N> ::m2_syn::Reconstruct<N> for _Cdt
6120where
6121    N: ::m2_syn::ExternalCstNode,
6122{
6123    fn matches(node: &N) -> bool {
6124        node.identity().matches("·", false)
6125    }
6126    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6127        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6128            return Err(::m2_syn::ReconstructError::wrong_node(
6129                "·",
6130                false,
6131                node.identity(),
6132            ));
6133        }
6134        Ok(_Cdt(node.span()))
6135    }
6136}
6137#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6138pub struct _CdtEql {
6139    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6140}
6141#[doc(hidden)]
6142#[allow(non_snake_case)]
6143pub fn _CdtEql<S: ::m2_syn::Spanned>(span: S) -> _CdtEql {
6144    let span = span.span();
6145    _CdtEql {
6146        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("·=", span))),
6147    }
6148}
6149impl ::m2_syn::Token for _CdtEql {
6150    const SPELLING: &'static str = "·=";
6151    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6152        match token {
6153            ::m2_syn::TokenTree::Punct(token) => token.text() == "·=",
6154            _ => false,
6155        }
6156    }
6157    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6158        Self::matches_token_tree(&token).then_some(Self {
6159            raw: ::std::boxed::Box::new(token),
6160        })
6161    }
6162}
6163impl ::m2_syn::Parse for _CdtEql {
6164    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
6165        input.parse_token()
6166    }
6167}
6168impl ::m2_syn::ToTokens for _CdtEql {
6169    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6170        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
6171    }
6172}
6173impl ::m2_syn::PrettyTree for _CdtEql {
6174    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6175        ::m2_syn::PrettyNode::token(
6176            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
6177            <Self as ::m2_syn::Token>::SPELLING,
6178            ::m2_syn::Spanned::span(self),
6179        )
6180    }
6181}
6182impl<N> ::m2_syn::Reconstruct<N> for _CdtEql
6183where
6184    N: ::m2_syn::ExternalCstNode,
6185{
6186    fn matches(node: &N) -> bool {
6187        node.identity().matches("·=", false)
6188    }
6189    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6190        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6191            return Err(::m2_syn::ReconstructError::wrong_node(
6192                "·=",
6193                false,
6194                node.identity(),
6195            ));
6196        }
6197        Ok(_CdtEql(node.span()))
6198    }
6199}
6200#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6201pub struct _Box {
6202    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6203}
6204#[doc(hidden)]
6205#[allow(non_snake_case)]
6206pub fn _Box<S: ::m2_syn::Spanned>(span: S) -> _Box {
6207    let span = span.span();
6208    _Box {
6209        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("⊠", span))),
6210    }
6211}
6212impl ::m2_syn::Token for _Box {
6213    const SPELLING: &'static str = "⊠";
6214    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6215        match token {
6216            ::m2_syn::TokenTree::Punct(token) => token.text() == "⊠",
6217            _ => false,
6218        }
6219    }
6220    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6221        Self::matches_token_tree(&token).then_some(Self {
6222            raw: ::std::boxed::Box::new(token),
6223        })
6224    }
6225}
6226impl ::m2_syn::Parse for _Box {
6227    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
6228        input.parse_token()
6229    }
6230}
6231impl ::m2_syn::ToTokens for _Box {
6232    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6233        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
6234    }
6235}
6236impl ::m2_syn::PrettyTree for _Box {
6237    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6238        ::m2_syn::PrettyNode::token(
6239            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
6240            <Self as ::m2_syn::Token>::SPELLING,
6241            ::m2_syn::Spanned::span(self),
6242        )
6243    }
6244}
6245impl<N> ::m2_syn::Reconstruct<N> for _Box
6246where
6247    N: ::m2_syn::ExternalCstNode,
6248{
6249    fn matches(node: &N) -> bool {
6250        node.identity().matches("⊠", false)
6251    }
6252    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6253        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6254            return Err(::m2_syn::ReconstructError::wrong_node(
6255                "⊠",
6256                false,
6257                node.identity(),
6258            ));
6259        }
6260        Ok(_Box(node.span()))
6261    }
6262}
6263#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6264pub struct _BoxEql {
6265    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6266}
6267#[doc(hidden)]
6268#[allow(non_snake_case)]
6269pub fn _BoxEql<S: ::m2_syn::Spanned>(span: S) -> _BoxEql {
6270    let span = span.span();
6271    _BoxEql {
6272        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("⊠=", span))),
6273    }
6274}
6275impl ::m2_syn::Token for _BoxEql {
6276    const SPELLING: &'static str = "⊠=";
6277    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6278        match token {
6279            ::m2_syn::TokenTree::Punct(token) => token.text() == "⊠=",
6280            _ => false,
6281        }
6282    }
6283    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6284        Self::matches_token_tree(&token).then_some(Self {
6285            raw: ::std::boxed::Box::new(token),
6286        })
6287    }
6288}
6289impl ::m2_syn::Parse for _BoxEql {
6290    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
6291        input.parse_token()
6292    }
6293}
6294impl ::m2_syn::ToTokens for _BoxEql {
6295    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6296        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
6297    }
6298}
6299impl ::m2_syn::PrettyTree for _BoxEql {
6300    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6301        ::m2_syn::PrettyNode::token(
6302            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
6303            <Self as ::m2_syn::Token>::SPELLING,
6304            ::m2_syn::Spanned::span(self),
6305        )
6306    }
6307}
6308impl<N> ::m2_syn::Reconstruct<N> for _BoxEql
6309where
6310    N: ::m2_syn::ExternalCstNode,
6311{
6312    fn matches(node: &N) -> bool {
6313        node.identity().matches("⊠=", false)
6314    }
6315    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6316        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6317            return Err(::m2_syn::ReconstructError::wrong_node(
6318                "⊠=",
6319                false,
6320                node.identity(),
6321            ));
6322        }
6323        Ok(_BoxEql(node.span()))
6324    }
6325}
6326#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6327pub struct _Sfp {
6328    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6329}
6330#[doc(hidden)]
6331#[allow(non_snake_case)]
6332pub fn _Sfp<S: ::m2_syn::Spanned>(span: S) -> _Sfp {
6333    let span = span.span();
6334    _Sfp {
6335        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("⧢", span))),
6336    }
6337}
6338impl ::m2_syn::Token for _Sfp {
6339    const SPELLING: &'static str = "⧢";
6340    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6341        match token {
6342            ::m2_syn::TokenTree::Punct(token) => token.text() == "⧢",
6343            _ => false,
6344        }
6345    }
6346    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6347        Self::matches_token_tree(&token).then_some(Self {
6348            raw: ::std::boxed::Box::new(token),
6349        })
6350    }
6351}
6352impl ::m2_syn::Parse for _Sfp {
6353    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
6354        input.parse_token()
6355    }
6356}
6357impl ::m2_syn::ToTokens for _Sfp {
6358    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6359        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
6360    }
6361}
6362impl ::m2_syn::PrettyTree for _Sfp {
6363    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6364        ::m2_syn::PrettyNode::token(
6365            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
6366            <Self as ::m2_syn::Token>::SPELLING,
6367            ::m2_syn::Spanned::span(self),
6368        )
6369    }
6370}
6371impl<N> ::m2_syn::Reconstruct<N> for _Sfp
6372where
6373    N: ::m2_syn::ExternalCstNode,
6374{
6375    fn matches(node: &N) -> bool {
6376        node.identity().matches("⧢", false)
6377    }
6378    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6379        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6380            return Err(::m2_syn::ReconstructError::wrong_node(
6381                "⧢",
6382                false,
6383                node.identity(),
6384            ));
6385        }
6386        Ok(_Sfp(node.span()))
6387    }
6388}
6389#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6390pub struct _SfpEql {
6391    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6392}
6393#[doc(hidden)]
6394#[allow(non_snake_case)]
6395pub fn _SfpEql<S: ::m2_syn::Spanned>(span: S) -> _SfpEql {
6396    let span = span.span();
6397    _SfpEql {
6398        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("⧢=", span))),
6399    }
6400}
6401impl ::m2_syn::Token for _SfpEql {
6402    const SPELLING: &'static str = "⧢=";
6403    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6404        match token {
6405            ::m2_syn::TokenTree::Punct(token) => token.text() == "⧢=",
6406            _ => false,
6407        }
6408    }
6409    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6410        Self::matches_token_tree(&token).then_some(Self {
6411            raw: ::std::boxed::Box::new(token),
6412        })
6413    }
6414}
6415impl ::m2_syn::Parse for _SfpEql {
6416    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
6417        input.parse_token()
6418    }
6419}
6420impl ::m2_syn::ToTokens for _SfpEql {
6421    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6422        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
6423    }
6424}
6425impl ::m2_syn::PrettyTree for _SfpEql {
6426    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6427        ::m2_syn::PrettyNode::token(
6428            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
6429            <Self as ::m2_syn::Token>::SPELLING,
6430            ::m2_syn::Spanned::span(self),
6431        )
6432    }
6433}
6434impl<N> ::m2_syn::Reconstruct<N> for _SfpEql
6435where
6436    N: ::m2_syn::ExternalCstNode,
6437{
6438    fn matches(node: &N) -> bool {
6439        node.identity().matches("⧢=", false)
6440    }
6441    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6442        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6443            return Err(::m2_syn::ReconstructError::wrong_node(
6444                "⧢=",
6445                false,
6446                node.identity(),
6447            ));
6448        }
6449        Ok(_SfpEql(node.span()))
6450    }
6451}
6452#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6453pub struct _And {
6454    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6455}
6456#[doc(hidden)]
6457#[allow(non_snake_case)]
6458pub fn _And<S: ::m2_syn::Spanned>(span: S) -> _And {
6459    let span = span.span();
6460    _And {
6461        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
6462            "and", span,
6463        ))),
6464    }
6465}
6466impl ::m2_syn::Token for _And {
6467    const SPELLING: &'static str = "and";
6468    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6469        match token {
6470            ::m2_syn::TokenTree::Ident(token) => {
6471                token.text() == "and" || token.text().strip_prefix("Core$") == Some("and")
6472            }
6473            _ => false,
6474        }
6475    }
6476    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6477        Self::matches_token_tree(&token).then_some(Self {
6478            raw: ::std::boxed::Box::new(token),
6479        })
6480    }
6481}
6482impl ::m2_syn::Parse for _And {
6483    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
6484        input.parse_token()
6485    }
6486}
6487impl ::m2_syn::ToTokens for _And {
6488    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6489        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
6490    }
6491}
6492impl ::m2_syn::PrettyTree for _And {
6493    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6494        ::m2_syn::PrettyNode::token(
6495            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
6496            <Self as ::m2_syn::Token>::SPELLING,
6497            ::m2_syn::Spanned::span(self),
6498        )
6499    }
6500}
6501impl<N> ::m2_syn::Reconstruct<N> for _And
6502where
6503    N: ::m2_syn::ExternalCstNode,
6504{
6505    fn matches(node: &N) -> bool {
6506        node.identity().matches("and", false)
6507    }
6508    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6509        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6510            return Err(::m2_syn::ReconstructError::wrong_node(
6511                "and",
6512                false,
6513                node.identity(),
6514            ));
6515        }
6516        Ok(_And(node.span()))
6517    }
6518}
6519#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6520pub struct _Or {
6521    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6522}
6523#[doc(hidden)]
6524#[allow(non_snake_case)]
6525pub fn _Or<S: ::m2_syn::Spanned>(span: S) -> _Or {
6526    let span = span.span();
6527    _Or {
6528        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
6529            "or", span,
6530        ))),
6531    }
6532}
6533impl ::m2_syn::Token for _Or {
6534    const SPELLING: &'static str = "or";
6535    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6536        match token {
6537            ::m2_syn::TokenTree::Ident(token) => {
6538                token.text() == "or" || token.text().strip_prefix("Core$") == Some("or")
6539            }
6540            _ => false,
6541        }
6542    }
6543    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6544        Self::matches_token_tree(&token).then_some(Self {
6545            raw: ::std::boxed::Box::new(token),
6546        })
6547    }
6548}
6549impl ::m2_syn::Parse for _Or {
6550    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
6551        input.parse_token()
6552    }
6553}
6554impl ::m2_syn::ToTokens for _Or {
6555    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6556        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
6557    }
6558}
6559impl ::m2_syn::PrettyTree for _Or {
6560    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6561        ::m2_syn::PrettyNode::token(
6562            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
6563            <Self as ::m2_syn::Token>::SPELLING,
6564            ::m2_syn::Spanned::span(self),
6565        )
6566    }
6567}
6568impl<N> ::m2_syn::Reconstruct<N> for _Or
6569where
6570    N: ::m2_syn::ExternalCstNode,
6571{
6572    fn matches(node: &N) -> bool {
6573        node.identity().matches("or", false)
6574    }
6575    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6576        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6577            return Err(::m2_syn::ReconstructError::wrong_node(
6578                "or",
6579                false,
6580                node.identity(),
6581            ));
6582        }
6583        Ok(_Or(node.span()))
6584    }
6585}
6586#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6587pub struct _Space {
6588    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6589}
6590#[doc(hidden)]
6591#[allow(non_snake_case)]
6592pub fn _Space<S: ::m2_syn::Spanned>(span: S) -> _Space {
6593    let span = span.span();
6594    _Space {
6595        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Trivia(::m2_syn::Trivia::new(
6596            ::m2_syn::TriviaKind::Whitespace,
6597            " ",
6598            span,
6599        ))),
6600    }
6601}
6602impl ::m2_syn::Token for _Space {
6603    const SPELLING: &'static str = "SPACE";
6604    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6605        match token {
6606            ::m2_syn::TokenTree::Trivia(token) => {
6607                token.kind() == ::m2_syn::TriviaKind::Whitespace && !token.contains_line_break()
6608            }
6609            ::m2_syn::TokenTree::Ident(token) => token.text() == "SPACE",
6610            _ => false,
6611        }
6612    }
6613    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6614        Self::matches_token_tree(&token).then_some(Self {
6615            raw: ::std::boxed::Box::new(token),
6616        })
6617    }
6618}
6619impl ::m2_syn::Parse for _Space {
6620    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
6621        input.parse_token()
6622    }
6623}
6624impl ::m2_syn::ToTokens for _Space {
6625    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6626        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
6627    }
6628}
6629impl ::m2_syn::PrettyTree for _Space {
6630    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6631        ::m2_syn::PrettyNode::token(
6632            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
6633            <Self as ::m2_syn::Token>::SPELLING,
6634            ::m2_syn::Spanned::span(self),
6635        )
6636    }
6637}
6638impl<N> ::m2_syn::Reconstruct<N> for _Space
6639where
6640    N: ::m2_syn::ExternalCstNode,
6641{
6642    fn matches(node: &N) -> bool {
6643        node.identity().matches("SPACE", false)
6644    }
6645    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6646        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6647            return Err(::m2_syn::ReconstructError::wrong_node(
6648                "SPACE",
6649                false,
6650                node.identity(),
6651            ));
6652        }
6653        Ok(_Space(node.span()))
6654    }
6655}
6656#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6657pub struct _Xor {
6658    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6659}
6660#[doc(hidden)]
6661#[allow(non_snake_case)]
6662pub fn _Xor<S: ::m2_syn::Spanned>(span: S) -> _Xor {
6663    let span = span.span();
6664    _Xor {
6665        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
6666            "xor", span,
6667        ))),
6668    }
6669}
6670impl ::m2_syn::Token for _Xor {
6671    const SPELLING: &'static str = "xor";
6672    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6673        match token {
6674            ::m2_syn::TokenTree::Ident(token) => {
6675                token.text() == "xor" || token.text().strip_prefix("Core$") == Some("xor")
6676            }
6677            _ => false,
6678        }
6679    }
6680    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6681        Self::matches_token_tree(&token).then_some(Self {
6682            raw: ::std::boxed::Box::new(token),
6683        })
6684    }
6685}
6686impl ::m2_syn::Parse for _Xor {
6687    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
6688        input.parse_token()
6689    }
6690}
6691impl ::m2_syn::ToTokens for _Xor {
6692    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6693        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
6694    }
6695}
6696impl ::m2_syn::PrettyTree for _Xor {
6697    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6698        ::m2_syn::PrettyNode::token(
6699            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
6700            <Self as ::m2_syn::Token>::SPELLING,
6701            ::m2_syn::Spanned::span(self),
6702        )
6703    }
6704}
6705impl<N> ::m2_syn::Reconstruct<N> for _Xor
6706where
6707    N: ::m2_syn::ExternalCstNode,
6708{
6709    fn matches(node: &N) -> bool {
6710        node.identity().matches("xor", false)
6711    }
6712    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6713        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6714            return Err(::m2_syn::ReconstructError::wrong_node(
6715                "xor",
6716                false,
6717                node.identity(),
6718            ));
6719        }
6720        Ok(_Xor(node.span()))
6721    }
6722}
6723#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6724pub struct _Bng {
6725    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6726}
6727#[doc(hidden)]
6728#[allow(non_snake_case)]
6729pub fn _Bng<S: ::m2_syn::Spanned>(span: S) -> _Bng {
6730    let span = span.span();
6731    _Bng {
6732        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("!", span))),
6733    }
6734}
6735impl ::m2_syn::Token for _Bng {
6736    const SPELLING: &'static str = "!";
6737    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6738        match token {
6739            ::m2_syn::TokenTree::Punct(token) => token.text() == "!",
6740            _ => false,
6741        }
6742    }
6743    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6744        Self::matches_token_tree(&token).then_some(Self {
6745            raw: ::std::boxed::Box::new(token),
6746        })
6747    }
6748}
6749impl ::m2_syn::Parse for _Bng {
6750    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
6751        input.parse_token()
6752    }
6753}
6754impl ::m2_syn::ToTokens for _Bng {
6755    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6756        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
6757    }
6758}
6759impl ::m2_syn::PrettyTree for _Bng {
6760    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6761        ::m2_syn::PrettyNode::token(
6762            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
6763            <Self as ::m2_syn::Token>::SPELLING,
6764            ::m2_syn::Spanned::span(self),
6765        )
6766    }
6767}
6768impl<N> ::m2_syn::Reconstruct<N> for _Bng
6769where
6770    N: ::m2_syn::ExternalCstNode,
6771{
6772    fn matches(node: &N) -> bool {
6773        node.identity().matches("!", false)
6774    }
6775    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6776        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6777            return Err(::m2_syn::ReconstructError::wrong_node(
6778                "!",
6779                false,
6780                node.identity(),
6781            ));
6782        }
6783        Ok(_Bng(node.span()))
6784    }
6785}
6786#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6787pub struct _Graded {
6788    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6789}
6790#[doc(hidden)]
6791#[allow(non_snake_case)]
6792pub fn _Graded<S: ::m2_syn::Spanned>(span: S) -> _Graded {
6793    let span = span.span();
6794    _Graded {
6795        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(
6796            "(*)", span,
6797        ))),
6798    }
6799}
6800impl ::m2_syn::Token for _Graded {
6801    const SPELLING: &'static str = "(*)";
6802    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6803        match token {
6804            ::m2_syn::TokenTree::Punct(token) => token.text() == "(*)",
6805            _ => false,
6806        }
6807    }
6808    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6809        Self::matches_token_tree(&token).then_some(Self {
6810            raw: ::std::boxed::Box::new(token),
6811        })
6812    }
6813}
6814impl ::m2_syn::Parse for _Graded {
6815    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
6816        input.parse_token()
6817    }
6818}
6819impl ::m2_syn::ToTokens for _Graded {
6820    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6821        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
6822    }
6823}
6824impl ::m2_syn::PrettyTree for _Graded {
6825    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6826        ::m2_syn::PrettyNode::token(
6827            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
6828            <Self as ::m2_syn::Token>::SPELLING,
6829            ::m2_syn::Spanned::span(self),
6830        )
6831    }
6832}
6833impl<N> ::m2_syn::Reconstruct<N> for _Graded
6834where
6835    N: ::m2_syn::ExternalCstNode,
6836{
6837    fn matches(node: &N) -> bool {
6838        node.identity().matches("(*)", false)
6839    }
6840    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6841        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6842            return Err(::m2_syn::ReconstructError::wrong_node(
6843                "(*)",
6844                false,
6845                node.identity(),
6846            ));
6847        }
6848        Ok(_Graded(node.span()))
6849    }
6850}
6851#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6852pub struct _CrtBng {
6853    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6854}
6855#[doc(hidden)]
6856#[allow(non_snake_case)]
6857pub fn _CrtBng<S: ::m2_syn::Spanned>(span: S) -> _CrtBng {
6858    let span = span.span();
6859    _CrtBng {
6860        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^!", span))),
6861    }
6862}
6863impl ::m2_syn::Token for _CrtBng {
6864    const SPELLING: &'static str = "^!";
6865    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6866        match token {
6867            ::m2_syn::TokenTree::Punct(token) => token.text() == "^!",
6868            _ => false,
6869        }
6870    }
6871    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6872        Self::matches_token_tree(&token).then_some(Self {
6873            raw: ::std::boxed::Box::new(token),
6874        })
6875    }
6876}
6877impl ::m2_syn::Parse for _CrtBng {
6878    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
6879        input.parse_token()
6880    }
6881}
6882impl ::m2_syn::ToTokens for _CrtBng {
6883    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6884        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
6885    }
6886}
6887impl ::m2_syn::PrettyTree for _CrtBng {
6888    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6889        ::m2_syn::PrettyNode::token(
6890            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
6891            <Self as ::m2_syn::Token>::SPELLING,
6892            ::m2_syn::Spanned::span(self),
6893        )
6894    }
6895}
6896impl<N> ::m2_syn::Reconstruct<N> for _CrtBng
6897where
6898    N: ::m2_syn::ExternalCstNode,
6899{
6900    fn matches(node: &N) -> bool {
6901        node.identity().matches("^!", false)
6902    }
6903    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6904        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6905            return Err(::m2_syn::ReconstructError::wrong_node(
6906                "^!",
6907                false,
6908                node.identity(),
6909            ));
6910        }
6911        Ok(_CrtBng(node.span()))
6912    }
6913}
6914#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6915pub struct _CrtMul {
6916    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6917}
6918#[doc(hidden)]
6919#[allow(non_snake_case)]
6920pub fn _CrtMul<S: ::m2_syn::Spanned>(span: S) -> _CrtMul {
6921    let span = span.span();
6922    _CrtMul {
6923        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^*", span))),
6924    }
6925}
6926impl ::m2_syn::Token for _CrtMul {
6927    const SPELLING: &'static str = "^*";
6928    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6929        match token {
6930            ::m2_syn::TokenTree::Punct(token) => token.text() == "^*",
6931            _ => false,
6932        }
6933    }
6934    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6935        Self::matches_token_tree(&token).then_some(Self {
6936            raw: ::std::boxed::Box::new(token),
6937        })
6938    }
6939}
6940impl ::m2_syn::Parse for _CrtMul {
6941    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
6942        input.parse_token()
6943    }
6944}
6945impl ::m2_syn::ToTokens for _CrtMul {
6946    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6947        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
6948    }
6949}
6950impl ::m2_syn::PrettyTree for _CrtMul {
6951    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6952        ::m2_syn::PrettyNode::token(
6953            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
6954            <Self as ::m2_syn::Token>::SPELLING,
6955            ::m2_syn::Spanned::span(self),
6956        )
6957    }
6958}
6959impl<N> ::m2_syn::Reconstruct<N> for _CrtMul
6960where
6961    N: ::m2_syn::ExternalCstNode,
6962{
6963    fn matches(node: &N) -> bool {
6964        node.identity().matches("^*", false)
6965    }
6966    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6967        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
6968            return Err(::m2_syn::ReconstructError::wrong_node(
6969                "^*",
6970                false,
6971                node.identity(),
6972            ));
6973        }
6974        Ok(_CrtMul(node.span()))
6975    }
6976}
6977#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
6978pub struct _CrtTld {
6979    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
6980}
6981#[doc(hidden)]
6982#[allow(non_snake_case)]
6983pub fn _CrtTld<S: ::m2_syn::Spanned>(span: S) -> _CrtTld {
6984    let span = span.span();
6985    _CrtTld {
6986        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("^~", span))),
6987    }
6988}
6989impl ::m2_syn::Token for _CrtTld {
6990    const SPELLING: &'static str = "^~";
6991    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
6992        match token {
6993            ::m2_syn::TokenTree::Punct(token) => token.text() == "^~",
6994            _ => false,
6995        }
6996    }
6997    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6998        Self::matches_token_tree(&token).then_some(Self {
6999            raw: ::std::boxed::Box::new(token),
7000        })
7001    }
7002}
7003impl ::m2_syn::Parse for _CrtTld {
7004    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
7005        input.parse_token()
7006    }
7007}
7008impl ::m2_syn::ToTokens for _CrtTld {
7009    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
7010        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
7011    }
7012}
7013impl ::m2_syn::PrettyTree for _CrtTld {
7014    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
7015        ::m2_syn::PrettyNode::token(
7016            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
7017            <Self as ::m2_syn::Token>::SPELLING,
7018            ::m2_syn::Spanned::span(self),
7019        )
7020    }
7021}
7022impl<N> ::m2_syn::Reconstruct<N> for _CrtTld
7023where
7024    N: ::m2_syn::ExternalCstNode,
7025{
7026    fn matches(node: &N) -> bool {
7027        node.identity().matches("^~", false)
7028    }
7029    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7030        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
7031            return Err(::m2_syn::ReconstructError::wrong_node(
7032                "^~",
7033                false,
7034                node.identity(),
7035            ));
7036        }
7037        Ok(_CrtTld(node.span()))
7038    }
7039}
7040#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
7041pub struct _UbsBng {
7042    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
7043}
7044#[doc(hidden)]
7045#[allow(non_snake_case)]
7046pub fn _UbsBng<S: ::m2_syn::Spanned>(span: S) -> _UbsBng {
7047    let span = span.span();
7048    _UbsBng {
7049        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("_!", span))),
7050    }
7051}
7052impl ::m2_syn::Token for _UbsBng {
7053    const SPELLING: &'static str = "_!";
7054    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
7055        match token {
7056            ::m2_syn::TokenTree::Punct(token) => token.text() == "_!",
7057            _ => false,
7058        }
7059    }
7060    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7061        Self::matches_token_tree(&token).then_some(Self {
7062            raw: ::std::boxed::Box::new(token),
7063        })
7064    }
7065}
7066impl ::m2_syn::Parse for _UbsBng {
7067    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
7068        input.parse_token()
7069    }
7070}
7071impl ::m2_syn::ToTokens for _UbsBng {
7072    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
7073        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
7074    }
7075}
7076impl ::m2_syn::PrettyTree for _UbsBng {
7077    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
7078        ::m2_syn::PrettyNode::token(
7079            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
7080            <Self as ::m2_syn::Token>::SPELLING,
7081            ::m2_syn::Spanned::span(self),
7082        )
7083    }
7084}
7085impl<N> ::m2_syn::Reconstruct<N> for _UbsBng
7086where
7087    N: ::m2_syn::ExternalCstNode,
7088{
7089    fn matches(node: &N) -> bool {
7090        node.identity().matches("_!", false)
7091    }
7092    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7093        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
7094            return Err(::m2_syn::ReconstructError::wrong_node(
7095                "_!",
7096                false,
7097                node.identity(),
7098            ));
7099        }
7100        Ok(_UbsBng(node.span()))
7101    }
7102}
7103#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
7104pub struct _UbsMul {
7105    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
7106}
7107#[doc(hidden)]
7108#[allow(non_snake_case)]
7109pub fn _UbsMul<S: ::m2_syn::Spanned>(span: S) -> _UbsMul {
7110    let span = span.span();
7111    _UbsMul {
7112        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("_*", span))),
7113    }
7114}
7115impl ::m2_syn::Token for _UbsMul {
7116    const SPELLING: &'static str = "_*";
7117    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
7118        match token {
7119            ::m2_syn::TokenTree::Punct(token) => token.text() == "_*",
7120            _ => false,
7121        }
7122    }
7123    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7124        Self::matches_token_tree(&token).then_some(Self {
7125            raw: ::std::boxed::Box::new(token),
7126        })
7127    }
7128}
7129impl ::m2_syn::Parse for _UbsMul {
7130    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
7131        input.parse_token()
7132    }
7133}
7134impl ::m2_syn::ToTokens for _UbsMul {
7135    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
7136        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
7137    }
7138}
7139impl ::m2_syn::PrettyTree for _UbsMul {
7140    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
7141        ::m2_syn::PrettyNode::token(
7142            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
7143            <Self as ::m2_syn::Token>::SPELLING,
7144            ::m2_syn::Spanned::span(self),
7145        )
7146    }
7147}
7148impl<N> ::m2_syn::Reconstruct<N> for _UbsMul
7149where
7150    N: ::m2_syn::ExternalCstNode,
7151{
7152    fn matches(node: &N) -> bool {
7153        node.identity().matches("_*", false)
7154    }
7155    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7156        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
7157            return Err(::m2_syn::ReconstructError::wrong_node(
7158                "_*",
7159                false,
7160                node.identity(),
7161            ));
7162        }
7163        Ok(_UbsMul(node.span()))
7164    }
7165}
7166#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
7167pub struct _UbsTld {
7168    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
7169}
7170#[doc(hidden)]
7171#[allow(non_snake_case)]
7172pub fn _UbsTld<S: ::m2_syn::Spanned>(span: S) -> _UbsTld {
7173    let span = span.span();
7174    _UbsTld {
7175        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new("_~", span))),
7176    }
7177}
7178impl ::m2_syn::Token for _UbsTld {
7179    const SPELLING: &'static str = "_~";
7180    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
7181        match token {
7182            ::m2_syn::TokenTree::Punct(token) => token.text() == "_~",
7183            _ => false,
7184        }
7185    }
7186    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7187        Self::matches_token_tree(&token).then_some(Self {
7188            raw: ::std::boxed::Box::new(token),
7189        })
7190    }
7191}
7192impl ::m2_syn::Parse for _UbsTld {
7193    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
7194        input.parse_token()
7195    }
7196}
7197impl ::m2_syn::ToTokens for _UbsTld {
7198    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
7199        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
7200    }
7201}
7202impl ::m2_syn::PrettyTree for _UbsTld {
7203    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
7204        ::m2_syn::PrettyNode::token(
7205            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
7206            <Self as ::m2_syn::Token>::SPELLING,
7207            ::m2_syn::Spanned::span(self),
7208        )
7209    }
7210}
7211impl<N> ::m2_syn::Reconstruct<N> for _UbsTld
7212where
7213    N: ::m2_syn::ExternalCstNode,
7214{
7215    fn matches(node: &N) -> bool {
7216        node.identity().matches("_~", false)
7217    }
7218    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7219        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
7220            return Err(::m2_syn::ReconstructError::wrong_node(
7221                "_~",
7222                false,
7223                node.identity(),
7224            ));
7225        }
7226        Ok(_UbsTld(node.span()))
7227    }
7228}
7229#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
7230pub struct _Not {
7231    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
7232}
7233#[doc(hidden)]
7234#[allow(non_snake_case)]
7235pub fn _Not<S: ::m2_syn::Spanned>(span: S) -> _Not {
7236    let span = span.span();
7237    _Not {
7238        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
7239            "not", span,
7240        ))),
7241    }
7242}
7243impl ::m2_syn::Token for _Not {
7244    const SPELLING: &'static str = "not";
7245    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
7246        match token {
7247            ::m2_syn::TokenTree::Ident(token) => {
7248                token.text() == "not" || token.text().strip_prefix("Core$") == Some("not")
7249            }
7250            _ => false,
7251        }
7252    }
7253    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7254        Self::matches_token_tree(&token).then_some(Self {
7255            raw: ::std::boxed::Box::new(token),
7256        })
7257    }
7258}
7259impl ::m2_syn::Parse for _Not {
7260    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
7261        input.parse_token()
7262    }
7263}
7264impl ::m2_syn::ToTokens for _Not {
7265    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
7266        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
7267    }
7268}
7269impl ::m2_syn::PrettyTree for _Not {
7270    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
7271        ::m2_syn::PrettyNode::token(
7272            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
7273            <Self as ::m2_syn::Token>::SPELLING,
7274            ::m2_syn::Spanned::span(self),
7275        )
7276    }
7277}
7278impl<N> ::m2_syn::Reconstruct<N> for _Not
7279where
7280    N: ::m2_syn::ExternalCstNode,
7281{
7282    fn matches(node: &N) -> bool {
7283        node.identity().matches("not", false)
7284    }
7285    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7286        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
7287            return Err(::m2_syn::ReconstructError::wrong_node(
7288                "not",
7289                false,
7290                node.identity(),
7291            ));
7292        }
7293        Ok(_Not(node.span()))
7294    }
7295}
7296#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
7297pub struct _BreakKeyword {
7298    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
7299}
7300#[doc(hidden)]
7301#[allow(non_snake_case)]
7302pub fn _BreakKeyword<S: ::m2_syn::Spanned>(span: S) -> _BreakKeyword {
7303    let span = span.span();
7304    _BreakKeyword {
7305        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
7306            "break", span,
7307        ))),
7308    }
7309}
7310impl ::m2_syn::Token for _BreakKeyword {
7311    const SPELLING: &'static str = "break";
7312    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
7313        match token {
7314            ::m2_syn::TokenTree::Ident(token) => {
7315                token.text() == "break" || token.text().strip_prefix("Core$") == Some("break")
7316            }
7317            _ => false,
7318        }
7319    }
7320    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7321        Self::matches_token_tree(&token).then_some(Self {
7322            raw: ::std::boxed::Box::new(token),
7323        })
7324    }
7325}
7326impl ::m2_syn::Parse for _BreakKeyword {
7327    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
7328        input.parse_token()
7329    }
7330}
7331impl ::m2_syn::ToTokens for _BreakKeyword {
7332    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
7333        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
7334    }
7335}
7336impl ::m2_syn::PrettyTree for _BreakKeyword {
7337    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
7338        ::m2_syn::PrettyNode::token(
7339            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
7340            <Self as ::m2_syn::Token>::SPELLING,
7341            ::m2_syn::Spanned::span(self),
7342        )
7343    }
7344}
7345impl<N> ::m2_syn::Reconstruct<N> for _BreakKeyword
7346where
7347    N: ::m2_syn::ExternalCstNode,
7348{
7349    fn matches(node: &N) -> bool {
7350        node.identity().matches("break", false)
7351    }
7352    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7353        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
7354            return Err(::m2_syn::ReconstructError::wrong_node(
7355                "break",
7356                false,
7357                node.identity(),
7358            ));
7359        }
7360        Ok(_BreakKeyword(node.span()))
7361    }
7362}
7363#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
7364pub struct _BreakpointKeyword {
7365    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
7366}
7367#[doc(hidden)]
7368#[allow(non_snake_case)]
7369pub fn _BreakpointKeyword<S: ::m2_syn::Spanned>(span: S) -> _BreakpointKeyword {
7370    let span = span.span();
7371    _BreakpointKeyword {
7372        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
7373            "breakpoint",
7374            span,
7375        ))),
7376    }
7377}
7378impl ::m2_syn::Token for _BreakpointKeyword {
7379    const SPELLING: &'static str = "breakpoint";
7380    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
7381        match token {
7382            ::m2_syn::TokenTree::Ident(token) => {
7383                token.text() == "breakpoint"
7384                    || token.text().strip_prefix("Core$") == Some("breakpoint")
7385            }
7386            _ => false,
7387        }
7388    }
7389    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7390        Self::matches_token_tree(&token).then_some(Self {
7391            raw: ::std::boxed::Box::new(token),
7392        })
7393    }
7394}
7395impl ::m2_syn::Parse for _BreakpointKeyword {
7396    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
7397        input.parse_token()
7398    }
7399}
7400impl ::m2_syn::ToTokens for _BreakpointKeyword {
7401    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
7402        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
7403    }
7404}
7405impl ::m2_syn::PrettyTree for _BreakpointKeyword {
7406    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
7407        ::m2_syn::PrettyNode::token(
7408            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
7409            <Self as ::m2_syn::Token>::SPELLING,
7410            ::m2_syn::Spanned::span(self),
7411        )
7412    }
7413}
7414impl<N> ::m2_syn::Reconstruct<N> for _BreakpointKeyword
7415where
7416    N: ::m2_syn::ExternalCstNode,
7417{
7418    fn matches(node: &N) -> bool {
7419        node.identity().matches("breakpoint", false)
7420    }
7421    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7422        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
7423            return Err(::m2_syn::ReconstructError::wrong_node(
7424                "breakpoint",
7425                false,
7426                node.identity(),
7427            ));
7428        }
7429        Ok(_BreakpointKeyword(node.span()))
7430    }
7431}
7432#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
7433pub struct _CatchKeyword {
7434    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
7435}
7436#[doc(hidden)]
7437#[allow(non_snake_case)]
7438pub fn _CatchKeyword<S: ::m2_syn::Spanned>(span: S) -> _CatchKeyword {
7439    let span = span.span();
7440    _CatchKeyword {
7441        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
7442            "catch", span,
7443        ))),
7444    }
7445}
7446impl ::m2_syn::Token for _CatchKeyword {
7447    const SPELLING: &'static str = "catch";
7448    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
7449        match token {
7450            ::m2_syn::TokenTree::Ident(token) => {
7451                token.text() == "catch" || token.text().strip_prefix("Core$") == Some("catch")
7452            }
7453            _ => false,
7454        }
7455    }
7456    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7457        Self::matches_token_tree(&token).then_some(Self {
7458            raw: ::std::boxed::Box::new(token),
7459        })
7460    }
7461}
7462impl ::m2_syn::Parse for _CatchKeyword {
7463    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
7464        input.parse_token()
7465    }
7466}
7467impl ::m2_syn::ToTokens for _CatchKeyword {
7468    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
7469        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
7470    }
7471}
7472impl ::m2_syn::PrettyTree for _CatchKeyword {
7473    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
7474        ::m2_syn::PrettyNode::token(
7475            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
7476            <Self as ::m2_syn::Token>::SPELLING,
7477            ::m2_syn::Spanned::span(self),
7478        )
7479    }
7480}
7481impl<N> ::m2_syn::Reconstruct<N> for _CatchKeyword
7482where
7483    N: ::m2_syn::ExternalCstNode,
7484{
7485    fn matches(node: &N) -> bool {
7486        node.identity().matches("catch", false)
7487    }
7488    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7489        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
7490            return Err(::m2_syn::ReconstructError::wrong_node(
7491                "catch",
7492                false,
7493                node.identity(),
7494            ));
7495        }
7496        Ok(_CatchKeyword(node.span()))
7497    }
7498}
7499#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
7500pub struct _ContinueKeyword {
7501    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
7502}
7503#[doc(hidden)]
7504#[allow(non_snake_case)]
7505pub fn _ContinueKeyword<S: ::m2_syn::Spanned>(span: S) -> _ContinueKeyword {
7506    let span = span.span();
7507    _ContinueKeyword {
7508        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
7509            "continue", span,
7510        ))),
7511    }
7512}
7513impl ::m2_syn::Token for _ContinueKeyword {
7514    const SPELLING: &'static str = "continue";
7515    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
7516        match token {
7517            ::m2_syn::TokenTree::Ident(token) => {
7518                token.text() == "continue" || token.text().strip_prefix("Core$") == Some("continue")
7519            }
7520            _ => false,
7521        }
7522    }
7523    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7524        Self::matches_token_tree(&token).then_some(Self {
7525            raw: ::std::boxed::Box::new(token),
7526        })
7527    }
7528}
7529impl ::m2_syn::Parse for _ContinueKeyword {
7530    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
7531        input.parse_token()
7532    }
7533}
7534impl ::m2_syn::ToTokens for _ContinueKeyword {
7535    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
7536        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
7537    }
7538}
7539impl ::m2_syn::PrettyTree for _ContinueKeyword {
7540    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
7541        ::m2_syn::PrettyNode::token(
7542            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
7543            <Self as ::m2_syn::Token>::SPELLING,
7544            ::m2_syn::Spanned::span(self),
7545        )
7546    }
7547}
7548impl<N> ::m2_syn::Reconstruct<N> for _ContinueKeyword
7549where
7550    N: ::m2_syn::ExternalCstNode,
7551{
7552    fn matches(node: &N) -> bool {
7553        node.identity().matches("continue", false)
7554    }
7555    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7556        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
7557            return Err(::m2_syn::ReconstructError::wrong_node(
7558                "continue",
7559                false,
7560                node.identity(),
7561            ));
7562        }
7563        Ok(_ContinueKeyword(node.span()))
7564    }
7565}
7566#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
7567pub struct _DoKeyword {
7568    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
7569}
7570#[doc(hidden)]
7571#[allow(non_snake_case)]
7572pub fn _DoKeyword<S: ::m2_syn::Spanned>(span: S) -> _DoKeyword {
7573    let span = span.span();
7574    _DoKeyword {
7575        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
7576            "do", span,
7577        ))),
7578    }
7579}
7580impl ::m2_syn::Token for _DoKeyword {
7581    const SPELLING: &'static str = "do";
7582    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
7583        match token {
7584            ::m2_syn::TokenTree::Ident(token) => {
7585                token.text() == "do" || token.text().strip_prefix("Core$") == Some("do")
7586            }
7587            _ => false,
7588        }
7589    }
7590    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7591        Self::matches_token_tree(&token).then_some(Self {
7592            raw: ::std::boxed::Box::new(token),
7593        })
7594    }
7595}
7596impl ::m2_syn::Parse for _DoKeyword {
7597    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
7598        input.parse_token()
7599    }
7600}
7601impl ::m2_syn::ToTokens for _DoKeyword {
7602    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
7603        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
7604    }
7605}
7606impl ::m2_syn::PrettyTree for _DoKeyword {
7607    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
7608        ::m2_syn::PrettyNode::token(
7609            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
7610            <Self as ::m2_syn::Token>::SPELLING,
7611            ::m2_syn::Spanned::span(self),
7612        )
7613    }
7614}
7615impl<N> ::m2_syn::Reconstruct<N> for _DoKeyword
7616where
7617    N: ::m2_syn::ExternalCstNode,
7618{
7619    fn matches(node: &N) -> bool {
7620        node.identity().matches("do", false)
7621    }
7622    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7623        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
7624            return Err(::m2_syn::ReconstructError::wrong_node(
7625                "do",
7626                false,
7627                node.identity(),
7628            ));
7629        }
7630        Ok(_DoKeyword(node.span()))
7631    }
7632}
7633#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
7634pub struct _ElapsedTimeKeyword {
7635    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
7636}
7637#[doc(hidden)]
7638#[allow(non_snake_case)]
7639pub fn _ElapsedTimeKeyword<S: ::m2_syn::Spanned>(span: S) -> _ElapsedTimeKeyword {
7640    let span = span.span();
7641    _ElapsedTimeKeyword {
7642        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
7643            "elapsedTime",
7644            span,
7645        ))),
7646    }
7647}
7648impl ::m2_syn::Token for _ElapsedTimeKeyword {
7649    const SPELLING: &'static str = "elapsedTime";
7650    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
7651        match token {
7652            ::m2_syn::TokenTree::Ident(token) => {
7653                token.text() == "elapsedTime"
7654                    || token.text().strip_prefix("Core$") == Some("elapsedTime")
7655            }
7656            _ => false,
7657        }
7658    }
7659    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7660        Self::matches_token_tree(&token).then_some(Self {
7661            raw: ::std::boxed::Box::new(token),
7662        })
7663    }
7664}
7665impl ::m2_syn::Parse for _ElapsedTimeKeyword {
7666    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
7667        input.parse_token()
7668    }
7669}
7670impl ::m2_syn::ToTokens for _ElapsedTimeKeyword {
7671    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
7672        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
7673    }
7674}
7675impl ::m2_syn::PrettyTree for _ElapsedTimeKeyword {
7676    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
7677        ::m2_syn::PrettyNode::token(
7678            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
7679            <Self as ::m2_syn::Token>::SPELLING,
7680            ::m2_syn::Spanned::span(self),
7681        )
7682    }
7683}
7684impl<N> ::m2_syn::Reconstruct<N> for _ElapsedTimeKeyword
7685where
7686    N: ::m2_syn::ExternalCstNode,
7687{
7688    fn matches(node: &N) -> bool {
7689        node.identity().matches("elapsedTime", false)
7690    }
7691    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7692        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
7693            return Err(::m2_syn::ReconstructError::wrong_node(
7694                "elapsedTime",
7695                false,
7696                node.identity(),
7697            ));
7698        }
7699        Ok(_ElapsedTimeKeyword(node.span()))
7700    }
7701}
7702#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
7703pub struct _ElapsedTimingKeyword {
7704    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
7705}
7706#[doc(hidden)]
7707#[allow(non_snake_case)]
7708pub fn _ElapsedTimingKeyword<S: ::m2_syn::Spanned>(span: S) -> _ElapsedTimingKeyword {
7709    let span = span.span();
7710    _ElapsedTimingKeyword {
7711        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
7712            "elapsedTiming",
7713            span,
7714        ))),
7715    }
7716}
7717impl ::m2_syn::Token for _ElapsedTimingKeyword {
7718    const SPELLING: &'static str = "elapsedTiming";
7719    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
7720        match token {
7721            ::m2_syn::TokenTree::Ident(token) => {
7722                token.text() == "elapsedTiming"
7723                    || token.text().strip_prefix("Core$") == Some("elapsedTiming")
7724            }
7725            _ => false,
7726        }
7727    }
7728    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7729        Self::matches_token_tree(&token).then_some(Self {
7730            raw: ::std::boxed::Box::new(token),
7731        })
7732    }
7733}
7734impl ::m2_syn::Parse for _ElapsedTimingKeyword {
7735    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
7736        input.parse_token()
7737    }
7738}
7739impl ::m2_syn::ToTokens for _ElapsedTimingKeyword {
7740    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
7741        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
7742    }
7743}
7744impl ::m2_syn::PrettyTree for _ElapsedTimingKeyword {
7745    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
7746        ::m2_syn::PrettyNode::token(
7747            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
7748            <Self as ::m2_syn::Token>::SPELLING,
7749            ::m2_syn::Spanned::span(self),
7750        )
7751    }
7752}
7753impl<N> ::m2_syn::Reconstruct<N> for _ElapsedTimingKeyword
7754where
7755    N: ::m2_syn::ExternalCstNode,
7756{
7757    fn matches(node: &N) -> bool {
7758        node.identity().matches("elapsedTiming", false)
7759    }
7760    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7761        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
7762            return Err(::m2_syn::ReconstructError::wrong_node(
7763                "elapsedTiming",
7764                false,
7765                node.identity(),
7766            ));
7767        }
7768        Ok(_ElapsedTimingKeyword(node.span()))
7769    }
7770}
7771#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
7772pub struct _ElseKeyword {
7773    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
7774}
7775#[doc(hidden)]
7776#[allow(non_snake_case)]
7777pub fn _ElseKeyword<S: ::m2_syn::Spanned>(span: S) -> _ElseKeyword {
7778    let span = span.span();
7779    _ElseKeyword {
7780        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
7781            "else", span,
7782        ))),
7783    }
7784}
7785impl ::m2_syn::Token for _ElseKeyword {
7786    const SPELLING: &'static str = "else";
7787    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
7788        match token {
7789            ::m2_syn::TokenTree::Ident(token) => {
7790                token.text() == "else" || token.text().strip_prefix("Core$") == Some("else")
7791            }
7792            _ => false,
7793        }
7794    }
7795    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7796        Self::matches_token_tree(&token).then_some(Self {
7797            raw: ::std::boxed::Box::new(token),
7798        })
7799    }
7800}
7801impl ::m2_syn::Parse for _ElseKeyword {
7802    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
7803        input.parse_token()
7804    }
7805}
7806impl ::m2_syn::ToTokens for _ElseKeyword {
7807    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
7808        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
7809    }
7810}
7811impl ::m2_syn::PrettyTree for _ElseKeyword {
7812    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
7813        ::m2_syn::PrettyNode::token(
7814            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
7815            <Self as ::m2_syn::Token>::SPELLING,
7816            ::m2_syn::Spanned::span(self),
7817        )
7818    }
7819}
7820impl<N> ::m2_syn::Reconstruct<N> for _ElseKeyword
7821where
7822    N: ::m2_syn::ExternalCstNode,
7823{
7824    fn matches(node: &N) -> bool {
7825        node.identity().matches("else", false)
7826    }
7827    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7828        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
7829            return Err(::m2_syn::ReconstructError::wrong_node(
7830                "else",
7831                false,
7832                node.identity(),
7833            ));
7834        }
7835        Ok(_ElseKeyword(node.span()))
7836    }
7837}
7838#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
7839pub struct _ExceptKeyword {
7840    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
7841}
7842#[doc(hidden)]
7843#[allow(non_snake_case)]
7844pub fn _ExceptKeyword<S: ::m2_syn::Spanned>(span: S) -> _ExceptKeyword {
7845    let span = span.span();
7846    _ExceptKeyword {
7847        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
7848            "except", span,
7849        ))),
7850    }
7851}
7852impl ::m2_syn::Token for _ExceptKeyword {
7853    const SPELLING: &'static str = "except";
7854    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
7855        match token {
7856            ::m2_syn::TokenTree::Ident(token) => {
7857                token.text() == "except" || token.text().strip_prefix("Core$") == Some("except")
7858            }
7859            _ => false,
7860        }
7861    }
7862    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7863        Self::matches_token_tree(&token).then_some(Self {
7864            raw: ::std::boxed::Box::new(token),
7865        })
7866    }
7867}
7868impl ::m2_syn::Parse for _ExceptKeyword {
7869    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
7870        input.parse_token()
7871    }
7872}
7873impl ::m2_syn::ToTokens for _ExceptKeyword {
7874    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
7875        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
7876    }
7877}
7878impl ::m2_syn::PrettyTree for _ExceptKeyword {
7879    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
7880        ::m2_syn::PrettyNode::token(
7881            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
7882            <Self as ::m2_syn::Token>::SPELLING,
7883            ::m2_syn::Spanned::span(self),
7884        )
7885    }
7886}
7887impl<N> ::m2_syn::Reconstruct<N> for _ExceptKeyword
7888where
7889    N: ::m2_syn::ExternalCstNode,
7890{
7891    fn matches(node: &N) -> bool {
7892        node.identity().matches("except", false)
7893    }
7894    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7895        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
7896            return Err(::m2_syn::ReconstructError::wrong_node(
7897                "except",
7898                false,
7899                node.identity(),
7900            ));
7901        }
7902        Ok(_ExceptKeyword(node.span()))
7903    }
7904}
7905#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
7906pub struct _FinishKeyword {
7907    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
7908}
7909#[doc(hidden)]
7910#[allow(non_snake_case)]
7911pub fn _FinishKeyword<S: ::m2_syn::Spanned>(span: S) -> _FinishKeyword {
7912    let span = span.span();
7913    _FinishKeyword {
7914        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
7915            "finish", span,
7916        ))),
7917    }
7918}
7919impl ::m2_syn::Token for _FinishKeyword {
7920    const SPELLING: &'static str = "finish";
7921    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
7922        match token {
7923            ::m2_syn::TokenTree::Ident(token) => {
7924                token.text() == "finish" || token.text().strip_prefix("Core$") == Some("finish")
7925            }
7926            _ => false,
7927        }
7928    }
7929    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7930        Self::matches_token_tree(&token).then_some(Self {
7931            raw: ::std::boxed::Box::new(token),
7932        })
7933    }
7934}
7935impl ::m2_syn::Parse for _FinishKeyword {
7936    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
7937        input.parse_token()
7938    }
7939}
7940impl ::m2_syn::ToTokens for _FinishKeyword {
7941    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
7942        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
7943    }
7944}
7945impl ::m2_syn::PrettyTree for _FinishKeyword {
7946    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
7947        ::m2_syn::PrettyNode::token(
7948            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
7949            <Self as ::m2_syn::Token>::SPELLING,
7950            ::m2_syn::Spanned::span(self),
7951        )
7952    }
7953}
7954impl<N> ::m2_syn::Reconstruct<N> for _FinishKeyword
7955where
7956    N: ::m2_syn::ExternalCstNode,
7957{
7958    fn matches(node: &N) -> bool {
7959        node.identity().matches("finish", false)
7960    }
7961    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7962        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
7963            return Err(::m2_syn::ReconstructError::wrong_node(
7964                "finish",
7965                false,
7966                node.identity(),
7967            ));
7968        }
7969        Ok(_FinishKeyword(node.span()))
7970    }
7971}
7972#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
7973pub struct _ForKeyword {
7974    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
7975}
7976#[doc(hidden)]
7977#[allow(non_snake_case)]
7978pub fn _ForKeyword<S: ::m2_syn::Spanned>(span: S) -> _ForKeyword {
7979    let span = span.span();
7980    _ForKeyword {
7981        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
7982            "for", span,
7983        ))),
7984    }
7985}
7986impl ::m2_syn::Token for _ForKeyword {
7987    const SPELLING: &'static str = "for";
7988    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
7989        match token {
7990            ::m2_syn::TokenTree::Ident(token) => {
7991                token.text() == "for" || token.text().strip_prefix("Core$") == Some("for")
7992            }
7993            _ => false,
7994        }
7995    }
7996    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7997        Self::matches_token_tree(&token).then_some(Self {
7998            raw: ::std::boxed::Box::new(token),
7999        })
8000    }
8001}
8002impl ::m2_syn::Parse for _ForKeyword {
8003    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
8004        input.parse_token()
8005    }
8006}
8007impl ::m2_syn::ToTokens for _ForKeyword {
8008    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8009        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
8010    }
8011}
8012impl ::m2_syn::PrettyTree for _ForKeyword {
8013    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8014        ::m2_syn::PrettyNode::token(
8015            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
8016            <Self as ::m2_syn::Token>::SPELLING,
8017            ::m2_syn::Spanned::span(self),
8018        )
8019    }
8020}
8021impl<N> ::m2_syn::Reconstruct<N> for _ForKeyword
8022where
8023    N: ::m2_syn::ExternalCstNode,
8024{
8025    fn matches(node: &N) -> bool {
8026        node.identity().matches("for", false)
8027    }
8028    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8029        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
8030            return Err(::m2_syn::ReconstructError::wrong_node(
8031                "for",
8032                false,
8033                node.identity(),
8034            ));
8035        }
8036        Ok(_ForKeyword(node.span()))
8037    }
8038}
8039#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
8040pub struct _FromKeyword {
8041    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
8042}
8043#[doc(hidden)]
8044#[allow(non_snake_case)]
8045pub fn _FromKeyword<S: ::m2_syn::Spanned>(span: S) -> _FromKeyword {
8046    let span = span.span();
8047    _FromKeyword {
8048        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
8049            "from", span,
8050        ))),
8051    }
8052}
8053impl ::m2_syn::Token for _FromKeyword {
8054    const SPELLING: &'static str = "from";
8055    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
8056        match token {
8057            ::m2_syn::TokenTree::Ident(token) => {
8058                token.text() == "from" || token.text().strip_prefix("Core$") == Some("from")
8059            }
8060            _ => false,
8061        }
8062    }
8063    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
8064        Self::matches_token_tree(&token).then_some(Self {
8065            raw: ::std::boxed::Box::new(token),
8066        })
8067    }
8068}
8069impl ::m2_syn::Parse for _FromKeyword {
8070    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
8071        input.parse_token()
8072    }
8073}
8074impl ::m2_syn::ToTokens for _FromKeyword {
8075    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8076        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
8077    }
8078}
8079impl ::m2_syn::PrettyTree for _FromKeyword {
8080    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8081        ::m2_syn::PrettyNode::token(
8082            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
8083            <Self as ::m2_syn::Token>::SPELLING,
8084            ::m2_syn::Spanned::span(self),
8085        )
8086    }
8087}
8088impl<N> ::m2_syn::Reconstruct<N> for _FromKeyword
8089where
8090    N: ::m2_syn::ExternalCstNode,
8091{
8092    fn matches(node: &N) -> bool {
8093        node.identity().matches("from", false)
8094    }
8095    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8096        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
8097            return Err(::m2_syn::ReconstructError::wrong_node(
8098                "from",
8099                false,
8100                node.identity(),
8101            ));
8102        }
8103        Ok(_FromKeyword(node.span()))
8104    }
8105}
8106#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
8107pub struct _GlobalKeyword {
8108    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
8109}
8110#[doc(hidden)]
8111#[allow(non_snake_case)]
8112pub fn _GlobalKeyword<S: ::m2_syn::Spanned>(span: S) -> _GlobalKeyword {
8113    let span = span.span();
8114    _GlobalKeyword {
8115        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
8116            "global", span,
8117        ))),
8118    }
8119}
8120impl ::m2_syn::Token for _GlobalKeyword {
8121    const SPELLING: &'static str = "global";
8122    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
8123        match token {
8124            ::m2_syn::TokenTree::Ident(token) => {
8125                token.text() == "global" || token.text().strip_prefix("Core$") == Some("global")
8126            }
8127            _ => false,
8128        }
8129    }
8130    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
8131        Self::matches_token_tree(&token).then_some(Self {
8132            raw: ::std::boxed::Box::new(token),
8133        })
8134    }
8135}
8136impl ::m2_syn::Parse for _GlobalKeyword {
8137    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
8138        input.parse_token()
8139    }
8140}
8141impl ::m2_syn::ToTokens for _GlobalKeyword {
8142    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8143        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
8144    }
8145}
8146impl ::m2_syn::PrettyTree for _GlobalKeyword {
8147    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8148        ::m2_syn::PrettyNode::token(
8149            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
8150            <Self as ::m2_syn::Token>::SPELLING,
8151            ::m2_syn::Spanned::span(self),
8152        )
8153    }
8154}
8155impl<N> ::m2_syn::Reconstruct<N> for _GlobalKeyword
8156where
8157    N: ::m2_syn::ExternalCstNode,
8158{
8159    fn matches(node: &N) -> bool {
8160        node.identity().matches("global", false)
8161    }
8162    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8163        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
8164            return Err(::m2_syn::ReconstructError::wrong_node(
8165                "global",
8166                false,
8167                node.identity(),
8168            ));
8169        }
8170        Ok(_GlobalKeyword(node.span()))
8171    }
8172}
8173#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
8174pub struct _IfKeyword {
8175    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
8176}
8177#[doc(hidden)]
8178#[allow(non_snake_case)]
8179pub fn _IfKeyword<S: ::m2_syn::Spanned>(span: S) -> _IfKeyword {
8180    let span = span.span();
8181    _IfKeyword {
8182        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
8183            "if", span,
8184        ))),
8185    }
8186}
8187impl ::m2_syn::Token for _IfKeyword {
8188    const SPELLING: &'static str = "if";
8189    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
8190        match token {
8191            ::m2_syn::TokenTree::Ident(token) => {
8192                token.text() == "if" || token.text().strip_prefix("Core$") == Some("if")
8193            }
8194            _ => false,
8195        }
8196    }
8197    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
8198        Self::matches_token_tree(&token).then_some(Self {
8199            raw: ::std::boxed::Box::new(token),
8200        })
8201    }
8202}
8203impl ::m2_syn::Parse for _IfKeyword {
8204    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
8205        input.parse_token()
8206    }
8207}
8208impl ::m2_syn::ToTokens for _IfKeyword {
8209    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8210        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
8211    }
8212}
8213impl ::m2_syn::PrettyTree for _IfKeyword {
8214    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8215        ::m2_syn::PrettyNode::token(
8216            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
8217            <Self as ::m2_syn::Token>::SPELLING,
8218            ::m2_syn::Spanned::span(self),
8219        )
8220    }
8221}
8222impl<N> ::m2_syn::Reconstruct<N> for _IfKeyword
8223where
8224    N: ::m2_syn::ExternalCstNode,
8225{
8226    fn matches(node: &N) -> bool {
8227        node.identity().matches("if", false)
8228    }
8229    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8230        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
8231            return Err(::m2_syn::ReconstructError::wrong_node(
8232                "if",
8233                false,
8234                node.identity(),
8235            ));
8236        }
8237        Ok(_IfKeyword(node.span()))
8238    }
8239}
8240#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
8241pub struct _InKeyword {
8242    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
8243}
8244#[doc(hidden)]
8245#[allow(non_snake_case)]
8246pub fn _InKeyword<S: ::m2_syn::Spanned>(span: S) -> _InKeyword {
8247    let span = span.span();
8248    _InKeyword {
8249        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
8250            "in", span,
8251        ))),
8252    }
8253}
8254impl ::m2_syn::Token for _InKeyword {
8255    const SPELLING: &'static str = "in";
8256    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
8257        match token {
8258            ::m2_syn::TokenTree::Ident(token) => {
8259                token.text() == "in" || token.text().strip_prefix("Core$") == Some("in")
8260            }
8261            _ => false,
8262        }
8263    }
8264    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
8265        Self::matches_token_tree(&token).then_some(Self {
8266            raw: ::std::boxed::Box::new(token),
8267        })
8268    }
8269}
8270impl ::m2_syn::Parse for _InKeyword {
8271    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
8272        input.parse_token()
8273    }
8274}
8275impl ::m2_syn::ToTokens for _InKeyword {
8276    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8277        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
8278    }
8279}
8280impl ::m2_syn::PrettyTree for _InKeyword {
8281    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8282        ::m2_syn::PrettyNode::token(
8283            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
8284            <Self as ::m2_syn::Token>::SPELLING,
8285            ::m2_syn::Spanned::span(self),
8286        )
8287    }
8288}
8289impl<N> ::m2_syn::Reconstruct<N> for _InKeyword
8290where
8291    N: ::m2_syn::ExternalCstNode,
8292{
8293    fn matches(node: &N) -> bool {
8294        node.identity().matches("in", false)
8295    }
8296    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8297        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
8298            return Err(::m2_syn::ReconstructError::wrong_node(
8299                "in",
8300                false,
8301                node.identity(),
8302            ));
8303        }
8304        Ok(_InKeyword(node.span()))
8305    }
8306}
8307#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
8308pub struct _ListKeyword {
8309    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
8310}
8311#[doc(hidden)]
8312#[allow(non_snake_case)]
8313pub fn _ListKeyword<S: ::m2_syn::Spanned>(span: S) -> _ListKeyword {
8314    let span = span.span();
8315    _ListKeyword {
8316        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
8317            "list", span,
8318        ))),
8319    }
8320}
8321impl ::m2_syn::Token for _ListKeyword {
8322    const SPELLING: &'static str = "list";
8323    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
8324        match token {
8325            ::m2_syn::TokenTree::Ident(token) => {
8326                token.text() == "list" || token.text().strip_prefix("Core$") == Some("list")
8327            }
8328            _ => false,
8329        }
8330    }
8331    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
8332        Self::matches_token_tree(&token).then_some(Self {
8333            raw: ::std::boxed::Box::new(token),
8334        })
8335    }
8336}
8337impl ::m2_syn::Parse for _ListKeyword {
8338    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
8339        input.parse_token()
8340    }
8341}
8342impl ::m2_syn::ToTokens for _ListKeyword {
8343    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8344        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
8345    }
8346}
8347impl ::m2_syn::PrettyTree for _ListKeyword {
8348    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8349        ::m2_syn::PrettyNode::token(
8350            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
8351            <Self as ::m2_syn::Token>::SPELLING,
8352            ::m2_syn::Spanned::span(self),
8353        )
8354    }
8355}
8356impl<N> ::m2_syn::Reconstruct<N> for _ListKeyword
8357where
8358    N: ::m2_syn::ExternalCstNode,
8359{
8360    fn matches(node: &N) -> bool {
8361        node.identity().matches("list", false)
8362    }
8363    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8364        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
8365            return Err(::m2_syn::ReconstructError::wrong_node(
8366                "list",
8367                false,
8368                node.identity(),
8369            ));
8370        }
8371        Ok(_ListKeyword(node.span()))
8372    }
8373}
8374#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
8375pub struct _LocalKeyword {
8376    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
8377}
8378#[doc(hidden)]
8379#[allow(non_snake_case)]
8380pub fn _LocalKeyword<S: ::m2_syn::Spanned>(span: S) -> _LocalKeyword {
8381    let span = span.span();
8382    _LocalKeyword {
8383        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
8384            "local", span,
8385        ))),
8386    }
8387}
8388impl ::m2_syn::Token for _LocalKeyword {
8389    const SPELLING: &'static str = "local";
8390    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
8391        match token {
8392            ::m2_syn::TokenTree::Ident(token) => {
8393                token.text() == "local" || token.text().strip_prefix("Core$") == Some("local")
8394            }
8395            _ => false,
8396        }
8397    }
8398    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
8399        Self::matches_token_tree(&token).then_some(Self {
8400            raw: ::std::boxed::Box::new(token),
8401        })
8402    }
8403}
8404impl ::m2_syn::Parse for _LocalKeyword {
8405    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
8406        input.parse_token()
8407    }
8408}
8409impl ::m2_syn::ToTokens for _LocalKeyword {
8410    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8411        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
8412    }
8413}
8414impl ::m2_syn::PrettyTree for _LocalKeyword {
8415    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8416        ::m2_syn::PrettyNode::token(
8417            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
8418            <Self as ::m2_syn::Token>::SPELLING,
8419            ::m2_syn::Spanned::span(self),
8420        )
8421    }
8422}
8423impl<N> ::m2_syn::Reconstruct<N> for _LocalKeyword
8424where
8425    N: ::m2_syn::ExternalCstNode,
8426{
8427    fn matches(node: &N) -> bool {
8428        node.identity().matches("local", false)
8429    }
8430    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8431        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
8432            return Err(::m2_syn::ReconstructError::wrong_node(
8433                "local",
8434                false,
8435                node.identity(),
8436            ));
8437        }
8438        Ok(_LocalKeyword(node.span()))
8439    }
8440}
8441#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
8442pub struct _NewKeyword {
8443    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
8444}
8445#[doc(hidden)]
8446#[allow(non_snake_case)]
8447pub fn _NewKeyword<S: ::m2_syn::Spanned>(span: S) -> _NewKeyword {
8448    let span = span.span();
8449    _NewKeyword {
8450        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
8451            "new", span,
8452        ))),
8453    }
8454}
8455impl ::m2_syn::Token for _NewKeyword {
8456    const SPELLING: &'static str = "new";
8457    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
8458        match token {
8459            ::m2_syn::TokenTree::Ident(token) => {
8460                token.text() == "new" || token.text().strip_prefix("Core$") == Some("new")
8461            }
8462            _ => false,
8463        }
8464    }
8465    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
8466        Self::matches_token_tree(&token).then_some(Self {
8467            raw: ::std::boxed::Box::new(token),
8468        })
8469    }
8470}
8471impl ::m2_syn::Parse for _NewKeyword {
8472    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
8473        input.parse_token()
8474    }
8475}
8476impl ::m2_syn::ToTokens for _NewKeyword {
8477    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8478        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
8479    }
8480}
8481impl ::m2_syn::PrettyTree for _NewKeyword {
8482    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8483        ::m2_syn::PrettyNode::token(
8484            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
8485            <Self as ::m2_syn::Token>::SPELLING,
8486            ::m2_syn::Spanned::span(self),
8487        )
8488    }
8489}
8490impl<N> ::m2_syn::Reconstruct<N> for _NewKeyword
8491where
8492    N: ::m2_syn::ExternalCstNode,
8493{
8494    fn matches(node: &N) -> bool {
8495        node.identity().matches("new", false)
8496    }
8497    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8498        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
8499            return Err(::m2_syn::ReconstructError::wrong_node(
8500                "new",
8501                false,
8502                node.identity(),
8503            ));
8504        }
8505        Ok(_NewKeyword(node.span()))
8506    }
8507}
8508#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
8509pub struct _OfKeyword {
8510    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
8511}
8512#[doc(hidden)]
8513#[allow(non_snake_case)]
8514pub fn _OfKeyword<S: ::m2_syn::Spanned>(span: S) -> _OfKeyword {
8515    let span = span.span();
8516    _OfKeyword {
8517        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
8518            "of", span,
8519        ))),
8520    }
8521}
8522impl ::m2_syn::Token for _OfKeyword {
8523    const SPELLING: &'static str = "of";
8524    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
8525        match token {
8526            ::m2_syn::TokenTree::Ident(token) => {
8527                token.text() == "of" || token.text().strip_prefix("Core$") == Some("of")
8528            }
8529            _ => false,
8530        }
8531    }
8532    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
8533        Self::matches_token_tree(&token).then_some(Self {
8534            raw: ::std::boxed::Box::new(token),
8535        })
8536    }
8537}
8538impl ::m2_syn::Parse for _OfKeyword {
8539    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
8540        input.parse_token()
8541    }
8542}
8543impl ::m2_syn::ToTokens for _OfKeyword {
8544    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8545        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
8546    }
8547}
8548impl ::m2_syn::PrettyTree for _OfKeyword {
8549    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8550        ::m2_syn::PrettyNode::token(
8551            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
8552            <Self as ::m2_syn::Token>::SPELLING,
8553            ::m2_syn::Spanned::span(self),
8554        )
8555    }
8556}
8557impl<N> ::m2_syn::Reconstruct<N> for _OfKeyword
8558where
8559    N: ::m2_syn::ExternalCstNode,
8560{
8561    fn matches(node: &N) -> bool {
8562        node.identity().matches("of", false)
8563    }
8564    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8565        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
8566            return Err(::m2_syn::ReconstructError::wrong_node(
8567                "of",
8568                false,
8569                node.identity(),
8570            ));
8571        }
8572        Ok(_OfKeyword(node.span()))
8573    }
8574}
8575#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
8576pub struct _ProfileKeyword {
8577    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
8578}
8579#[doc(hidden)]
8580#[allow(non_snake_case)]
8581pub fn _ProfileKeyword<S: ::m2_syn::Spanned>(span: S) -> _ProfileKeyword {
8582    let span = span.span();
8583    _ProfileKeyword {
8584        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
8585            "profile", span,
8586        ))),
8587    }
8588}
8589impl ::m2_syn::Token for _ProfileKeyword {
8590    const SPELLING: &'static str = "profile";
8591    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
8592        match token {
8593            ::m2_syn::TokenTree::Ident(token) => {
8594                token.text() == "profile" || token.text().strip_prefix("Core$") == Some("profile")
8595            }
8596            _ => false,
8597        }
8598    }
8599    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
8600        Self::matches_token_tree(&token).then_some(Self {
8601            raw: ::std::boxed::Box::new(token),
8602        })
8603    }
8604}
8605impl ::m2_syn::Parse for _ProfileKeyword {
8606    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
8607        input.parse_token()
8608    }
8609}
8610impl ::m2_syn::ToTokens for _ProfileKeyword {
8611    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8612        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
8613    }
8614}
8615impl ::m2_syn::PrettyTree for _ProfileKeyword {
8616    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8617        ::m2_syn::PrettyNode::token(
8618            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
8619            <Self as ::m2_syn::Token>::SPELLING,
8620            ::m2_syn::Spanned::span(self),
8621        )
8622    }
8623}
8624impl<N> ::m2_syn::Reconstruct<N> for _ProfileKeyword
8625where
8626    N: ::m2_syn::ExternalCstNode,
8627{
8628    fn matches(node: &N) -> bool {
8629        node.identity().matches("profile", false)
8630    }
8631    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8632        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
8633            return Err(::m2_syn::ReconstructError::wrong_node(
8634                "profile",
8635                false,
8636                node.identity(),
8637            ));
8638        }
8639        Ok(_ProfileKeyword(node.span()))
8640    }
8641}
8642#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
8643pub struct _ReturnKeyword {
8644    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
8645}
8646#[doc(hidden)]
8647#[allow(non_snake_case)]
8648pub fn _ReturnKeyword<S: ::m2_syn::Spanned>(span: S) -> _ReturnKeyword {
8649    let span = span.span();
8650    _ReturnKeyword {
8651        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
8652            "return", span,
8653        ))),
8654    }
8655}
8656impl ::m2_syn::Token for _ReturnKeyword {
8657    const SPELLING: &'static str = "return";
8658    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
8659        match token {
8660            ::m2_syn::TokenTree::Ident(token) => {
8661                token.text() == "return" || token.text().strip_prefix("Core$") == Some("return")
8662            }
8663            _ => false,
8664        }
8665    }
8666    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
8667        Self::matches_token_tree(&token).then_some(Self {
8668            raw: ::std::boxed::Box::new(token),
8669        })
8670    }
8671}
8672impl ::m2_syn::Parse for _ReturnKeyword {
8673    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
8674        input.parse_token()
8675    }
8676}
8677impl ::m2_syn::ToTokens for _ReturnKeyword {
8678    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8679        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
8680    }
8681}
8682impl ::m2_syn::PrettyTree for _ReturnKeyword {
8683    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8684        ::m2_syn::PrettyNode::token(
8685            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
8686            <Self as ::m2_syn::Token>::SPELLING,
8687            ::m2_syn::Spanned::span(self),
8688        )
8689    }
8690}
8691impl<N> ::m2_syn::Reconstruct<N> for _ReturnKeyword
8692where
8693    N: ::m2_syn::ExternalCstNode,
8694{
8695    fn matches(node: &N) -> bool {
8696        node.identity().matches("return", false)
8697    }
8698    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8699        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
8700            return Err(::m2_syn::ReconstructError::wrong_node(
8701                "return",
8702                false,
8703                node.identity(),
8704            ));
8705        }
8706        Ok(_ReturnKeyword(node.span()))
8707    }
8708}
8709#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
8710pub struct _ShieldKeyword {
8711    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
8712}
8713#[doc(hidden)]
8714#[allow(non_snake_case)]
8715pub fn _ShieldKeyword<S: ::m2_syn::Spanned>(span: S) -> _ShieldKeyword {
8716    let span = span.span();
8717    _ShieldKeyword {
8718        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
8719            "shield", span,
8720        ))),
8721    }
8722}
8723impl ::m2_syn::Token for _ShieldKeyword {
8724    const SPELLING: &'static str = "shield";
8725    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
8726        match token {
8727            ::m2_syn::TokenTree::Ident(token) => {
8728                token.text() == "shield" || token.text().strip_prefix("Core$") == Some("shield")
8729            }
8730            _ => false,
8731        }
8732    }
8733    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
8734        Self::matches_token_tree(&token).then_some(Self {
8735            raw: ::std::boxed::Box::new(token),
8736        })
8737    }
8738}
8739impl ::m2_syn::Parse for _ShieldKeyword {
8740    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
8741        input.parse_token()
8742    }
8743}
8744impl ::m2_syn::ToTokens for _ShieldKeyword {
8745    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8746        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
8747    }
8748}
8749impl ::m2_syn::PrettyTree for _ShieldKeyword {
8750    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8751        ::m2_syn::PrettyNode::token(
8752            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
8753            <Self as ::m2_syn::Token>::SPELLING,
8754            ::m2_syn::Spanned::span(self),
8755        )
8756    }
8757}
8758impl<N> ::m2_syn::Reconstruct<N> for _ShieldKeyword
8759where
8760    N: ::m2_syn::ExternalCstNode,
8761{
8762    fn matches(node: &N) -> bool {
8763        node.identity().matches("shield", false)
8764    }
8765    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8766        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
8767            return Err(::m2_syn::ReconstructError::wrong_node(
8768                "shield",
8769                false,
8770                node.identity(),
8771            ));
8772        }
8773        Ok(_ShieldKeyword(node.span()))
8774    }
8775}
8776#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
8777pub struct _StepKeyword {
8778    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
8779}
8780#[doc(hidden)]
8781#[allow(non_snake_case)]
8782pub fn _StepKeyword<S: ::m2_syn::Spanned>(span: S) -> _StepKeyword {
8783    let span = span.span();
8784    _StepKeyword {
8785        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
8786            "step", span,
8787        ))),
8788    }
8789}
8790impl ::m2_syn::Token for _StepKeyword {
8791    const SPELLING: &'static str = "step";
8792    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
8793        match token {
8794            ::m2_syn::TokenTree::Ident(token) => {
8795                token.text() == "step" || token.text().strip_prefix("Core$") == Some("step")
8796            }
8797            _ => false,
8798        }
8799    }
8800    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
8801        Self::matches_token_tree(&token).then_some(Self {
8802            raw: ::std::boxed::Box::new(token),
8803        })
8804    }
8805}
8806impl ::m2_syn::Parse for _StepKeyword {
8807    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
8808        input.parse_token()
8809    }
8810}
8811impl ::m2_syn::ToTokens for _StepKeyword {
8812    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8813        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
8814    }
8815}
8816impl ::m2_syn::PrettyTree for _StepKeyword {
8817    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8818        ::m2_syn::PrettyNode::token(
8819            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
8820            <Self as ::m2_syn::Token>::SPELLING,
8821            ::m2_syn::Spanned::span(self),
8822        )
8823    }
8824}
8825impl<N> ::m2_syn::Reconstruct<N> for _StepKeyword
8826where
8827    N: ::m2_syn::ExternalCstNode,
8828{
8829    fn matches(node: &N) -> bool {
8830        node.identity().matches("step", false)
8831    }
8832    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8833        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
8834            return Err(::m2_syn::ReconstructError::wrong_node(
8835                "step",
8836                false,
8837                node.identity(),
8838            ));
8839        }
8840        Ok(_StepKeyword(node.span()))
8841    }
8842}
8843#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
8844pub struct _SymbolKeyword {
8845    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
8846}
8847#[doc(hidden)]
8848#[allow(non_snake_case)]
8849pub fn _SymbolKeyword<S: ::m2_syn::Spanned>(span: S) -> _SymbolKeyword {
8850    let span = span.span();
8851    _SymbolKeyword {
8852        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
8853            "symbol", span,
8854        ))),
8855    }
8856}
8857impl ::m2_syn::Token for _SymbolKeyword {
8858    const SPELLING: &'static str = "symbol";
8859    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
8860        match token {
8861            ::m2_syn::TokenTree::Ident(token) => {
8862                token.text() == "symbol" || token.text().strip_prefix("Core$") == Some("symbol")
8863            }
8864            _ => false,
8865        }
8866    }
8867    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
8868        Self::matches_token_tree(&token).then_some(Self {
8869            raw: ::std::boxed::Box::new(token),
8870        })
8871    }
8872}
8873impl ::m2_syn::Parse for _SymbolKeyword {
8874    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
8875        input.parse_token()
8876    }
8877}
8878impl ::m2_syn::ToTokens for _SymbolKeyword {
8879    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8880        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
8881    }
8882}
8883impl ::m2_syn::PrettyTree for _SymbolKeyword {
8884    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8885        ::m2_syn::PrettyNode::token(
8886            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
8887            <Self as ::m2_syn::Token>::SPELLING,
8888            ::m2_syn::Spanned::span(self),
8889        )
8890    }
8891}
8892impl<N> ::m2_syn::Reconstruct<N> for _SymbolKeyword
8893where
8894    N: ::m2_syn::ExternalCstNode,
8895{
8896    fn matches(node: &N) -> bool {
8897        node.identity().matches("symbol", false)
8898    }
8899    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8900        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
8901            return Err(::m2_syn::ReconstructError::wrong_node(
8902                "symbol",
8903                false,
8904                node.identity(),
8905            ));
8906        }
8907        Ok(_SymbolKeyword(node.span()))
8908    }
8909}
8910#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
8911pub struct _TestKeyword {
8912    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
8913}
8914#[doc(hidden)]
8915#[allow(non_snake_case)]
8916pub fn _TestKeyword<S: ::m2_syn::Spanned>(span: S) -> _TestKeyword {
8917    let span = span.span();
8918    _TestKeyword {
8919        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
8920            "TEST", span,
8921        ))),
8922    }
8923}
8924impl ::m2_syn::Token for _TestKeyword {
8925    const SPELLING: &'static str = "TEST";
8926    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
8927        match token {
8928            ::m2_syn::TokenTree::Ident(token) => {
8929                token.text() == "TEST" || token.text().strip_prefix("Core$") == Some("TEST")
8930            }
8931            _ => false,
8932        }
8933    }
8934    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
8935        Self::matches_token_tree(&token).then_some(Self {
8936            raw: ::std::boxed::Box::new(token),
8937        })
8938    }
8939}
8940impl ::m2_syn::Parse for _TestKeyword {
8941    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
8942        input.parse_token()
8943    }
8944}
8945impl ::m2_syn::ToTokens for _TestKeyword {
8946    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8947        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
8948    }
8949}
8950impl ::m2_syn::PrettyTree for _TestKeyword {
8951    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8952        ::m2_syn::PrettyNode::token(
8953            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
8954            <Self as ::m2_syn::Token>::SPELLING,
8955            ::m2_syn::Spanned::span(self),
8956        )
8957    }
8958}
8959impl<N> ::m2_syn::Reconstruct<N> for _TestKeyword
8960where
8961    N: ::m2_syn::ExternalCstNode,
8962{
8963    fn matches(node: &N) -> bool {
8964        node.identity().matches("TEST", false)
8965    }
8966    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8967        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
8968            return Err(::m2_syn::ReconstructError::wrong_node(
8969                "TEST",
8970                false,
8971                node.identity(),
8972            ));
8973        }
8974        Ok(_TestKeyword(node.span()))
8975    }
8976}
8977#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
8978pub struct _ThenKeyword {
8979    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
8980}
8981#[doc(hidden)]
8982#[allow(non_snake_case)]
8983pub fn _ThenKeyword<S: ::m2_syn::Spanned>(span: S) -> _ThenKeyword {
8984    let span = span.span();
8985    _ThenKeyword {
8986        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
8987            "then", span,
8988        ))),
8989    }
8990}
8991impl ::m2_syn::Token for _ThenKeyword {
8992    const SPELLING: &'static str = "then";
8993    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
8994        match token {
8995            ::m2_syn::TokenTree::Ident(token) => {
8996                token.text() == "then" || token.text().strip_prefix("Core$") == Some("then")
8997            }
8998            _ => false,
8999        }
9000    }
9001    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
9002        Self::matches_token_tree(&token).then_some(Self {
9003            raw: ::std::boxed::Box::new(token),
9004        })
9005    }
9006}
9007impl ::m2_syn::Parse for _ThenKeyword {
9008    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
9009        input.parse_token()
9010    }
9011}
9012impl ::m2_syn::ToTokens for _ThenKeyword {
9013    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9014        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
9015    }
9016}
9017impl ::m2_syn::PrettyTree for _ThenKeyword {
9018    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9019        ::m2_syn::PrettyNode::token(
9020            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
9021            <Self as ::m2_syn::Token>::SPELLING,
9022            ::m2_syn::Spanned::span(self),
9023        )
9024    }
9025}
9026impl<N> ::m2_syn::Reconstruct<N> for _ThenKeyword
9027where
9028    N: ::m2_syn::ExternalCstNode,
9029{
9030    fn matches(node: &N) -> bool {
9031        node.identity().matches("then", false)
9032    }
9033    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9034        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
9035            return Err(::m2_syn::ReconstructError::wrong_node(
9036                "then",
9037                false,
9038                node.identity(),
9039            ));
9040        }
9041        Ok(_ThenKeyword(node.span()))
9042    }
9043}
9044#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
9045pub struct _ThreadLocalKeyword {
9046    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
9047}
9048#[doc(hidden)]
9049#[allow(non_snake_case)]
9050pub fn _ThreadLocalKeyword<S: ::m2_syn::Spanned>(span: S) -> _ThreadLocalKeyword {
9051    let span = span.span();
9052    _ThreadLocalKeyword {
9053        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
9054            "threadLocal",
9055            span,
9056        ))),
9057    }
9058}
9059impl ::m2_syn::Token for _ThreadLocalKeyword {
9060    const SPELLING: &'static str = "threadLocal";
9061    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
9062        match token {
9063            ::m2_syn::TokenTree::Ident(token) => {
9064                token.text() == "threadLocal"
9065                    || token.text().strip_prefix("Core$") == Some("threadLocal")
9066            }
9067            _ => false,
9068        }
9069    }
9070    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
9071        Self::matches_token_tree(&token).then_some(Self {
9072            raw: ::std::boxed::Box::new(token),
9073        })
9074    }
9075}
9076impl ::m2_syn::Parse for _ThreadLocalKeyword {
9077    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
9078        input.parse_token()
9079    }
9080}
9081impl ::m2_syn::ToTokens for _ThreadLocalKeyword {
9082    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9083        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
9084    }
9085}
9086impl ::m2_syn::PrettyTree for _ThreadLocalKeyword {
9087    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9088        ::m2_syn::PrettyNode::token(
9089            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
9090            <Self as ::m2_syn::Token>::SPELLING,
9091            ::m2_syn::Spanned::span(self),
9092        )
9093    }
9094}
9095impl<N> ::m2_syn::Reconstruct<N> for _ThreadLocalKeyword
9096where
9097    N: ::m2_syn::ExternalCstNode,
9098{
9099    fn matches(node: &N) -> bool {
9100        node.identity().matches("threadLocal", false)
9101    }
9102    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9103        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
9104            return Err(::m2_syn::ReconstructError::wrong_node(
9105                "threadLocal",
9106                false,
9107                node.identity(),
9108            ));
9109        }
9110        Ok(_ThreadLocalKeyword(node.span()))
9111    }
9112}
9113#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
9114pub struct _ThreadVariableKeyword {
9115    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
9116}
9117#[doc(hidden)]
9118#[allow(non_snake_case)]
9119pub fn _ThreadVariableKeyword<S: ::m2_syn::Spanned>(span: S) -> _ThreadVariableKeyword {
9120    let span = span.span();
9121    _ThreadVariableKeyword {
9122        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
9123            "threadVariable",
9124            span,
9125        ))),
9126    }
9127}
9128impl ::m2_syn::Token for _ThreadVariableKeyword {
9129    const SPELLING: &'static str = "threadVariable";
9130    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
9131        match token {
9132            ::m2_syn::TokenTree::Ident(token) => {
9133                token.text() == "threadVariable"
9134                    || token.text().strip_prefix("Core$") == Some("threadVariable")
9135            }
9136            _ => false,
9137        }
9138    }
9139    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
9140        Self::matches_token_tree(&token).then_some(Self {
9141            raw: ::std::boxed::Box::new(token),
9142        })
9143    }
9144}
9145impl ::m2_syn::Parse for _ThreadVariableKeyword {
9146    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
9147        input.parse_token()
9148    }
9149}
9150impl ::m2_syn::ToTokens for _ThreadVariableKeyword {
9151    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9152        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
9153    }
9154}
9155impl ::m2_syn::PrettyTree for _ThreadVariableKeyword {
9156    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9157        ::m2_syn::PrettyNode::token(
9158            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
9159            <Self as ::m2_syn::Token>::SPELLING,
9160            ::m2_syn::Spanned::span(self),
9161        )
9162    }
9163}
9164impl<N> ::m2_syn::Reconstruct<N> for _ThreadVariableKeyword
9165where
9166    N: ::m2_syn::ExternalCstNode,
9167{
9168    fn matches(node: &N) -> bool {
9169        node.identity().matches("threadVariable", false)
9170    }
9171    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9172        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
9173            return Err(::m2_syn::ReconstructError::wrong_node(
9174                "threadVariable",
9175                false,
9176                node.identity(),
9177            ));
9178        }
9179        Ok(_ThreadVariableKeyword(node.span()))
9180    }
9181}
9182#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
9183pub struct _ThrowKeyword {
9184    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
9185}
9186#[doc(hidden)]
9187#[allow(non_snake_case)]
9188pub fn _ThrowKeyword<S: ::m2_syn::Spanned>(span: S) -> _ThrowKeyword {
9189    let span = span.span();
9190    _ThrowKeyword {
9191        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
9192            "throw", span,
9193        ))),
9194    }
9195}
9196impl ::m2_syn::Token for _ThrowKeyword {
9197    const SPELLING: &'static str = "throw";
9198    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
9199        match token {
9200            ::m2_syn::TokenTree::Ident(token) => {
9201                token.text() == "throw" || token.text().strip_prefix("Core$") == Some("throw")
9202            }
9203            _ => false,
9204        }
9205    }
9206    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
9207        Self::matches_token_tree(&token).then_some(Self {
9208            raw: ::std::boxed::Box::new(token),
9209        })
9210    }
9211}
9212impl ::m2_syn::Parse for _ThrowKeyword {
9213    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
9214        input.parse_token()
9215    }
9216}
9217impl ::m2_syn::ToTokens for _ThrowKeyword {
9218    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9219        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
9220    }
9221}
9222impl ::m2_syn::PrettyTree for _ThrowKeyword {
9223    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9224        ::m2_syn::PrettyNode::token(
9225            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
9226            <Self as ::m2_syn::Token>::SPELLING,
9227            ::m2_syn::Spanned::span(self),
9228        )
9229    }
9230}
9231impl<N> ::m2_syn::Reconstruct<N> for _ThrowKeyword
9232where
9233    N: ::m2_syn::ExternalCstNode,
9234{
9235    fn matches(node: &N) -> bool {
9236        node.identity().matches("throw", false)
9237    }
9238    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9239        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
9240            return Err(::m2_syn::ReconstructError::wrong_node(
9241                "throw",
9242                false,
9243                node.identity(),
9244            ));
9245        }
9246        Ok(_ThrowKeyword(node.span()))
9247    }
9248}
9249#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
9250pub struct _TimeKeyword {
9251    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
9252}
9253#[doc(hidden)]
9254#[allow(non_snake_case)]
9255pub fn _TimeKeyword<S: ::m2_syn::Spanned>(span: S) -> _TimeKeyword {
9256    let span = span.span();
9257    _TimeKeyword {
9258        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
9259            "time", span,
9260        ))),
9261    }
9262}
9263impl ::m2_syn::Token for _TimeKeyword {
9264    const SPELLING: &'static str = "time";
9265    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
9266        match token {
9267            ::m2_syn::TokenTree::Ident(token) => {
9268                token.text() == "time" || token.text().strip_prefix("Core$") == Some("time")
9269            }
9270            _ => false,
9271        }
9272    }
9273    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
9274        Self::matches_token_tree(&token).then_some(Self {
9275            raw: ::std::boxed::Box::new(token),
9276        })
9277    }
9278}
9279impl ::m2_syn::Parse for _TimeKeyword {
9280    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
9281        input.parse_token()
9282    }
9283}
9284impl ::m2_syn::ToTokens for _TimeKeyword {
9285    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9286        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
9287    }
9288}
9289impl ::m2_syn::PrettyTree for _TimeKeyword {
9290    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9291        ::m2_syn::PrettyNode::token(
9292            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
9293            <Self as ::m2_syn::Token>::SPELLING,
9294            ::m2_syn::Spanned::span(self),
9295        )
9296    }
9297}
9298impl<N> ::m2_syn::Reconstruct<N> for _TimeKeyword
9299where
9300    N: ::m2_syn::ExternalCstNode,
9301{
9302    fn matches(node: &N) -> bool {
9303        node.identity().matches("time", false)
9304    }
9305    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9306        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
9307            return Err(::m2_syn::ReconstructError::wrong_node(
9308                "time",
9309                false,
9310                node.identity(),
9311            ));
9312        }
9313        Ok(_TimeKeyword(node.span()))
9314    }
9315}
9316#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
9317pub struct _TimingKeyword {
9318    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
9319}
9320#[doc(hidden)]
9321#[allow(non_snake_case)]
9322pub fn _TimingKeyword<S: ::m2_syn::Spanned>(span: S) -> _TimingKeyword {
9323    let span = span.span();
9324    _TimingKeyword {
9325        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
9326            "timing", span,
9327        ))),
9328    }
9329}
9330impl ::m2_syn::Token for _TimingKeyword {
9331    const SPELLING: &'static str = "timing";
9332    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
9333        match token {
9334            ::m2_syn::TokenTree::Ident(token) => {
9335                token.text() == "timing" || token.text().strip_prefix("Core$") == Some("timing")
9336            }
9337            _ => false,
9338        }
9339    }
9340    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
9341        Self::matches_token_tree(&token).then_some(Self {
9342            raw: ::std::boxed::Box::new(token),
9343        })
9344    }
9345}
9346impl ::m2_syn::Parse for _TimingKeyword {
9347    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
9348        input.parse_token()
9349    }
9350}
9351impl ::m2_syn::ToTokens for _TimingKeyword {
9352    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9353        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
9354    }
9355}
9356impl ::m2_syn::PrettyTree for _TimingKeyword {
9357    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9358        ::m2_syn::PrettyNode::token(
9359            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
9360            <Self as ::m2_syn::Token>::SPELLING,
9361            ::m2_syn::Spanned::span(self),
9362        )
9363    }
9364}
9365impl<N> ::m2_syn::Reconstruct<N> for _TimingKeyword
9366where
9367    N: ::m2_syn::ExternalCstNode,
9368{
9369    fn matches(node: &N) -> bool {
9370        node.identity().matches("timing", false)
9371    }
9372    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9373        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
9374            return Err(::m2_syn::ReconstructError::wrong_node(
9375                "timing",
9376                false,
9377                node.identity(),
9378            ));
9379        }
9380        Ok(_TimingKeyword(node.span()))
9381    }
9382}
9383#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
9384pub struct _ToKeyword {
9385    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
9386}
9387#[doc(hidden)]
9388#[allow(non_snake_case)]
9389pub fn _ToKeyword<S: ::m2_syn::Spanned>(span: S) -> _ToKeyword {
9390    let span = span.span();
9391    _ToKeyword {
9392        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
9393            "to", span,
9394        ))),
9395    }
9396}
9397impl ::m2_syn::Token for _ToKeyword {
9398    const SPELLING: &'static str = "to";
9399    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
9400        match token {
9401            ::m2_syn::TokenTree::Ident(token) => {
9402                token.text() == "to" || token.text().strip_prefix("Core$") == Some("to")
9403            }
9404            _ => false,
9405        }
9406    }
9407    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
9408        Self::matches_token_tree(&token).then_some(Self {
9409            raw: ::std::boxed::Box::new(token),
9410        })
9411    }
9412}
9413impl ::m2_syn::Parse for _ToKeyword {
9414    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
9415        input.parse_token()
9416    }
9417}
9418impl ::m2_syn::ToTokens for _ToKeyword {
9419    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9420        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
9421    }
9422}
9423impl ::m2_syn::PrettyTree for _ToKeyword {
9424    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9425        ::m2_syn::PrettyNode::token(
9426            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
9427            <Self as ::m2_syn::Token>::SPELLING,
9428            ::m2_syn::Spanned::span(self),
9429        )
9430    }
9431}
9432impl<N> ::m2_syn::Reconstruct<N> for _ToKeyword
9433where
9434    N: ::m2_syn::ExternalCstNode,
9435{
9436    fn matches(node: &N) -> bool {
9437        node.identity().matches("to", false)
9438    }
9439    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9440        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
9441            return Err(::m2_syn::ReconstructError::wrong_node(
9442                "to",
9443                false,
9444                node.identity(),
9445            ));
9446        }
9447        Ok(_ToKeyword(node.span()))
9448    }
9449}
9450#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
9451pub struct _TrapKeyword {
9452    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
9453}
9454#[doc(hidden)]
9455#[allow(non_snake_case)]
9456pub fn _TrapKeyword<S: ::m2_syn::Spanned>(span: S) -> _TrapKeyword {
9457    let span = span.span();
9458    _TrapKeyword {
9459        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
9460            "trap", span,
9461        ))),
9462    }
9463}
9464impl ::m2_syn::Token for _TrapKeyword {
9465    const SPELLING: &'static str = "trap";
9466    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
9467        match token {
9468            ::m2_syn::TokenTree::Ident(token) => {
9469                token.text() == "trap" || token.text().strip_prefix("Core$") == Some("trap")
9470            }
9471            _ => false,
9472        }
9473    }
9474    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
9475        Self::matches_token_tree(&token).then_some(Self {
9476            raw: ::std::boxed::Box::new(token),
9477        })
9478    }
9479}
9480impl ::m2_syn::Parse for _TrapKeyword {
9481    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
9482        input.parse_token()
9483    }
9484}
9485impl ::m2_syn::ToTokens for _TrapKeyword {
9486    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9487        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
9488    }
9489}
9490impl ::m2_syn::PrettyTree for _TrapKeyword {
9491    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9492        ::m2_syn::PrettyNode::token(
9493            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
9494            <Self as ::m2_syn::Token>::SPELLING,
9495            ::m2_syn::Spanned::span(self),
9496        )
9497    }
9498}
9499impl<N> ::m2_syn::Reconstruct<N> for _TrapKeyword
9500where
9501    N: ::m2_syn::ExternalCstNode,
9502{
9503    fn matches(node: &N) -> bool {
9504        node.identity().matches("trap", false)
9505    }
9506    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9507        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
9508            return Err(::m2_syn::ReconstructError::wrong_node(
9509                "trap",
9510                false,
9511                node.identity(),
9512            ));
9513        }
9514        Ok(_TrapKeyword(node.span()))
9515    }
9516}
9517#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
9518pub struct _TryKeyword {
9519    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
9520}
9521#[doc(hidden)]
9522#[allow(non_snake_case)]
9523pub fn _TryKeyword<S: ::m2_syn::Spanned>(span: S) -> _TryKeyword {
9524    let span = span.span();
9525    _TryKeyword {
9526        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
9527            "try", span,
9528        ))),
9529    }
9530}
9531impl ::m2_syn::Token for _TryKeyword {
9532    const SPELLING: &'static str = "try";
9533    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
9534        match token {
9535            ::m2_syn::TokenTree::Ident(token) => {
9536                token.text() == "try" || token.text().strip_prefix("Core$") == Some("try")
9537            }
9538            _ => false,
9539        }
9540    }
9541    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
9542        Self::matches_token_tree(&token).then_some(Self {
9543            raw: ::std::boxed::Box::new(token),
9544        })
9545    }
9546}
9547impl ::m2_syn::Parse for _TryKeyword {
9548    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
9549        input.parse_token()
9550    }
9551}
9552impl ::m2_syn::ToTokens for _TryKeyword {
9553    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9554        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
9555    }
9556}
9557impl ::m2_syn::PrettyTree for _TryKeyword {
9558    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9559        ::m2_syn::PrettyNode::token(
9560            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
9561            <Self as ::m2_syn::Token>::SPELLING,
9562            ::m2_syn::Spanned::span(self),
9563        )
9564    }
9565}
9566impl<N> ::m2_syn::Reconstruct<N> for _TryKeyword
9567where
9568    N: ::m2_syn::ExternalCstNode,
9569{
9570    fn matches(node: &N) -> bool {
9571        node.identity().matches("try", false)
9572    }
9573    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9574        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
9575            return Err(::m2_syn::ReconstructError::wrong_node(
9576                "try",
9577                false,
9578                node.identity(),
9579            ));
9580        }
9581        Ok(_TryKeyword(node.span()))
9582    }
9583}
9584#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
9585pub struct _WhenKeyword {
9586    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
9587}
9588#[doc(hidden)]
9589#[allow(non_snake_case)]
9590pub fn _WhenKeyword<S: ::m2_syn::Spanned>(span: S) -> _WhenKeyword {
9591    let span = span.span();
9592    _WhenKeyword {
9593        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
9594            "when", span,
9595        ))),
9596    }
9597}
9598impl ::m2_syn::Token for _WhenKeyword {
9599    const SPELLING: &'static str = "when";
9600    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
9601        match token {
9602            ::m2_syn::TokenTree::Ident(token) => {
9603                token.text() == "when" || token.text().strip_prefix("Core$") == Some("when")
9604            }
9605            _ => false,
9606        }
9607    }
9608    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
9609        Self::matches_token_tree(&token).then_some(Self {
9610            raw: ::std::boxed::Box::new(token),
9611        })
9612    }
9613}
9614impl ::m2_syn::Parse for _WhenKeyword {
9615    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
9616        input.parse_token()
9617    }
9618}
9619impl ::m2_syn::ToTokens for _WhenKeyword {
9620    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9621        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
9622    }
9623}
9624impl ::m2_syn::PrettyTree for _WhenKeyword {
9625    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9626        ::m2_syn::PrettyNode::token(
9627            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
9628            <Self as ::m2_syn::Token>::SPELLING,
9629            ::m2_syn::Spanned::span(self),
9630        )
9631    }
9632}
9633impl<N> ::m2_syn::Reconstruct<N> for _WhenKeyword
9634where
9635    N: ::m2_syn::ExternalCstNode,
9636{
9637    fn matches(node: &N) -> bool {
9638        node.identity().matches("when", false)
9639    }
9640    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9641        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
9642            return Err(::m2_syn::ReconstructError::wrong_node(
9643                "when",
9644                false,
9645                node.identity(),
9646            ));
9647        }
9648        Ok(_WhenKeyword(node.span()))
9649    }
9650}
9651#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
9652pub struct _WhileKeyword {
9653    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
9654}
9655#[doc(hidden)]
9656#[allow(non_snake_case)]
9657pub fn _WhileKeyword<S: ::m2_syn::Spanned>(span: S) -> _WhileKeyword {
9658    let span = span.span();
9659    _WhileKeyword {
9660        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Ident(::m2_syn::IdentToken::new(
9661            "while", span,
9662        ))),
9663    }
9664}
9665impl ::m2_syn::Token for _WhileKeyword {
9666    const SPELLING: &'static str = "while";
9667    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
9668        match token {
9669            ::m2_syn::TokenTree::Ident(token) => {
9670                token.text() == "while" || token.text().strip_prefix("Core$") == Some("while")
9671            }
9672            _ => false,
9673        }
9674    }
9675    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
9676        Self::matches_token_tree(&token).then_some(Self {
9677            raw: ::std::boxed::Box::new(token),
9678        })
9679    }
9680}
9681impl ::m2_syn::Parse for _WhileKeyword {
9682    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
9683        input.parse_token()
9684    }
9685}
9686impl ::m2_syn::ToTokens for _WhileKeyword {
9687    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9688        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
9689    }
9690}
9691impl ::m2_syn::PrettyTree for _WhileKeyword {
9692    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9693        ::m2_syn::PrettyNode::token(
9694            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
9695            <Self as ::m2_syn::Token>::SPELLING,
9696            ::m2_syn::Spanned::span(self),
9697        )
9698    }
9699}
9700impl<N> ::m2_syn::Reconstruct<N> for _WhileKeyword
9701where
9702    N: ::m2_syn::ExternalCstNode,
9703{
9704    fn matches(node: &N) -> bool {
9705        node.identity().matches("while", false)
9706    }
9707    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9708        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
9709            return Err(::m2_syn::ReconstructError::wrong_node(
9710                "while",
9711                false,
9712                node.identity(),
9713            ));
9714        }
9715        Ok(_WhileKeyword(node.span()))
9716    }
9717}
9718#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
9719pub struct _Scl {
9720    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
9721}
9722#[doc(hidden)]
9723#[allow(non_snake_case)]
9724pub fn _Scl<S: ::m2_syn::Spanned>(span: S) -> _Scl {
9725    let span = span.span();
9726    _Scl {
9727        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(";", span))),
9728    }
9729}
9730impl ::m2_syn::Token for _Scl {
9731    const SPELLING: &'static str = ";";
9732    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
9733        match token {
9734            ::m2_syn::TokenTree::Punct(token) => token.text() == ";",
9735            _ => false,
9736        }
9737    }
9738    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
9739        Self::matches_token_tree(&token).then_some(Self {
9740            raw: ::std::boxed::Box::new(token),
9741        })
9742    }
9743}
9744impl ::m2_syn::Parse for _Scl {
9745    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
9746        input.parse_token()
9747    }
9748}
9749impl ::m2_syn::ToTokens for _Scl {
9750    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9751        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
9752    }
9753}
9754impl ::m2_syn::PrettyTree for _Scl {
9755    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9756        ::m2_syn::PrettyNode::token(
9757            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
9758            <Self as ::m2_syn::Token>::SPELLING,
9759            ::m2_syn::Spanned::span(self),
9760        )
9761    }
9762}
9763impl<N> ::m2_syn::Reconstruct<N> for _Scl
9764where
9765    N: ::m2_syn::ExternalCstNode,
9766{
9767    fn matches(node: &N) -> bool {
9768        node.identity().matches(";", false)
9769    }
9770    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9771        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
9772            return Err(::m2_syn::ReconstructError::wrong_node(
9773                ";",
9774                false,
9775                node.identity(),
9776            ));
9777        }
9778        Ok(_Scl(node.span()))
9779    }
9780}
9781#[derive(Debug, Clone, PartialEq, Eq, ::m2_syn::Spanned)]
9782pub struct _Cma {
9783    raw: ::std::boxed::Box<::m2_syn::TokenTree>,
9784}
9785#[doc(hidden)]
9786#[allow(non_snake_case)]
9787pub fn _Cma<S: ::m2_syn::Spanned>(span: S) -> _Cma {
9788    let span = span.span();
9789    _Cma {
9790        raw: ::std::boxed::Box::new(::m2_syn::TokenTree::Punct(::m2_syn::Punct::new(",", span))),
9791    }
9792}
9793impl ::m2_syn::Token for _Cma {
9794    const SPELLING: &'static str = ",";
9795    fn matches_token_tree(token: &::m2_syn::TokenTree) -> bool {
9796        match token {
9797            ::m2_syn::TokenTree::Punct(token) => token.text() == ",",
9798            _ => false,
9799        }
9800    }
9801    fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
9802        Self::matches_token_tree(&token).then_some(Self {
9803            raw: ::std::boxed::Box::new(token),
9804        })
9805    }
9806}
9807impl ::m2_syn::Parse for _Cma {
9808    fn parse(input: &mut ::m2_syn::ParseStream) -> Result<Self, ::m2_syn::TokenParseError> {
9809        input.parse_token()
9810    }
9811}
9812impl ::m2_syn::ToTokens for _Cma {
9813    fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9814        ::m2_syn::ToTokens::to_tokens(&self.raw, output);
9815    }
9816}
9817impl ::m2_syn::PrettyTree for _Cma {
9818    fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9819        ::m2_syn::PrettyNode::token(
9820            ::std::format!("Token![{}]", <Self as ::m2_syn::Token>::SPELLING),
9821            <Self as ::m2_syn::Token>::SPELLING,
9822            ::m2_syn::Spanned::span(self),
9823        )
9824    }
9825}
9826impl<N> ::m2_syn::Reconstruct<N> for _Cma
9827where
9828    N: ::m2_syn::ExternalCstNode,
9829{
9830    fn matches(node: &N) -> bool {
9831        node.identity().matches(",", false)
9832    }
9833    fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9834        if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
9835            return Err(::m2_syn::ReconstructError::wrong_node(
9836                ",",
9837                false,
9838                node.identity(),
9839            ));
9840        }
9841        Ok(_Cma(node.span()))
9842    }
9843}
9844#[macro_export]
9845macro_rules! Token {
9846    [!=] => { $crate::_BngEql };
9847    [#] => { $crate::_Hsh };
9848    [#?] => { $crate::_HshQsm };
9849    [%] => { $crate::_Mod };
9850    [%=] => { $crate::_ModEql };
9851    [&] => { $crate::_Amp };
9852    [&=] => { $crate::_AmpEql };
9853    [*] => { $crate::_Mul };
9854    [*=] => { $crate::_MulEql };
9855    [**] => { $crate::_MulMul };
9856    [**=] => { $crate::_MulMulEql };
9857    [+] => { $crate::_Add };
9858    [+=] => { $crate::_AddEql };
9859    [++] => { $crate::_AddAdd };
9860    [++=] => { $crate::_AddAddEql };
9861    [-] => { $crate::_Sub };
9862    [-=] => { $crate::_SubEql };
9863    [->] => { $crate::_SubGst };
9864    [.] => { $crate::_Dot };
9865    [..] => { $crate::_DotDot };
9866    [..=] => { $crate::_DotDotEql };
9867    [..<] => { $crate::_DotDotLst };
9868    [..<=] => { $crate::_DotDotLstEql };
9869    [.?] => { $crate::_DotQsm };
9870    [/] => { $crate::_Slh };
9871    [/=] => { $crate::_SlhEql };
9872    [/ /] => { $crate::_SlhSlh };
9873    [/ /=] => { $crate::_SlhSlhEql };
9874    [:] => { $crate::_Col };
9875    [:=] => { $crate::_ColEql };
9876    [<] => { $crate::_Lst };
9877    [<-] => { $crate::_LstSub };
9878    [<<] => { $crate::_LstLst };
9879    [<<=] => { $crate::_LstLstEql };
9880    [<=] => { $crate::_LstEql };
9881    [<==] => { $crate::_LstEqlEql };
9882    [<===] => { $crate::_LstEqlEqlEql };
9883    [<==>] => { $crate::_LstEqlEqlGst };
9884    [<==>=] => { $crate::_LstEqlEqlGstEql };
9885    [=] => { $crate::_Eql };
9886    [=!=] => { $crate::_EqlBngEql };
9887    [==] => { $crate::_EqlEql };
9888    [===] => { $crate::_EqlEqlEql };
9889    [===>] => { $crate::_EqlEqlEqlGst };
9890    [===>=] => { $crate::_EqlEqlEqlGstEql };
9891    [==>] => { $crate::_EqlEqlGst };
9892    [==>=] => { $crate::_EqlEqlGstEql };
9893    [=>] => { $crate::_EqlGst };
9894    [>] => { $crate::_Gst };
9895    [>=] => { $crate::_GstEql };
9896    [>>] => { $crate::_GstGst };
9897    [>>=] => { $crate::_GstGstEql };
9898    [?] => { $crate::_Qsm };
9899    [??] => { $crate::_QsmQsm };
9900    [??=] => { $crate::_QsmQsmEql };
9901    [@] => { $crate::_Att };
9902    [@=] => { $crate::_AttEql };
9903    [@@] => { $crate::_AttAtt };
9904    [@@=] => { $crate::_AttAttEql };
9905    [@@?] => { $crate::_AttAttQsm };
9906    [@@?=] => { $crate::_AttAttQsmEql };
9907    ["\\"] => { $crate::_Bsl };
9908    ["\\="] => { $crate::_BslEql };
9909    ["\\\\"] => { $crate::_BslBsl };
9910    ["\\\\="] => { $crate::_BslBslEql };
9911    [^] => { $crate::_Crt };
9912    [^=] => { $crate::_CrtEql };
9913    [^**] => { $crate::_CrtMulMul };
9914    [^**=] => { $crate::_CrtMulMulEql };
9915    [^<] => { $crate::_CrtLst };
9916    [^<=] => { $crate::_CrtLstEql };
9917    [^>] => { $crate::_CrtGst };
9918    [^>=] => { $crate::_CrtGstEql };
9919    [^^] => { $crate::_CrtCrt };
9920    [^^=] => { $crate::_CrtCrtEql };
9921    [_] => { $crate::_Ubs };
9922    [_=] => { $crate::_UbsEql };
9923    [_<] => { $crate::_UbsLst };
9924    [_<=] => { $crate::_UbsLstEql };
9925    [_>] => { $crate::_UbsGst };
9926    [_>=] => { $crate::_UbsGstEql };
9927    [|] => { $crate::_Pip };
9928    [|=] => { $crate::_PipEql };
9929    [|-] => { $crate::_PipSub };
9930    [|-=] => { $crate::_PipSubEql };
9931    [|_] => { $crate::_PipUbs };
9932    [|_=] => { $crate::_PipUbsEql };
9933    [||] => { $crate::_PipPip };
9934    [||=] => { $crate::_PipPipEql };
9935    [~] => { $crate::_Tld };
9936    [~=] => { $crate::_TldEql };
9937    ["·"] => { $crate::_Cdt };
9938    ["·="] => { $crate::_CdtEql };
9939    ["⊠"] => { $crate::_Box };
9940    ["⊠="] => { $crate::_BoxEql };
9941    ["⧢"] => { $crate::_Sfp };
9942    ["⧢="] => { $crate::_SfpEql };
9943    [and] => { $crate::_And };
9944    [or] => { $crate::_Or };
9945    [SPACE] => { $crate::_Space };
9946    [xor] => { $crate::_Xor };
9947    [!] => { $crate::_Bng };
9948    [(*)] => { $crate::_Graded };
9949    [^!] => { $crate::_CrtBng };
9950    [^*] => { $crate::_CrtMul };
9951    [^~] => { $crate::_CrtTld };
9952    [_!] => { $crate::_UbsBng };
9953    [_*] => { $crate::_UbsMul };
9954    [_~] => { $crate::_UbsTld };
9955    [not] => { $crate::_Not };
9956    [break] => { $crate::_BreakKeyword };
9957    [breakpoint] => { $crate::_BreakpointKeyword };
9958    [catch] => { $crate::_CatchKeyword };
9959    [continue] => { $crate::_ContinueKeyword };
9960    [do] => { $crate::_DoKeyword };
9961    [elapsedTime] => { $crate::_ElapsedTimeKeyword };
9962    [elapsedTiming] => { $crate::_ElapsedTimingKeyword };
9963    [else] => { $crate::_ElseKeyword };
9964    [except] => { $crate::_ExceptKeyword };
9965    [finish] => { $crate::_FinishKeyword };
9966    [for] => { $crate::_ForKeyword };
9967    [from] => { $crate::_FromKeyword };
9968    [global] => { $crate::_GlobalKeyword };
9969    [if] => { $crate::_IfKeyword };
9970    [in] => { $crate::_InKeyword };
9971    [list] => { $crate::_ListKeyword };
9972    [local] => { $crate::_LocalKeyword };
9973    [new] => { $crate::_NewKeyword };
9974    [of] => { $crate::_OfKeyword };
9975    [profile] => { $crate::_ProfileKeyword };
9976    [return] => { $crate::_ReturnKeyword };
9977    [shield] => { $crate::_ShieldKeyword };
9978    [step] => { $crate::_StepKeyword };
9979    [symbol] => { $crate::_SymbolKeyword };
9980    [TEST] => { $crate::_TestKeyword };
9981    [then] => { $crate::_ThenKeyword };
9982    [threadLocal] => { $crate::_ThreadLocalKeyword };
9983    [threadVariable] => { $crate::_ThreadVariableKeyword };
9984    [throw] => { $crate::_ThrowKeyword };
9985    [time] => { $crate::_TimeKeyword };
9986    [timing] => { $crate::_TimingKeyword };
9987    [to] => { $crate::_ToKeyword };
9988    [trap] => { $crate::_TrapKeyword };
9989    [try] => { $crate::_TryKeyword };
9990    [when] => { $crate::_WhenKeyword };
9991    [while] => { $crate::_WhileKeyword };
9992    [;] => { $crate::_Scl };
9993    [,] => { $crate::_Cma };
9994    [$($unsupported:tt)*] => { compile_error!("token was not declared in `syntax!`") };
9995}
9996#[doc(hidden)]
9997#[macro_export]
9998macro_rules! __m2_syn_parse_info {
9999    ($spelling:expr , $parse_info:ident) => {
10000        match $spelling {
10001            "!=" => Some($parse_info::binary(36u8, 35u8)),
10002            "#" => Some($parse_info::prefix_binary(70u8, 70u8, 61u8)),
10003            "#?" => Some($parse_info::binary(70u8, 70u8)),
10004            "%" => Some($parse_info::binary(58u8, 58u8)),
10005            "%=" => Some($parse_info::binary(14u8, 13u8)),
10006            "&" => Some($parse_info::binary(46u8, 46u8)),
10007            "&=" => Some($parse_info::binary(14u8, 13u8)),
10008            "*" => Some($parse_info::prefix_binary(58u8, 58u8, 58u8)),
10009            "*=" => Some($parse_info::binary(14u8, 13u8)),
10010            "**" => Some($parse_info::binary(54u8, 54u8)),
10011            "**=" => Some($parse_info::binary(14u8, 13u8)),
10012            "+" => Some($parse_info::prefix_binary(50u8, 50u8, 50u8)),
10013            "+=" => Some($parse_info::binary(14u8, 13u8)),
10014            "++" => Some($parse_info::binary(50u8, 50u8)),
10015            "++=" => Some($parse_info::binary(14u8, 13u8)),
10016            "-" => Some($parse_info::prefix_binary(50u8, 50u8, 50u8)),
10017            "-=" => Some($parse_info::binary(14u8, 13u8)),
10018            "->" => Some($parse_info::binary(14u8, 13u8)),
10019            "." => Some($parse_info::binary(70u8, 70u8)),
10020            ".." => Some($parse_info::binary(48u8, 48u8)),
10021            "..=" => Some($parse_info::binary(14u8, 13u8)),
10022            "..<" => Some($parse_info::binary(48u8, 48u8)),
10023            "..<=" => Some($parse_info::binary(14u8, 13u8)),
10024            ".?" => Some($parse_info::binary(70u8, 70u8)),
10025            "/" => Some($parse_info::binary(58u8, 58u8)),
10026            "/=" => Some($parse_info::binary(14u8, 13u8)),
10027            "//" => Some($parse_info::binary(58u8, 58u8)),
10028            "//=" => Some($parse_info::binary(14u8, 13u8)),
10029            ":" => Some($parse_info::binary(40u8, 39u8)),
10030            ":=" => Some($parse_info::binary(14u8, 13u8)),
10031            "<" => Some($parse_info::prefix_binary(36u8, 35u8, 36u8)),
10032            "<-" => Some($parse_info::binary(14u8, 13u8)),
10033            "<<" => Some($parse_info::prefix_binary(18u8, 18u8, 18u8)),
10034            "<<=" => Some($parse_info::binary(14u8, 13u8)),
10035            "<=" => Some($parse_info::prefix_binary(36u8, 35u8, 36u8)),
10036            "<==" => Some($parse_info::prefix_binary(26u8, 25u8, 26u8)),
10037            "<===" => Some($parse_info::prefix_binary(22u8, 21u8, 22u8)),
10038            "<==>" => Some($parse_info::binary(24u8, 23u8)),
10039            "<==>=" => Some($parse_info::binary(14u8, 13u8)),
10040            "=" => Some($parse_info::binary(14u8, 13u8)),
10041            "=!=" => Some($parse_info::binary(36u8, 35u8)),
10042            "==" => Some($parse_info::binary(36u8, 35u8)),
10043            "===" => Some($parse_info::binary(36u8, 35u8)),
10044            "===>" => Some($parse_info::binary(22u8, 21u8)),
10045            "===>=" => Some($parse_info::binary(14u8, 13u8)),
10046            "==>" => Some($parse_info::binary(26u8, 25u8)),
10047            "==>=" => Some($parse_info::binary(14u8, 13u8)),
10048            "=>" => Some($parse_info::binary(14u8, 13u8)),
10049            ">" => Some($parse_info::prefix_binary(36u8, 35u8, 36u8)),
10050            ">=" => Some($parse_info::prefix_binary(36u8, 35u8, 36u8)),
10051            ">>" => Some($parse_info::binary(14u8, 13u8)),
10052            ">>=" => Some($parse_info::binary(14u8, 13u8)),
10053            "?" => Some($parse_info::prefix_binary(36u8, 35u8, 36u8)),
10054            "??" => Some($parse_info::prefix_binary(28u8, 27u8, 28u8)),
10055            "??=" => Some($parse_info::binary(14u8, 13u8)),
10056            "@" => Some($parse_info::binary(60u8, 59u8)),
10057            "@=" => Some($parse_info::binary(14u8, 13u8)),
10058            "@@" => Some($parse_info::binary(66u8, 66u8)),
10059            "@@=" => Some($parse_info::binary(14u8, 13u8)),
10060            "@@?" => Some($parse_info::binary(66u8, 66u8)),
10061            "@@?=" => Some($parse_info::binary(14u8, 13u8)),
10062            "\\" => Some($parse_info::binary(58u8, 57u8)),
10063            "\\=" => Some($parse_info::binary(14u8, 13u8)),
10064            "\\\\" => Some($parse_info::binary(58u8, 57u8)),
10065            "\\\\=" => Some($parse_info::binary(14u8, 13u8)),
10066            "^" => Some($parse_info::binary(70u8, 70u8)),
10067            "^=" => Some($parse_info::binary(14u8, 13u8)),
10068            "^**" => Some($parse_info::binary(70u8, 70u8)),
10069            "^**=" => Some($parse_info::binary(14u8, 13u8)),
10070            "^<" => Some($parse_info::binary(70u8, 70u8)),
10071            "^<=" => Some($parse_info::binary(70u8, 70u8)),
10072            "^>" => Some($parse_info::binary(70u8, 70u8)),
10073            "^>=" => Some($parse_info::binary(70u8, 70u8)),
10074            "^^" => Some($parse_info::binary(44u8, 44u8)),
10075            "^^=" => Some($parse_info::binary(14u8, 13u8)),
10076            "_" => Some($parse_info::binary(70u8, 70u8)),
10077            "_=" => Some($parse_info::binary(14u8, 13u8)),
10078            "_<" => Some($parse_info::binary(70u8, 70u8)),
10079            "_<=" => Some($parse_info::binary(70u8, 70u8)),
10080            "_>" => Some($parse_info::binary(70u8, 70u8)),
10081            "_>=" => Some($parse_info::binary(70u8, 70u8)),
10082            "|" => Some($parse_info::binary(42u8, 42u8)),
10083            "|=" => Some($parse_info::binary(14u8, 13u8)),
10084            "|-" => Some($parse_info::prefix_binary(20u8, 20u8, 20u8)),
10085            "|-=" => Some($parse_info::binary(14u8, 13u8)),
10086            "|_" => Some($parse_info::binary(70u8, 70u8)),
10087            "|_=" => Some($parse_info::binary(14u8, 13u8)),
10088            "||" => Some($parse_info::binary(38u8, 38u8)),
10089            "||=" => Some($parse_info::binary(14u8, 13u8)),
10090            "~" => Some($parse_info::prefix_binary(36u8, 35u8, 36u8)),
10091            "~=" => Some($parse_info::binary(14u8, 13u8)),
10092            "·" => Some($parse_info::binary(52u8, 52u8)),
10093            "·=" => Some($parse_info::binary(14u8, 13u8)),
10094            "⊠" => Some($parse_info::binary(54u8, 54u8)),
10095            "⊠=" => Some($parse_info::binary(14u8, 13u8)),
10096            "⧢" => Some($parse_info::binary(54u8, 54u8)),
10097            "⧢=" => Some($parse_info::binary(14u8, 13u8)),
10098            "and" => Some($parse_info::binary(32u8, 31u8)),
10099            "or" => Some($parse_info::binary(28u8, 27u8)),
10100            "SPACE" => Some($parse_info::binary(62u8, 61u8)),
10101            "xor" => Some($parse_info::binary(30u8, 29u8)),
10102            "!" => Some($parse_info::postfix(72u8)),
10103            "(*)" => Some($parse_info::postfix(64u8)),
10104            "^!" => Some($parse_info::postfix(72u8)),
10105            "^*" => Some($parse_info::postfix(68u8)),
10106            "^~" => Some($parse_info::postfix(68u8)),
10107            "_!" => Some($parse_info::postfix(72u8)),
10108            "_*" => Some($parse_info::postfix(68u8)),
10109            "_~" => Some($parse_info::postfix(68u8)),
10110            "not" => Some($parse_info::prefix(34u8, 34u8)),
10111            _ => None,
10112        }
10113    };
10114}
m2_syn/gen/tokens.rs

m2_syn/gen/
tokens.rs
