import PyramidParsing

public struct ExprGrammarSymbols {
    public static let `accentedSymbol` : SymbolId = 0
    public static let `any` : SymbolId = 1
    public static let `arrow` : SymbolId = 2
    public static let `assignSyntax` : SymbolId = 3
    public static let `atomic` : SymbolId = 4
    public static let `aux` : SymbolId = 5
    public static let `backarrow` : SymbolId = 6
    public static let `comment` : SymbolId = 7
    public static let `decchar` : SymbolId = 8
    public static let `dots` : SymbolId = 9
    public static let `empty` : SymbolId = 10
    public static let `equal` : SymbolId = 11
    public static let `greater` : SymbolId = 12
    public static let `greaterOrEqual` : SymbolId = 13
    public static let `hexchar` : SymbolId = 14
    public static let `keyword` : SymbolId = 15
    public static let `layout` : SymbolId = 16
    public static let `literal` : SymbolId = 17
    public static let `nested` : SymbolId = 18
    public static let `newline` : SymbolId = 19
    public static let `op` : SymbolId = 20
    public static let `peg` : SymbolId = 21
    public static let `permeable` : SymbolId = 22
    public static let `space` : SymbolId = 23
    public static let `symbol` : SymbolId = 24
    public static let `syntax` : SymbolId = 25
    public static let `unrelated` : SymbolId = 26
    public static let `Abs` : SymbolId = 27
    public static let `And` : SymbolId = 28
    public static let `AtomicDecl` : SymbolId = 29
    public static let `AtomicExpr` : SymbolId = 30
    public static let `AuxDecl` : SymbolId = 31
    public static let `Complement` : SymbolId = 32
    public static let `DefaultDecl` : SymbolId = 33
    public static let `Diff` : SymbolId = 34
    public static let `Expr` : SymbolId = 35
    public static let `ExprGrammar` : SymbolId = 36
    public static let `ExpressionDecl` : SymbolId = 37
    public static let `ExpressionDef` : SymbolId = 38
    public static let `ExpressionDefInGroup` : SymbolId = 39
    public static let `ExpressionDefs` : SymbolId = 40
    public static let `ExpressionGroup` : SymbolId = 41
    public static let `Front` : SymbolId = 42
    public static let `GroupSymbol` : SymbolId = 43
    public static let `LongestMatch` : SymbolId = 44
    public static let `Modifier` : SymbolId = 45
    public static let `Modifiers` : SymbolId = 46
    public static let `NestedDecl` : SymbolId = 47
    public static let `NonterminalDecl` : SymbolId = 48
    public static let `Not` : SymbolId = 49
    public static let `Opt` : SymbolId = 50
    public static let `OptGreedy` : SymbolId = 51
    public static let `Or` : SymbolId = 52
    public static let `OrGreedy` : SymbolId = 53
    public static let `PriorityDecl` : SymbolId = 54
    public static let `Range` : SymbolId = 55
    public static let `Related` : SymbolId = 56
    public static let `Relation` : SymbolId = 57
    public static let `Rep` : SymbolId = 58
    public static let `Rep1` : SymbolId = 59
    public static let `Rep1Greedy` : SymbolId = 60
    public static let `RepGreedy` : SymbolId = 61
    public static let `RuleDecl` : SymbolId = 62
    public static let `Seq` : SymbolId = 63
    public static let `SymbolAlts` : SymbolId = 64
    public static let `SymbolList` : SymbolId = 65
    public static let `SyntaxDecl` : SymbolId = 66
    public static let `SyntaxTreatAs` : SymbolId = 67
    public static let `TerminalDecl` : SymbolId = 68
    public static let `TreatAsDecl` : SymbolId = 69
}

public struct ExprGrammarSyntax {

    public final class `Abs` : DefaultAbstractSyntaxTree {
        public let `expr` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Abs else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `And` : DefaultAbstractSyntaxTree {
        public let `expr` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.And else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `AtomicDecl` : DefaultAbstractSyntaxTree {
        public let `atomic` : `Atomic`
        public let `symbolList` : `SymbolList`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.AtomicDecl else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Atomic`.of(tree[i]) { self.`atomic` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `SymbolList`.of(tree[i]) { self.`symbolList` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `AtomicExpr` : DefaultAbstractSyntaxTree {
        public enum Cases {
            case `accentedSymbol`(`AccentedSymbol`)
            case `symbol`(`Symbol`)
            case `expr`(`Expr`)
            public static func of(_ tree : AbstractSyntaxTree) -> Self?{
                switch tree.symbolId {
                    case ExprGrammarSymbols.accentedSymbol:
                        if let x = `AccentedSymbol`.of(tree) {
                            return .`accentedSymbol`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.symbol:
                        if let x = `Symbol`.of(tree) {
                            return .`symbol`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Expr:
                        if let x = `Expr`.of(tree) {
                            return .`expr`(x)
                        } else { return nil }
                    default: return nil
                }
            }
        }

        public let `cases` : Cases

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.AtomicExpr else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = Cases.of(tree[i]) { self.`cases` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `AuxDecl` : DefaultAbstractSyntaxTree {
        public let `aux` : `Aux`
        public let `symbolList` : `SymbolList`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.AuxDecl else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Aux`.of(tree[i]) { self.`aux` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `SymbolList`.of(tree[i]) { self.`symbolList` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `Complement` : DefaultAbstractSyntaxTree {
        public let `expr` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Complement else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `DefaultDecl` : DefaultAbstractSyntaxTree {
        public let `relation` : `Relation`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.DefaultDecl else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Relation`.of(tree[i]) { self.`relation` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `Diff` : DefaultAbstractSyntaxTree {
        public let `expr1` : `Expr`
        public let `expr2` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Diff else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr1` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr2` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `Expr` : DefaultAbstractSyntaxTree {
        public enum Cases {
            case `any`(`Any`)
            case `decchar`(`Decchar`)
            case `empty`(`Empty`)
            case `hexchar`(`Hexchar`)
            case `literal`(`Literal`)
            case `newline`(`Newline`)
            case `space`(`Space`)
            case `abs`(`Abs`)
            case `and`(`And`)
            case `atomicExpr`(`AtomicExpr`)
            case `complement`(`Complement`)
            case `diff`(`Diff`)
            case `expr`(`Expr`)
            case `front`(`Front`)
            case `not`(`Not`)
            case `opt`(`Opt`)
            case `optGreedy`(`OptGreedy`)
            case `or`(`Or`)
            case `orGreedy`(`OrGreedy`)
            case `range`(`Range`)
            case `related`(`Related`)
            case `rep`(`Rep`)
            case `rep1`(`Rep1`)
            case `rep1Greedy`(`Rep1Greedy`)
            case `repGreedy`(`RepGreedy`)
            case `seq`(`Seq`)
            case `syntaxTreatAs`(`SyntaxTreatAs`)
            public static func of(_ tree : AbstractSyntaxTree) -> Self?{
                switch tree.symbolId {
                    case ExprGrammarSymbols.any:
                        if let x = `Any`.of(tree) {
                            return .`any`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.decchar:
                        if let x = `Decchar`.of(tree) {
                            return .`decchar`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.empty:
                        if let x = `Empty`.of(tree) {
                            return .`empty`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.hexchar:
                        if let x = `Hexchar`.of(tree) {
                            return .`hexchar`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.literal:
                        if let x = `Literal`.of(tree) {
                            return .`literal`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.newline:
                        if let x = `Newline`.of(tree) {
                            return .`newline`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.space:
                        if let x = `Space`.of(tree) {
                            return .`space`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Abs:
                        if let x = `Abs`.of(tree) {
                            return .`abs`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.And:
                        if let x = `And`.of(tree) {
                            return .`and`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.AtomicExpr:
                        if let x = `AtomicExpr`.of(tree) {
                            return .`atomicExpr`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Complement:
                        if let x = `Complement`.of(tree) {
                            return .`complement`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Diff:
                        if let x = `Diff`.of(tree) {
                            return .`diff`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Expr:
                        if let x = `Expr`.of(tree) {
                            return .`expr`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Front:
                        if let x = `Front`.of(tree) {
                            return .`front`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Not:
                        if let x = `Not`.of(tree) {
                            return .`not`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Opt:
                        if let x = `Opt`.of(tree) {
                            return .`opt`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.OptGreedy:
                        if let x = `OptGreedy`.of(tree) {
                            return .`optGreedy`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Or:
                        if let x = `Or`.of(tree) {
                            return .`or`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.OrGreedy:
                        if let x = `OrGreedy`.of(tree) {
                            return .`orGreedy`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Range:
                        if let x = `Range`.of(tree) {
                            return .`range`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Related:
                        if let x = `Related`.of(tree) {
                            return .`related`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Rep:
                        if let x = `Rep`.of(tree) {
                            return .`rep`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Rep1:
                        if let x = `Rep1`.of(tree) {
                            return .`rep1`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Rep1Greedy:
                        if let x = `Rep1Greedy`.of(tree) {
                            return .`rep1Greedy`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.RepGreedy:
                        if let x = `RepGreedy`.of(tree) {
                            return .`repGreedy`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Seq:
                        if let x = `Seq`.of(tree) {
                            return .`seq`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.SyntaxTreatAs:
                        if let x = `SyntaxTreatAs`.of(tree) {
                            return .`syntaxTreatAs`(x)
                        } else { return nil }
                    default: return nil
                }
            }
        }

        public let `cases` : Cases

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Expr else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = Cases.of(tree[i]) { self.`cases` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `ExprGrammar` : DefaultAbstractSyntaxTree {
        public enum Cases {
            case `atomicDecl`(`AtomicDecl`)
            case `auxDecl`(`AuxDecl`)
            case `defaultDecl`(`DefaultDecl`)
            case `expressionDecl`(`ExpressionDecl`)
            case `nestedDecl`(`NestedDecl`)
            case `nonterminalDecl`(`NonterminalDecl`)
            case `priorityDecl`(`PriorityDecl`)
            case `ruleDecl`(`RuleDecl`)
            case `syntaxDecl`(`SyntaxDecl`)
            case `terminalDecl`(`TerminalDecl`)
            case `treatAsDecl`(`TreatAsDecl`)
            public static func of(_ tree : AbstractSyntaxTree) -> Self?{
                switch tree.symbolId {
                    case ExprGrammarSymbols.AtomicDecl:
                        if let x = `AtomicDecl`.of(tree) {
                            return .`atomicDecl`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.AuxDecl:
                        if let x = `AuxDecl`.of(tree) {
                            return .`auxDecl`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.DefaultDecl:
                        if let x = `DefaultDecl`.of(tree) {
                            return .`defaultDecl`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.ExpressionDecl:
                        if let x = `ExpressionDecl`.of(tree) {
                            return .`expressionDecl`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.NestedDecl:
                        if let x = `NestedDecl`.of(tree) {
                            return .`nestedDecl`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.NonterminalDecl:
                        if let x = `NonterminalDecl`.of(tree) {
                            return .`nonterminalDecl`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.PriorityDecl:
                        if let x = `PriorityDecl`.of(tree) {
                            return .`priorityDecl`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.RuleDecl:
                        if let x = `RuleDecl`.of(tree) {
                            return .`ruleDecl`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.SyntaxDecl:
                        if let x = `SyntaxDecl`.of(tree) {
                            return .`syntaxDecl`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.TerminalDecl:
                        if let x = `TerminalDecl`.of(tree) {
                            return .`terminalDecl`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.TreatAsDecl:
                        if let x = `TreatAsDecl`.of(tree) {
                            return .`treatAsDecl`(x)
                        } else { return nil }
                    default: return nil
                }
            }
        }

        public let `cases` : [Cases]

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.ExprGrammar else { return nil }
            var i = 0
            let I = tree.countChildren
            do {
                var xs : [Cases] = []
                while i < I, let x = Cases.of(tree[i]) {
                    xs.append(x)
                    i += 1
                }
                self.`cases` = xs
            }
            super.init(tree)
        }
    }

    public final class `ExpressionDecl` : DefaultAbstractSyntaxTree {
        public enum Cases {
            case `expressionDef`(`ExpressionDef`)
            case `expressionGroup`(`ExpressionGroup`)
            public static func of(_ tree : AbstractSyntaxTree) -> Self?{
                switch tree.symbolId {
                    case ExprGrammarSymbols.ExpressionDef:
                        if let x = `ExpressionDef`.of(tree) {
                            return .`expressionDef`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.ExpressionGroup:
                        if let x = `ExpressionGroup`.of(tree) {
                            return .`expressionGroup`(x)
                        } else { return nil }
                    default: return nil
                }
            }
        }

        public let `symbol` : `Symbol`
        public let `cases` : [Cases]

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.ExpressionDecl else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Symbol`.of(tree[i]) { self.`symbol` = x } else { return nil }
            i += 1
            do {
                var xs : [Cases] = []
                while i < I, let x = Cases.of(tree[i]) {
                    xs.append(x)
                    i += 1
                }
                self.`cases` = xs
            }
            super.init(tree)
        }
    }

    public final class `ExpressionDef` : DefaultAbstractSyntaxTree {
        public let `groupSymbol` : `GroupSymbol`
        public let `expr` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.ExpressionDef else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `GroupSymbol`.of(tree[i]) { self.`groupSymbol` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `ExpressionDefInGroup` : DefaultAbstractSyntaxTree {
        public let `symbol` : `Symbol`?
        public let `expr` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.ExpressionDefInGroup else { return nil }
            var i = 0
            let I = tree.countChildren
            if i < I, let x = `Symbol`.of(tree[i]) {
                self.`symbol` = x
                i += 1
            } else {
                self.`symbol` = nil
            }
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `ExpressionDefs` : DefaultAbstractSyntaxTree {
        public let `expressionDefInGroups` : [`ExpressionDefInGroup`]

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.ExpressionDefs else { return nil }
            var i = 0
            let I = tree.countChildren
            do {
                var xs : [`ExpressionDefInGroup`] = []
                while i < I, let x = `ExpressionDefInGroup`.of(tree[i]) {
                    xs.append(x)
                    i += 1
                }
                self.`expressionDefInGroups` = xs
            }
            super.init(tree)
        }
    }

    public final class `ExpressionGroup` : DefaultAbstractSyntaxTree {
        public let `groupSymbol` : `GroupSymbol`
        public let `expressionDefs` : `ExpressionDefs`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.ExpressionGroup else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `GroupSymbol`.of(tree[i]) { self.`groupSymbol` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `ExpressionDefs`.of(tree[i]) { self.`expressionDefs` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `Front` : DefaultAbstractSyntaxTree {
        public let `expr` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Front else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `GroupSymbol` : DefaultAbstractSyntaxTree {
        public let `symbol` : `Symbol`?
        public let `permeable` : `Permeable`?

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.GroupSymbol else { return nil }
            var i = 0
            let I = tree.countChildren
            if i < I, let x = `Symbol`.of(tree[i]) {
                self.`symbol` = x
                i += 1
            } else {
                self.`symbol` = nil
            }
            if i < I, let x = `Permeable`.of(tree[i]) {
                self.`permeable` = x
                i += 1
            } else {
                self.`permeable` = nil
            }
            super.init(tree)
        }
    }

    public final class `LongestMatch` : DefaultAbstractSyntaxTree {
        public let `symbols` : [`Symbol`]

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.LongestMatch else { return nil }
            var i = 0
            let I = tree.countChildren
            do {
                var xs : [`Symbol`] = []
                while i < I, let x = `Symbol`.of(tree[i]) {
                    xs.append(x)
                    i += 1
                }
                self.`symbols` = xs
            }
            super.init(tree)
        }
    }

    public final class `Modifier` : DefaultAbstractSyntaxTree {
        public enum Cases {
            case `atomic`(`Atomic`)
            case `aux`(`Aux`)
            case `nested`(`Nested`)
            case `syntax`(`Syntax`)
            case `relation`(`Relation`)
            public static func of(_ tree : AbstractSyntaxTree) -> Self?{
                switch tree.symbolId {
                    case ExprGrammarSymbols.atomic:
                        if let x = `Atomic`.of(tree) {
                            return .`atomic`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.aux:
                        if let x = `Aux`.of(tree) {
                            return .`aux`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.nested:
                        if let x = `Nested`.of(tree) {
                            return .`nested`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.syntax:
                        if let x = `Syntax`.of(tree) {
                            return .`syntax`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.Relation:
                        if let x = `Relation`.of(tree) {
                            return .`relation`(x)
                        } else { return nil }
                    default: return nil
                }
            }
        }

        public let `cases` : Cases

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Modifier else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = Cases.of(tree[i]) { self.`cases` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `Modifiers` : DefaultAbstractSyntaxTree {
        public let `modifiers` : [`Modifier`]

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Modifiers else { return nil }
            var i = 0
            let I = tree.countChildren
            do {
                var xs : [`Modifier`] = []
                while i < I, let x = `Modifier`.of(tree[i]) {
                    xs.append(x)
                    i += 1
                }
                self.`modifiers` = xs
            }
            super.init(tree)
        }
    }

    public final class `NestedDecl` : DefaultAbstractSyntaxTree {
        public let `nested` : `Nested`
        public let `symbolList` : `SymbolList`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.NestedDecl else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Nested`.of(tree[i]) { self.`nested` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `SymbolList`.of(tree[i]) { self.`symbolList` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `NonterminalDecl` : DefaultAbstractSyntaxTree {
        public let `modifiers` : `Modifiers`
        public let `symbolList` : `SymbolList`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.NonterminalDecl else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Modifiers`.of(tree[i]) { self.`modifiers` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `SymbolList`.of(tree[i]) { self.`symbolList` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `Not` : DefaultAbstractSyntaxTree {
        public let `expr` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Not else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `Opt` : DefaultAbstractSyntaxTree {
        public let `expr` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Opt else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `OptGreedy` : DefaultAbstractSyntaxTree {
        public let `expr` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.OptGreedy else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `Or` : DefaultAbstractSyntaxTree {
        public let `expr1` : `Expr`
        public let `expr2` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Or else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr1` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr2` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `OrGreedy` : DefaultAbstractSyntaxTree {
        public let `expr1` : `Expr`
        public let `expr2` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.OrGreedy else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr1` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr2` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `PriorityDecl` : DefaultAbstractSyntaxTree {
        public let `longestMatchs` : [`LongestMatch`]

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.PriorityDecl else { return nil }
            var i = 0
            let I = tree.countChildren
            do {
                var xs : [`LongestMatch`] = []
                while i < I, let x = `LongestMatch`.of(tree[i]) {
                    xs.append(x)
                    i += 1
                }
                self.`longestMatchs` = xs
            }
            super.init(tree)
        }
    }

    public final class `Range` : DefaultAbstractSyntaxTree {
        public let `expr1` : `Expr`
        public let `expr2` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Range else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr1` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr2` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `Related` : DefaultAbstractSyntaxTree {
        public let `expr` : `Expr`
        public let `relation` : `Relation`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Related else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `Relation`.of(tree[i]) { self.`relation` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `Relation` : DefaultAbstractSyntaxTree {
        public enum Cases {
            case `equal`(`Equal`)
            case `greater`(`Greater`)
            case `greaterOrEqual`(`GreaterOrEqual`)
            case `unrelated`(`Unrelated`)
            public static func of(_ tree : AbstractSyntaxTree) -> Self?{
                switch tree.symbolId {
                    case ExprGrammarSymbols.equal:
                        if let x = `Equal`.of(tree) {
                            return .`equal`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.greater:
                        if let x = `Greater`.of(tree) {
                            return .`greater`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.greaterOrEqual:
                        if let x = `GreaterOrEqual`.of(tree) {
                            return .`greaterOrEqual`(x)
                        } else { return nil }
                    case ExprGrammarSymbols.unrelated:
                        if let x = `Unrelated`.of(tree) {
                            return .`unrelated`(x)
                        } else { return nil }
                    default: return nil
                }
            }
        }

        public let `cases` : Cases

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Relation else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = Cases.of(tree[i]) { self.`cases` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `Rep` : DefaultAbstractSyntaxTree {
        public let `expr` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Rep else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `Rep1` : DefaultAbstractSyntaxTree {
        public let `expr` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Rep1 else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `Rep1Greedy` : DefaultAbstractSyntaxTree {
        public let `expr` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Rep1Greedy else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `RepGreedy` : DefaultAbstractSyntaxTree {
        public let `expr` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.RepGreedy else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `RuleDecl` : DefaultAbstractSyntaxTree {
        public let `symbol` : `Symbol`
        public let `expr` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.RuleDecl else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Symbol`.of(tree[i]) { self.`symbol` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `Seq` : DefaultAbstractSyntaxTree {
        public let `exprs` : [`Expr`]

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.Seq else { return nil }
            var i = 0
            let I = tree.countChildren
            do {
                var xs : [`Expr`] = []
                while i < I, let x = `Expr`.of(tree[i]) {
                    xs.append(x)
                    i += 1
                }
                self.`exprs` = xs
            }
            super.init(tree)
        }
    }

    public final class `SymbolAlts` : DefaultAbstractSyntaxTree {
        public let `symbols` : [`Symbol`]

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.SymbolAlts else { return nil }
            var i = 0
            let I = tree.countChildren
            do {
                var xs : [`Symbol`] = []
                while i < I, let x = `Symbol`.of(tree[i]) {
                    xs.append(x)
                    i += 1
                }
                self.`symbols` = xs
            }
            super.init(tree)
        }
    }

    public final class `SymbolList` : DefaultAbstractSyntaxTree {
        public let `symbols` : [`Symbol`]

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.SymbolList else { return nil }
            var i = 0
            let I = tree.countChildren
            do {
                var xs : [`Symbol`] = []
                while i < I, let x = `Symbol`.of(tree[i]) {
                    xs.append(x)
                    i += 1
                }
                self.`symbols` = xs
            }
            super.init(tree)
        }
    }

    public final class `SyntaxDecl` : DefaultAbstractSyntaxTree {
        public let `syntax` : `Syntax`
        public let `symbolList` : `SymbolList`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.SyntaxDecl else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Syntax`.of(tree[i]) { self.`syntax` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `SymbolList`.of(tree[i]) { self.`symbolList` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `SyntaxTreatAs` : DefaultAbstractSyntaxTree {
        public let `symbol` : `Symbol`
        public let `expr` : `Expr`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.SyntaxTreatAs else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Symbol`.of(tree[i]) { self.`symbol` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `Expr`.of(tree[i]) { self.`expr` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `TerminalDecl` : DefaultAbstractSyntaxTree {
        public let `modifiers` : `Modifiers`
        public let `symbolList` : `SymbolList`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.TerminalDecl else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Modifiers`.of(tree[i]) { self.`modifiers` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `SymbolList`.of(tree[i]) { self.`symbolList` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `TreatAsDecl` : DefaultAbstractSyntaxTree {
        public let `symbol` : `Symbol`
        public let `symbolAlts` : `SymbolAlts`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.TreatAsDecl else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Symbol`.of(tree[i]) { self.`symbol` = x } else { return nil }
            i += 1
            guard i < I else { return nil }
            if let x = `SymbolAlts`.of(tree[i]) { self.`symbolAlts` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `AccentedSymbol` : DefaultAbstractSyntaxTree {
        public let `symbol` : `Symbol`

        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.accentedSymbol else { return nil }
            var i = 0
            let I = tree.countChildren
            guard i < I else { return nil }
            if let x = `Symbol`.of(tree[i]) { self.`symbol` = x } else { return nil }
            i += 1
            super.init(tree)
        }
    }

    public final class `Any` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.any else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `Atomic` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.atomic else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `Aux` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.aux else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `Decchar` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.decchar else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `Empty` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.empty else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `Equal` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.equal else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `Greater` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.greater else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `GreaterOrEqual` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.greaterOrEqual else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `Hexchar` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.hexchar else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `Literal` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.literal else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `Nested` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.nested else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `Newline` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.newline else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `Permeable` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.permeable else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `Space` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.space else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `Symbol` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.symbol else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `Syntax` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.syntax else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

    public final class `Unrelated` : DefaultAbstractSyntaxTree {
        public required init?(_ tree : AbstractSyntaxTree) {
            guard tree.symbolId == ExprGrammarSymbols.unrelated else { return nil }
            guard tree.countChildren == 0 else { return nil }
            super.init(tree)
        }
    }

}