namespace Parser
{
    public class FileSyntaxNode : SyntaxNode
    {
        private SyntaxNode _statementList;

        internal FileSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken EndOfFile
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FileSyntaxNode)_green)._endOfFile, this.GetChildPosition(1)); }
        }

        public SyntaxNodeOrTokenList StatementList
        {
            get
            {
                var red = this.GetRed(ref this._statementList, 0);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _statementList, 0);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitFile(this);
        }

    }

    public class FunctionDeclarationSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode _outputDescription;
        private SyntaxNode _inputDescription;
        private SyntaxNode _commas;
        private SyntaxNode _body;

        internal FunctionDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken FunctionKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FunctionDeclarationSyntaxNode)_green)._functionKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken Name
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FunctionDeclarationSyntaxNode)_green)._name, this.GetChildPosition(2)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FunctionDeclarationSyntaxNode)_green)._endKeyword, this.GetChildPosition(6)); }
        }

        public FunctionOutputDescriptionSyntaxNode OutputDescription
        {
            get
            {
                var red = this.GetRed(ref this._outputDescription, 1);
                if (red != null)
                    return (FunctionOutputDescriptionSyntaxNode)red;

                return default(FunctionOutputDescriptionSyntaxNode);
            }
        }

        public FunctionInputDescriptionSyntaxNode InputDescription
        {
            get
            {
                var red = this.GetRed(ref this._inputDescription, 3);
                if (red != null)
                    return (FunctionInputDescriptionSyntaxNode)red;

                return default(FunctionInputDescriptionSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Commas
        {
            get
            {
                var red = this.GetRed(ref this._commas, 4);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body, 5);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _outputDescription, 1);
                case 3: return GetRed(ref _inputDescription, 3);
                case 4: return GetRed(ref _commas, 4);
                case 5: return GetRed(ref _body, 5);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitFunctionDeclaration(this);
        }

    }

    public class FunctionOutputDescriptionSyntaxNode : SyntaxNode
    {
        private SyntaxNode _outputList;

        internal FunctionOutputDescriptionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken AssignmentSign
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FunctionOutputDescriptionSyntaxNode)_green)._assignmentSign, this.GetChildPosition(1)); }
        }

        public SyntaxNodeOrTokenList OutputList
        {
            get
            {
                var red = this.GetRed(ref this._outputList, 0);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _outputList, 0);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitFunctionOutputDescription(this);
        }

    }

    public class FunctionInputDescriptionSyntaxNode : SyntaxNode
    {
        private SyntaxNode _parameterList;

        internal FunctionInputDescriptionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FunctionInputDescriptionSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); }
        }

        public SyntaxToken ClosingBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FunctionInputDescriptionSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); }
        }

        public SyntaxNodeOrTokenList ParameterList
        {
            get
            {
                var red = this.GetRed(ref this._parameterList, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _parameterList, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitFunctionInputDescription(this);
        }

    }

    public class SwitchStatementSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode _switchExpression;
        private SyntaxNode _optionalCommas;
        private SyntaxNode _cases;

        internal SwitchStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken SwitchKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.SwitchStatementSyntaxNode)_green)._switchKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.SwitchStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(4)); }
        }

        public ExpressionSyntaxNode SwitchExpression
        {
            get
            {
                var red = this.GetRed(ref this._switchExpression, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList OptionalCommas
        {
            get
            {
                var red = this.GetRed(ref this._optionalCommas, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        public SyntaxNodeOrTokenList Cases
        {
            get
            {
                var red = this.GetRed(ref this._cases, 3);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _switchExpression, 1);
                case 2: return GetRed(ref _optionalCommas, 2);
                case 3: return GetRed(ref _cases, 3);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitSwitchStatement(this);
        }

    }

    public class SwitchCaseSyntaxNode : SyntaxNode
    {
        private SyntaxNode _caseIdentifier;
        private SyntaxNode _optionalCommas;
        private SyntaxNode _body;

        internal SwitchCaseSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken CaseKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.SwitchCaseSyntaxNode)_green)._caseKeyword, this.GetChildPosition(0)); }
        }

        public ExpressionSyntaxNode CaseIdentifier
        {
            get
            {
                var red = this.GetRed(ref this._caseIdentifier, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList OptionalCommas
        {
            get
            {
                var red = this.GetRed(ref this._optionalCommas, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body, 3);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _caseIdentifier, 1);
                case 2: return GetRed(ref _optionalCommas, 2);
                case 3: return GetRed(ref _body, 3);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitSwitchCase(this);
        }

    }

    public class WhileStatementSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode _condition;
        private SyntaxNode _optionalCommas;
        private SyntaxNode _body;

        internal WhileStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken WhileKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.WhileStatementSyntaxNode)_green)._whileKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.WhileStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(4)); }
        }

        public ExpressionSyntaxNode Condition
        {
            get
            {
                var red = this.GetRed(ref this._condition, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList OptionalCommas
        {
            get
            {
                var red = this.GetRed(ref this._optionalCommas, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body, 3);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _condition, 1);
                case 2: return GetRed(ref _optionalCommas, 2);
                case 3: return GetRed(ref _body, 3);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitWhileStatement(this);
        }

    }

    public class ElseifClause : SyntaxNode
    {
        private SyntaxNode _condition;
        private SyntaxNode _optionalCommas;
        private SyntaxNode _body;

        internal ElseifClause(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken ElseifKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ElseifClause)_green)._elseifKeyword, this.GetChildPosition(0)); }
        }

        public ExpressionSyntaxNode Condition
        {
            get
            {
                var red = this.GetRed(ref this._condition, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList OptionalCommas
        {
            get
            {
                var red = this.GetRed(ref this._optionalCommas, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body, 3);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _condition, 1);
                case 2: return GetRed(ref _optionalCommas, 2);
                case 3: return GetRed(ref _body, 3);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitElseifClause(this);
        }

    }

    public class ElseClause : SyntaxNode
    {
        private SyntaxNode _body;

        internal ElseClause(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken ElseKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ElseClause)_green)._elseKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _body, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitElseClause(this);
        }

    }

    public class IfStatementSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode _condition;
        private SyntaxNode _optionalCommas;
        private SyntaxNode _body;
        private SyntaxNode _elseifClauses;
        private SyntaxNode _elseClause;

        internal IfStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken IfKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.IfStatementSyntaxNode)_green)._ifKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.IfStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(6)); }
        }

        public ExpressionSyntaxNode Condition
        {
            get
            {
                var red = this.GetRed(ref this._condition, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList OptionalCommas
        {
            get
            {
                var red = this.GetRed(ref this._optionalCommas, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body, 3);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        public SyntaxNodeOrTokenList ElseifClauses
        {
            get
            {
                var red = this.GetRed(ref this._elseifClauses, 4);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        public ElseClause ElseClause
        {
            get
            {
                var red = this.GetRed(ref this._elseClause, 5);
                if (red != null)
                    return (ElseClause)red;

                return default(ElseClause);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _condition, 1);
                case 2: return GetRed(ref _optionalCommas, 2);
                case 3: return GetRed(ref _body, 3);
                case 4: return GetRed(ref _elseifClauses, 4);
                case 5: return GetRed(ref _elseClause, 5);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitIfStatement(this);
        }

    }

    public class ForStatementSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode _assignment;
        private SyntaxNode _optionalCommas;
        private SyntaxNode _body;

        internal ForStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken ForKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ForStatementSyntaxNode)_green)._forKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ForStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(4)); }
        }

        public AssignmentExpressionSyntaxNode Assignment
        {
            get
            {
                var red = this.GetRed(ref this._assignment, 1);
                if (red != null)
                    return (AssignmentExpressionSyntaxNode)red;

                return default(AssignmentExpressionSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList OptionalCommas
        {
            get
            {
                var red = this.GetRed(ref this._optionalCommas, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body, 3);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _assignment, 1);
                case 2: return GetRed(ref _optionalCommas, 2);
                case 3: return GetRed(ref _body, 3);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitForStatement(this);
        }

    }

    public class AssignmentExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode _lhs;
        private SyntaxNode _rhs;

        internal AssignmentExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken AssignmentSign
        {
            get { return new SyntaxToken(this, ((Parser.Internal.AssignmentExpressionSyntaxNode)_green)._assignmentSign, this.GetChildPosition(1)); }
        }

        public ExpressionSyntaxNode Lhs
        {
            get
            {
                var red = this.GetRed(ref this._lhs, 0);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        public ExpressionSyntaxNode Rhs
        {
            get
            {
                var red = this.GetRed(ref this._rhs, 2);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _lhs, 0);
                case 2: return GetRed(ref _rhs, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitAssignmentExpression(this);
        }

    }

    public class CatchClauseSyntaxNode : SyntaxNode
    {
        private SyntaxNode _catchBody;

        internal CatchClauseSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken CatchKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.CatchClauseSyntaxNode)_green)._catchKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxNodeOrTokenList CatchBody
        {
            get
            {
                var red = this.GetRed(ref this._catchBody, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _catchBody, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitCatchClause(this);
        }

    }

    public class TryCatchStatementSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode _tryBody;
        private SyntaxNode _catchClause;

        internal TryCatchStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken TryKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.TryCatchStatementSyntaxNode)_green)._tryKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.TryCatchStatementSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); }
        }

        public SyntaxNodeOrTokenList TryBody
        {
            get
            {
                var red = this.GetRed(ref this._tryBody, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        public CatchClauseSyntaxNode CatchClause
        {
            get
            {
                var red = this.GetRed(ref this._catchClause, 2);
                if (red != null)
                    return (CatchClauseSyntaxNode)red;

                return default(CatchClauseSyntaxNode);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _tryBody, 1);
                case 2: return GetRed(ref _catchClause, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitTryCatchStatement(this);
        }

    }

    public class ExpressionStatementSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode _expression;

        internal ExpressionStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }


        public ExpressionSyntaxNode Expression
        {
            get
            {
                var red = this.GetRed(ref this._expression, 0);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _expression, 0);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitExpressionStatement(this);
        }

    }

    public class EmptyStatementSyntaxNode : StatementSyntaxNode
    {

        internal EmptyStatementSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken Semicolon
        {
            get { return new SyntaxToken(this, ((Parser.Internal.EmptyStatementSyntaxNode)_green)._semicolon, this.GetChildPosition(0)); }
        }


        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitEmptyStatement(this);
        }

    }

    public class EmptyExpressionSyntaxNode : ExpressionSyntaxNode
    {

        internal EmptyExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }



        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitEmptyExpression(this);
        }

    }

    public class UnaryPrefixOperationExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode _operand;

        internal UnaryPrefixOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken Operation
        {
            get { return new SyntaxToken(this, ((Parser.Internal.UnaryPrefixOperationExpressionSyntaxNode)_green)._operation, this.GetChildPosition(0)); }
        }

        public ExpressionSyntaxNode Operand
        {
            get
            {
                var red = this.GetRed(ref this._operand, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _operand, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitUnaryPrefixOperationExpression(this);
        }

    }

    public class CompoundNameSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode _nodes;

        internal CompoundNameSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }


        public SyntaxNodeOrTokenList Nodes
        {
            get
            {
                var red = this.GetRed(ref this._nodes, 0);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _nodes, 0);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitCompoundName(this);
        }

    }

    public class NamedFunctionHandleSyntaxNode : FunctionHandleSyntaxNode
    {
        private SyntaxNode _functionName;

        internal NamedFunctionHandleSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken AtSign
        {
            get { return new SyntaxToken(this, ((Parser.Internal.NamedFunctionHandleSyntaxNode)_green)._atSign, this.GetChildPosition(0)); }
        }

        public CompoundNameSyntaxNode FunctionName
        {
            get
            {
                var red = this.GetRed(ref this._functionName, 1);
                if (red != null)
                    return (CompoundNameSyntaxNode)red;

                return default(CompoundNameSyntaxNode);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _functionName, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitNamedFunctionHandle(this);
        }

    }

    public class LambdaSyntaxNode : FunctionHandleSyntaxNode
    {
        private SyntaxNode _input;
        private SyntaxNode _body;

        internal LambdaSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken AtSign
        {
            get { return new SyntaxToken(this, ((Parser.Internal.LambdaSyntaxNode)_green)._atSign, this.GetChildPosition(0)); }
        }

        public FunctionInputDescriptionSyntaxNode Input
        {
            get
            {
                var red = this.GetRed(ref this._input, 1);
                if (red != null)
                    return (FunctionInputDescriptionSyntaxNode)red;

                return default(FunctionInputDescriptionSyntaxNode);
            }
        }

        public ExpressionSyntaxNode Body
        {
            get
            {
                var red = this.GetRed(ref this._body, 2);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _input, 1);
                case 2: return GetRed(ref _body, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitLambda(this);
        }

    }

    public class BinaryOperationExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode _lhs;
        private SyntaxNode _rhs;

        internal BinaryOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken Operation
        {
            get { return new SyntaxToken(this, ((Parser.Internal.BinaryOperationExpressionSyntaxNode)_green)._operation, this.GetChildPosition(1)); }
        }

        public ExpressionSyntaxNode Lhs
        {
            get
            {
                var red = this.GetRed(ref this._lhs, 0);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        public ExpressionSyntaxNode Rhs
        {
            get
            {
                var red = this.GetRed(ref this._rhs, 2);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _lhs, 0);
                case 2: return GetRed(ref _rhs, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitBinaryOperationExpression(this);
        }

    }

    public class IdentifierNameSyntaxNode : ExpressionSyntaxNode
    {

        internal IdentifierNameSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken Name
        {
            get { return new SyntaxToken(this, ((Parser.Internal.IdentifierNameSyntaxNode)_green)._name, this.GetChildPosition(0)); }
        }


        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitIdentifierName(this);
        }

    }

    public class NumberLiteralSyntaxNode : ExpressionSyntaxNode
    {

        internal NumberLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken Number
        {
            get { return new SyntaxToken(this, ((Parser.Internal.NumberLiteralSyntaxNode)_green)._number, this.GetChildPosition(0)); }
        }


        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitNumberLiteral(this);
        }

    }

    public class StringLiteralSyntaxNode : ExpressionSyntaxNode
    {

        internal StringLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken StringToken
        {
            get { return new SyntaxToken(this, ((Parser.Internal.StringLiteralSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); }
        }


        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitStringLiteral(this);
        }

    }

    public class DoubleQuotedStringLiteralSyntaxNode : ExpressionSyntaxNode
    {

        internal DoubleQuotedStringLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken StringToken
        {
            get { return new SyntaxToken(this, ((Parser.Internal.DoubleQuotedStringLiteralSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); }
        }


        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitDoubleQuotedStringLiteral(this);
        }

    }

    public class UnquotedStringLiteralSyntaxNode : ExpressionSyntaxNode
    {

        internal UnquotedStringLiteralSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken StringToken
        {
            get { return new SyntaxToken(this, ((Parser.Internal.UnquotedStringLiteralSyntaxNode)_green)._stringToken, this.GetChildPosition(0)); }
        }


        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitUnquotedStringLiteral(this);
        }

    }

    public class ArrayLiteralExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode _nodes;

        internal ArrayLiteralExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningSquareBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ArrayLiteralExpressionSyntaxNode)_green)._openingSquareBracket, this.GetChildPosition(0)); }
        }

        public SyntaxToken ClosingSquareBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ArrayLiteralExpressionSyntaxNode)_green)._closingSquareBracket, this.GetChildPosition(2)); }
        }

        public SyntaxNodeOrTokenList Nodes
        {
            get
            {
                var red = this.GetRed(ref this._nodes, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _nodes, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitArrayLiteralExpression(this);
        }

    }

    public class CellArrayLiteralExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode _nodes;

        internal CellArrayLiteralExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBrace
        {
            get { return new SyntaxToken(this, ((Parser.Internal.CellArrayLiteralExpressionSyntaxNode)_green)._openingBrace, this.GetChildPosition(0)); }
        }

        public SyntaxToken ClosingBrace
        {
            get { return new SyntaxToken(this, ((Parser.Internal.CellArrayLiteralExpressionSyntaxNode)_green)._closingBrace, this.GetChildPosition(2)); }
        }

        public SyntaxNodeOrTokenList Nodes
        {
            get
            {
                var red = this.GetRed(ref this._nodes, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _nodes, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitCellArrayLiteralExpression(this);
        }

    }

    public class ParenthesizedExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode _expression;

        internal ParenthesizedExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ParenthesizedExpressionSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); }
        }

        public SyntaxToken ClosingBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ParenthesizedExpressionSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); }
        }

        public ExpressionSyntaxNode Expression
        {
            get
            {
                var red = this.GetRed(ref this._expression, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _expression, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitParenthesizedExpression(this);
        }

    }

    public class CellArrayElementAccessExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode _expression;
        private SyntaxNode _nodes;

        internal CellArrayElementAccessExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBrace
        {
            get { return new SyntaxToken(this, ((Parser.Internal.CellArrayElementAccessExpressionSyntaxNode)_green)._openingBrace, this.GetChildPosition(1)); }
        }

        public SyntaxToken ClosingBrace
        {
            get { return new SyntaxToken(this, ((Parser.Internal.CellArrayElementAccessExpressionSyntaxNode)_green)._closingBrace, this.GetChildPosition(3)); }
        }

        public ExpressionSyntaxNode Expression
        {
            get
            {
                var red = this.GetRed(ref this._expression, 0);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Nodes
        {
            get
            {
                var red = this.GetRed(ref this._nodes, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _expression, 0);
                case 2: return GetRed(ref _nodes, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitCellArrayElementAccessExpression(this);
        }

    }

    public class FunctionCallExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode _functionName;
        private SyntaxNode _nodes;

        internal FunctionCallExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FunctionCallExpressionSyntaxNode)_green)._openingBracket, this.GetChildPosition(1)); }
        }

        public SyntaxToken ClosingBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.FunctionCallExpressionSyntaxNode)_green)._closingBracket, this.GetChildPosition(3)); }
        }

        public ExpressionSyntaxNode FunctionName
        {
            get
            {
                var red = this.GetRed(ref this._functionName, 0);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Nodes
        {
            get
            {
                var red = this.GetRed(ref this._nodes, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _functionName, 0);
                case 2: return GetRed(ref _nodes, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitFunctionCallExpression(this);
        }

    }

    public class MemberAccessSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode _leftOperand;
        private SyntaxNode _rightOperand;

        internal MemberAccessSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken Dot
        {
            get { return new SyntaxToken(this, ((Parser.Internal.MemberAccessSyntaxNode)_green)._dot, this.GetChildPosition(1)); }
        }

        public SyntaxNode LeftOperand
        {
            get
            {
                var red = this.GetRed(ref this._leftOperand, 0);
                if (red != null)
                    return (SyntaxNode)red;

                return default(SyntaxNode);
            }
        }

        public SyntaxNode RightOperand
        {
            get
            {
                var red = this.GetRed(ref this._rightOperand, 2);
                if (red != null)
                    return (SyntaxNode)red;

                return default(SyntaxNode);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _leftOperand, 0);
                case 2: return GetRed(ref _rightOperand, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitMemberAccess(this);
        }

    }

    public class UnaryPostixOperationExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode _operand;

        internal UnaryPostixOperationExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken Operation
        {
            get { return new SyntaxToken(this, ((Parser.Internal.UnaryPostixOperationExpressionSyntaxNode)_green)._operation, this.GetChildPosition(1)); }
        }

        public ExpressionSyntaxNode Operand
        {
            get
            {
                var red = this.GetRed(ref this._operand, 0);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _operand, 0);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitUnaryPostixOperationExpression(this);
        }

    }

    public class IndirectMemberAccessSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode _expression;

        internal IndirectMemberAccessSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.IndirectMemberAccessSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); }
        }

        public SyntaxToken ClosingBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.IndirectMemberAccessSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); }
        }

        public ExpressionSyntaxNode Expression
        {
            get
            {
                var red = this.GetRed(ref this._expression, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _expression, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitIndirectMemberAccess(this);
        }

    }

    public class CommandExpressionSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode _commandName;
        private SyntaxNode _arguments;

        internal CommandExpressionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }


        public IdentifierNameSyntaxNode CommandName
        {
            get
            {
                var red = this.GetRed(ref this._commandName, 0);
                if (red != null)
                    return (IdentifierNameSyntaxNode)red;

                return default(IdentifierNameSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Arguments
        {
            get
            {
                var red = this.GetRed(ref this._arguments, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _commandName, 0);
                case 1: return GetRed(ref _arguments, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitCommandExpression(this);
        }

    }

    public class BaseClassInvokationSyntaxNode : ExpressionSyntaxNode
    {
        private SyntaxNode _methodName;
        private SyntaxNode _baseClassNameAndArguments;

        internal BaseClassInvokationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken AtSign
        {
            get { return new SyntaxToken(this, ((Parser.Internal.BaseClassInvokationSyntaxNode)_green)._atSign, this.GetChildPosition(1)); }
        }

        public ExpressionSyntaxNode MethodName
        {
            get
            {
                var red = this.GetRed(ref this._methodName, 0);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        public ExpressionSyntaxNode BaseClassNameAndArguments
        {
            get
            {
                var red = this.GetRed(ref this._baseClassNameAndArguments, 2);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _methodName, 0);
                case 2: return GetRed(ref _baseClassNameAndArguments, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitBaseClassInvokation(this);
        }

    }

    public class AttributeAssignmentSyntaxNode : SyntaxNode
    {
        private SyntaxNode _value;

        internal AttributeAssignmentSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken AssignmentSign
        {
            get { return new SyntaxToken(this, ((Parser.Internal.AttributeAssignmentSyntaxNode)_green)._assignmentSign, this.GetChildPosition(0)); }
        }

        public ExpressionSyntaxNode Value
        {
            get
            {
                var red = this.GetRed(ref this._value, 1);
                if (red != null)
                    return (ExpressionSyntaxNode)red;

                return default(ExpressionSyntaxNode);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _value, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitAttributeAssignment(this);
        }

    }

    public class AttributeSyntaxNode : SyntaxNode
    {
        private SyntaxNode _name;
        private SyntaxNode _assignment;

        internal AttributeSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }


        public IdentifierNameSyntaxNode Name
        {
            get
            {
                var red = this.GetRed(ref this._name, 0);
                if (red != null)
                    return (IdentifierNameSyntaxNode)red;

                return default(IdentifierNameSyntaxNode);
            }
        }

        public AttributeAssignmentSyntaxNode Assignment
        {
            get
            {
                var red = this.GetRed(ref this._assignment, 1);
                if (red != null)
                    return (AttributeAssignmentSyntaxNode)red;

                return default(AttributeAssignmentSyntaxNode);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _name, 0);
                case 1: return GetRed(ref _assignment, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitAttribute(this);
        }

    }

    public class AttributeListSyntaxNode : SyntaxNode
    {
        private SyntaxNode _nodes;

        internal AttributeListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.AttributeListSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); }
        }

        public SyntaxToken ClosingBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.AttributeListSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); }
        }

        public SyntaxNodeOrTokenList Nodes
        {
            get
            {
                var red = this.GetRed(ref this._nodes, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _nodes, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitAttributeList(this);
        }

    }

    public class MethodDefinitionSyntaxNode : MethodDeclarationSyntaxNode
    {
        private SyntaxNode _outputDescription;
        private SyntaxNode _name;
        private SyntaxNode _inputDescription;
        private SyntaxNode _commas;
        private SyntaxNode _body;

        internal MethodDefinitionSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken FunctionKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.MethodDefinitionSyntaxNode)_green)._functionKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.MethodDefinitionSyntaxNode)_green)._endKeyword, this.GetChildPosition(6)); }
        }

        public FunctionOutputDescriptionSyntaxNode OutputDescription
        {
            get
            {
                var red = this.GetRed(ref this._outputDescription, 1);
                if (red != null)
                    return (FunctionOutputDescriptionSyntaxNode)red;

                return default(FunctionOutputDescriptionSyntaxNode);
            }
        }

        public CompoundNameSyntaxNode Name
        {
            get
            {
                var red = this.GetRed(ref this._name, 2);
                if (red != null)
                    return (CompoundNameSyntaxNode)red;

                return default(CompoundNameSyntaxNode);
            }
        }

        public FunctionInputDescriptionSyntaxNode InputDescription
        {
            get
            {
                var red = this.GetRed(ref this._inputDescription, 3);
                if (red != null)
                    return (FunctionInputDescriptionSyntaxNode)red;

                return default(FunctionInputDescriptionSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Commas
        {
            get
            {
                var red = this.GetRed(ref this._commas, 4);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        public SyntaxNodeOrTokenList Body
        {
            get
            {
                var red = this.GetRed(ref this._body, 5);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _outputDescription, 1);
                case 2: return GetRed(ref _name, 2);
                case 3: return GetRed(ref _inputDescription, 3);
                case 4: return GetRed(ref _commas, 4);
                case 5: return GetRed(ref _body, 5);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitMethodDefinition(this);
        }

    }

    public class AbstractMethodDeclarationSyntaxNode : MethodDeclarationSyntaxNode
    {
        private SyntaxNode _outputDescription;
        private SyntaxNode _name;
        private SyntaxNode _inputDescription;

        internal AbstractMethodDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }


        public FunctionOutputDescriptionSyntaxNode OutputDescription
        {
            get
            {
                var red = this.GetRed(ref this._outputDescription, 0);
                if (red != null)
                    return (FunctionOutputDescriptionSyntaxNode)red;

                return default(FunctionOutputDescriptionSyntaxNode);
            }
        }

        public CompoundNameSyntaxNode Name
        {
            get
            {
                var red = this.GetRed(ref this._name, 1);
                if (red != null)
                    return (CompoundNameSyntaxNode)red;

                return default(CompoundNameSyntaxNode);
            }
        }

        public FunctionInputDescriptionSyntaxNode InputDescription
        {
            get
            {
                var red = this.GetRed(ref this._inputDescription, 2);
                if (red != null)
                    return (FunctionInputDescriptionSyntaxNode)red;

                return default(FunctionInputDescriptionSyntaxNode);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _outputDescription, 0);
                case 1: return GetRed(ref _name, 1);
                case 2: return GetRed(ref _inputDescription, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitAbstractMethodDeclaration(this);
        }

    }

    public class MethodsListSyntaxNode : SyntaxNode
    {
        private SyntaxNode _attributes;
        private SyntaxNode _methods;

        internal MethodsListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken MethodsKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.MethodsListSyntaxNode)_green)._methodsKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.MethodsListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); }
        }

        public AttributeListSyntaxNode Attributes
        {
            get
            {
                var red = this.GetRed(ref this._attributes, 1);
                if (red != null)
                    return (AttributeListSyntaxNode)red;

                return default(AttributeListSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Methods
        {
            get
            {
                var red = this.GetRed(ref this._methods, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _attributes, 1);
                case 2: return GetRed(ref _methods, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitMethodsList(this);
        }

    }

    public class PropertiesListSyntaxNode : SyntaxNode
    {
        private SyntaxNode _attributes;
        private SyntaxNode _properties;

        internal PropertiesListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken PropertiesKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.PropertiesListSyntaxNode)_green)._propertiesKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.PropertiesListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); }
        }

        public AttributeListSyntaxNode Attributes
        {
            get
            {
                var red = this.GetRed(ref this._attributes, 1);
                if (red != null)
                    return (AttributeListSyntaxNode)red;

                return default(AttributeListSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Properties
        {
            get
            {
                var red = this.GetRed(ref this._properties, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _attributes, 1);
                case 2: return GetRed(ref _properties, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitPropertiesList(this);
        }

    }

    public class BaseClassListSyntaxNode : SyntaxNode
    {
        private SyntaxNode _baseClasses;

        internal BaseClassListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken LessSign
        {
            get { return new SyntaxToken(this, ((Parser.Internal.BaseClassListSyntaxNode)_green)._lessSign, this.GetChildPosition(0)); }
        }

        public SyntaxNodeOrTokenList BaseClasses
        {
            get
            {
                var red = this.GetRed(ref this._baseClasses, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _baseClasses, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitBaseClassList(this);
        }

    }

    public class ClassDeclarationSyntaxNode : StatementSyntaxNode
    {
        private SyntaxNode _attributes;
        private SyntaxNode _className;
        private SyntaxNode _baseClassList;
        private SyntaxNode _nodes;

        internal ClassDeclarationSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken ClassdefKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ClassDeclarationSyntaxNode)_green)._classdefKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.ClassDeclarationSyntaxNode)_green)._endKeyword, this.GetChildPosition(5)); }
        }

        public AttributeListSyntaxNode Attributes
        {
            get
            {
                var red = this.GetRed(ref this._attributes, 1);
                if (red != null)
                    return (AttributeListSyntaxNode)red;

                return default(AttributeListSyntaxNode);
            }
        }

        public IdentifierNameSyntaxNode ClassName
        {
            get
            {
                var red = this.GetRed(ref this._className, 2);
                if (red != null)
                    return (IdentifierNameSyntaxNode)red;

                return default(IdentifierNameSyntaxNode);
            }
        }

        public BaseClassListSyntaxNode BaseClassList
        {
            get
            {
                var red = this.GetRed(ref this._baseClassList, 3);
                if (red != null)
                    return (BaseClassListSyntaxNode)red;

                return default(BaseClassListSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Nodes
        {
            get
            {
                var red = this.GetRed(ref this._nodes, 4);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _attributes, 1);
                case 2: return GetRed(ref _className, 2);
                case 3: return GetRed(ref _baseClassList, 3);
                case 4: return GetRed(ref _nodes, 4);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitClassDeclaration(this);
        }

    }

    public class EnumerationItemValueSyntaxNode : SyntaxNode
    {
        private SyntaxNode _values;

        internal EnumerationItemValueSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken OpeningBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.EnumerationItemValueSyntaxNode)_green)._openingBracket, this.GetChildPosition(0)); }
        }

        public SyntaxToken ClosingBracket
        {
            get { return new SyntaxToken(this, ((Parser.Internal.EnumerationItemValueSyntaxNode)_green)._closingBracket, this.GetChildPosition(2)); }
        }

        public SyntaxNodeOrTokenList Values
        {
            get
            {
                var red = this.GetRed(ref this._values, 1);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _values, 1);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitEnumerationItemValue(this);
        }

    }

    public class EnumerationItemSyntaxNode : SyntaxNode
    {
        private SyntaxNode _name;
        private SyntaxNode _values;
        private SyntaxNode _commas;

        internal EnumerationItemSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }


        public IdentifierNameSyntaxNode Name
        {
            get
            {
                var red = this.GetRed(ref this._name, 0);
                if (red != null)
                    return (IdentifierNameSyntaxNode)red;

                return default(IdentifierNameSyntaxNode);
            }
        }

        public EnumerationItemValueSyntaxNode Values
        {
            get
            {
                var red = this.GetRed(ref this._values, 1);
                if (red != null)
                    return (EnumerationItemValueSyntaxNode)red;

                return default(EnumerationItemValueSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Commas
        {
            get
            {
                var red = this.GetRed(ref this._commas, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 0: return GetRed(ref _name, 0);
                case 1: return GetRed(ref _values, 1);
                case 2: return GetRed(ref _commas, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitEnumerationItem(this);
        }

    }

    public class EnumerationListSyntaxNode : SyntaxNode
    {
        private SyntaxNode _attributes;
        private SyntaxNode _items;

        internal EnumerationListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken EnumerationKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.EnumerationListSyntaxNode)_green)._enumerationKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.EnumerationListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); }
        }

        public AttributeListSyntaxNode Attributes
        {
            get
            {
                var red = this.GetRed(ref this._attributes, 1);
                if (red != null)
                    return (AttributeListSyntaxNode)red;

                return default(AttributeListSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Items
        {
            get
            {
                var red = this.GetRed(ref this._items, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _attributes, 1);
                case 2: return GetRed(ref _items, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitEnumerationList(this);
        }

    }

    public class EventsListSyntaxNode : SyntaxNode
    {
        private SyntaxNode _attributes;
        private SyntaxNode _events;

        internal EventsListSyntaxNode(SyntaxNode parent, Internal.GreenNode green, int position) : base(parent, green, position)
        {
        }

        public SyntaxToken EventsKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.EventsListSyntaxNode)_green)._eventsKeyword, this.GetChildPosition(0)); }
        }

        public SyntaxToken EndKeyword
        {
            get { return new SyntaxToken(this, ((Parser.Internal.EventsListSyntaxNode)_green)._endKeyword, this.GetChildPosition(3)); }
        }

        public AttributeListSyntaxNode Attributes
        {
            get
            {
                var red = this.GetRed(ref this._attributes, 1);
                if (red != null)
                    return (AttributeListSyntaxNode)red;

                return default(AttributeListSyntaxNode);
            }
        }

        public SyntaxNodeOrTokenList Events
        {
            get
            {
                var red = this.GetRed(ref this._events, 2);
                if (red != null)
                    return (SyntaxNodeOrTokenList)red;

                return default(SyntaxNodeOrTokenList);
            }
        }

        internal override SyntaxNode GetNode(int i)
        {
            switch (i)
            {
                case 1: return GetRed(ref _attributes, 1);
                case 2: return GetRed(ref _events, 2);
                default: return null;
            }
        }

        public override void Accept(SyntaxVisitor visitor)
        {
            visitor.VisitEventsList(this);
        }

    }
}