DefinitionTree {
    definitions: [
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: Keyword {
                    value: "function",
                    position: 0,
                },
                name: Identifier {
                    position: 9,
                    value: "bar",
                },
                templates: None,
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 12,
                    parameters: CommaSeparated {
                        inner: [],
                        commas: [],
                    },
                    right_parenthesis: 13,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 14,
                    type_definition: Void(
                        Keyword {
                            value: "void",
                            position: 16,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 21,
                    statements: [
                        If(
                            IfStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                if: Keyword {
                                    value: "if",
                                    position: 27,
                                },
                                condition: Variable(
                                    Variable {
                                        position: 30,
                                        name: "$a",
                                    },
                                ),
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 33,
                                    statements: [],
                                    right_brace: 36,
                                },
                                elseifs: [],
                                else: None,
                            },
                        ),
                        If(
                            IfStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                if: Keyword {
                                    value: "if",
                                    position: 42,
                                },
                                condition: Parenthesized(
                                    ParenthesizedExpression {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left_parenthesis: 45,
                                        expression: Variable(
                                            Variable {
                                                position: 46,
                                                name: "$a",
                                            },
                                        ),
                                        right_parenthesis: 48,
                                    },
                                ),
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 50,
                                    statements: [],
                                    right_brace: 51,
                                },
                                elseifs: [],
                                else: None,
                            },
                        ),
                        If(
                            IfStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                if: Keyword {
                                    value: "if",
                                    position: 58,
                                },
                                condition: Variable(
                                    Variable {
                                        position: 61,
                                        name: "$a",
                                    },
                                ),
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 64,
                                    statements: [],
                                    right_brace: 68,
                                },
                                elseifs: [
                                    IfElseIfStatement {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        elseif: Keyword {
                                            value: "elseif",
                                            position: 70,
                                        },
                                        condition: Variable(
                                            Variable {
                                                position: 77,
                                                name: "$b",
                                            },
                                        ),
                                        block: BlockStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_brace: 80,
                                            statements: [],
                                            right_brace: 84,
                                        },
                                    },
                                ],
                                else: Some(
                                    IfElseStatement {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        else: Keyword {
                                            value: "else",
                                            position: 86,
                                        },
                                        block: If(
                                            IfStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                if: Keyword {
                                                    value: "if",
                                                    position: 91,
                                                },
                                                condition: Variable(
                                                    Variable {
                                                        position: 94,
                                                        name: "$c",
                                                    },
                                                ),
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: 97,
                                                    statements: [],
                                                    right_brace: 100,
                                                },
                                                elseifs: [],
                                                else: Some(
                                                    IfElseStatement {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        else: Keyword {
                                                            value: "else",
                                                            position: 102,
                                                        },
                                                        block: Block(
                                                            BlockStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_brace: 107,
                                                                statements: [],
                                                                right_brace: 108,
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            },
                        ),
                        If(
                            IfStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                if: Keyword {
                                    value: "if",
                                    position: 114,
                                },
                                condition: Parenthesized(
                                    ParenthesizedExpression {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left_parenthesis: 117,
                                        expression: Variable(
                                            Variable {
                                                position: 118,
                                                name: "$a",
                                            },
                                        ),
                                        right_parenthesis: 120,
                                    },
                                ),
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 122,
                                    statements: [],
                                    right_brace: 124,
                                },
                                elseifs: [
                                    IfElseIfStatement {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        elseif: Keyword {
                                            value: "elseif",
                                            position: 126,
                                        },
                                        condition: Parenthesized(
                                            ParenthesizedExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left_parenthesis: 133,
                                                expression: Variable(
                                                    Variable {
                                                        position: 134,
                                                        name: "$b",
                                                    },
                                                ),
                                                right_parenthesis: 136,
                                            },
                                        ),
                                        block: BlockStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_brace: 138,
                                            statements: [],
                                            right_brace: 140,
                                        },
                                    },
                                ],
                                else: Some(
                                    IfElseStatement {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        else: Keyword {
                                            value: "else",
                                            position: 142,
                                        },
                                        block: If(
                                            IfStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                if: Keyword {
                                                    value: "if",
                                                    position: 147,
                                                },
                                                condition: Parenthesized(
                                                    ParenthesizedExpression {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        left_parenthesis: 150,
                                                        expression: Variable(
                                                            Variable {
                                                                position: 151,
                                                                name: "$c",
                                                            },
                                                        ),
                                                        right_parenthesis: 153,
                                                    },
                                                ),
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: 155,
                                                    statements: [],
                                                    right_brace: 156,
                                                },
                                                elseifs: [],
                                                else: Some(
                                                    IfElseStatement {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        else: Keyword {
                                                            value: "else",
                                                            position: 158,
                                                        },
                                                        block: Block(
                                                            BlockStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_brace: 163,
                                                                statements: [],
                                                                right_brace: 164,
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            },
                        ),
                        If(
                            IfStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                if: Keyword {
                                    value: "if",
                                    position: 171,
                                },
                                condition: Variable(
                                    Variable {
                                        position: 174,
                                        name: "$a",
                                    },
                                ),
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 177,
                                    statements: [],
                                    right_brace: 180,
                                },
                                elseifs: [],
                                else: Some(
                                    IfElseStatement {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        else: Keyword {
                                            value: "else",
                                            position: 182,
                                        },
                                        block: Block(
                                            BlockStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left_brace: 187,
                                                statements: [],
                                                right_brace: 188,
                                            },
                                        ),
                                    },
                                ),
                            },
                        ),
                        If(
                            IfStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                if: Keyword {
                                    value: "if",
                                    position: 194,
                                },
                                condition: Parenthesized(
                                    ParenthesizedExpression {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left_parenthesis: 197,
                                        expression: Variable(
                                            Variable {
                                                position: 198,
                                                name: "$a",
                                            },
                                        ),
                                        right_parenthesis: 200,
                                    },
                                ),
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 202,
                                    statements: [],
                                    right_brace: 203,
                                },
                                elseifs: [],
                                else: Some(
                                    IfElseStatement {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        else: Keyword {
                                            value: "else",
                                            position: 205,
                                        },
                                        block: Block(
                                            BlockStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left_brace: 210,
                                                statements: [],
                                                right_brace: 211,
                                            },
                                        ),
                                    },
                                ),
                            },
                        ),
                        While(
                            WhileStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                while: Keyword {
                                    value: "while",
                                    position: 218,
                                },
                                condition: Variable(
                                    Variable {
                                        position: 224,
                                        name: "$a",
                                    },
                                ),
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 227,
                                    statements: [],
                                    right_brace: 230,
                                },
                            },
                        ),
                        While(
                            WhileStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                while: Keyword {
                                    value: "while",
                                    position: 236,
                                },
                                condition: Parenthesized(
                                    ParenthesizedExpression {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left_parenthesis: 242,
                                        expression: Variable(
                                            Variable {
                                                position: 243,
                                                name: "$a",
                                            },
                                        ),
                                        right_parenthesis: 245,
                                    },
                                ),
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 247,
                                    statements: [],
                                    right_brace: 248,
                                },
                            },
                        ),
                        DoWhile(
                            DoWhileStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                do: Keyword {
                                    value: "do",
                                    position: 255,
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 258,
                                    statements: [],
                                    right_brace: 259,
                                },
                                while: Keyword {
                                    value: "while",
                                    position: 261,
                                },
                                condition: Variable(
                                    Variable {
                                        position: 267,
                                        name: "$a",
                                    },
                                ),
                                semicolon: 269,
                            },
                        ),
                        DoWhile(
                            DoWhileStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                do: Keyword {
                                    value: "do",
                                    position: 275,
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 278,
                                    statements: [],
                                    right_brace: 279,
                                },
                                while: Keyword {
                                    value: "while",
                                    position: 281,
                                },
                                condition: Parenthesized(
                                    ParenthesizedExpression {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left_parenthesis: 287,
                                        expression: Variable(
                                            Variable {
                                                position: 288,
                                                name: "$a",
                                            },
                                        ),
                                        right_parenthesis: 290,
                                    },
                                ),
                                semicolon: 291,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: Keyword {
                                    value: "foreach",
                                    position: 298,
                                },
                                iterator: Value {
                                    expression: Variable(
                                        Variable {
                                            position: 306,
                                            name: "$a",
                                        },
                                    ),
                                    as: Keyword {
                                        value: "as",
                                        position: 309,
                                    },
                                    value: Variable {
                                        position: 312,
                                        name: "$b",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 315,
                                    statements: [],
                                    right_brace: 318,
                                },
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: Keyword {
                                    value: "foreach",
                                    position: 324,
                                },
                                iterator: Value {
                                    expression: Parenthesized(
                                        ParenthesizedExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: 332,
                                            expression: Variable(
                                                Variable {
                                                    position: 333,
                                                    name: "$a",
                                                },
                                            ),
                                            right_parenthesis: 335,
                                        },
                                    ),
                                    as: Keyword {
                                        value: "as",
                                        position: 337,
                                    },
                                    value: Variable {
                                        position: 340,
                                        name: "$b",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 343,
                                    statements: [],
                                    right_brace: 344,
                                },
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: Keyword {
                                    value: "foreach",
                                    position: 350,
                                },
                                iterator: ParenthesizedValue {
                                    left_parenthesis: 358,
                                    expression: Variable(
                                        Variable {
                                            position: 359,
                                            name: "$a",
                                        },
                                    ),
                                    as: Keyword {
                                        value: "as",
                                        position: 362,
                                    },
                                    value: Variable {
                                        position: 365,
                                        name: "$b",
                                    },
                                    right_parenthesis: 367,
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 369,
                                    statements: [],
                                    right_brace: 370,
                                },
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: Keyword {
                                    value: "foreach",
                                    position: 376,
                                },
                                iterator: KeyAndValue {
                                    expression: Variable(
                                        Variable {
                                            position: 384,
                                            name: "$a",
                                        },
                                    ),
                                    as: Keyword {
                                        value: "as",
                                        position: 387,
                                    },
                                    key: Variable {
                                        position: 390,
                                        name: "$b",
                                    },
                                    double_arrow: 393,
                                    value: Variable {
                                        position: 396,
                                        name: "$c",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 399,
                                    statements: [],
                                    right_brace: 402,
                                },
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: Keyword {
                                    value: "foreach",
                                    position: 408,
                                },
                                iterator: KeyAndValue {
                                    expression: Parenthesized(
                                        ParenthesizedExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: 416,
                                            expression: Variable(
                                                Variable {
                                                    position: 417,
                                                    name: "$a",
                                                },
                                            ),
                                            right_parenthesis: 419,
                                        },
                                    ),
                                    as: Keyword {
                                        value: "as",
                                        position: 421,
                                    },
                                    key: Variable {
                                        position: 424,
                                        name: "$b",
                                    },
                                    double_arrow: 427,
                                    value: Variable {
                                        position: 430,
                                        name: "$c",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 433,
                                    statements: [],
                                    right_brace: 434,
                                },
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: Keyword {
                                    value: "foreach",
                                    position: 440,
                                },
                                iterator: ParenthesizedKeyAndValue {
                                    left_parenthesis: 448,
                                    expression: Variable(
                                        Variable {
                                            position: 449,
                                            name: "$a",
                                        },
                                    ),
                                    as: Keyword {
                                        value: "as",
                                        position: 452,
                                    },
                                    key: Variable {
                                        position: 455,
                                        name: "$b",
                                    },
                                    double_arrow: 458,
                                    value: Variable {
                                        position: 461,
                                        name: "$c",
                                    },
                                    right_parenthesis: 463,
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 465,
                                    statements: [],
                                    right_brace: 466,
                                },
                            },
                        ),
                        For(
                            ForStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                for: Keyword {
                                    value: "for",
                                    position: 473,
                                },
                                iterator: Standalone {
                                    initializations: CommaSeparated {
                                        inner: [
                                            AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 477,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    equals: 480,
                                                    right: Literal(
                                                        Integer(
                                                            LiteralInteger {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                value: "0",
                                                                position: 482,
                                                            },
                                                        ),
                                                    ),
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    initializations_semicolon: 483,
                                    conditions: CommaSeparated {
                                        inner: [
                                            ComparisonOperation(
                                                LessThan {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 485,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    less_than: 488,
                                                    right: Literal(
                                                        Integer(
                                                            LiteralInteger {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                value: "10",
                                                                position: 490,
                                                            },
                                                        ),
                                                    ),
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    conditions_semicolon: 492,
                                    loop: CommaSeparated {
                                        inner: [
                                            ArithmeticOperation(
                                                PostIncrement {
                                                    left: Variable(
                                                        Variable {
                                                            position: 494,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    increment: 496,
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 499,
                                    statements: [],
                                    right_brace: 502,
                                },
                            },
                        ),
                        For(
                            ForStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                for: Keyword {
                                    value: "for",
                                    position: 508,
                                },
                                iterator: Parenthesized {
                                    left_parenthesis: 512,
                                    initializations: CommaSeparated {
                                        inner: [
                                            AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 513,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    equals: 516,
                                                    right: Literal(
                                                        Integer(
                                                            LiteralInteger {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                value: "0",
                                                                position: 518,
                                                            },
                                                        ),
                                                    ),
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    initializations_semicolon: 519,
                                    conditions: CommaSeparated {
                                        inner: [
                                            ComparisonOperation(
                                                LessThan {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 521,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    less_than: 524,
                                                    right: Literal(
                                                        Integer(
                                                            LiteralInteger {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                value: "10",
                                                                position: 526,
                                                            },
                                                        ),
                                                    ),
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    conditions_semicolon: 528,
                                    loop: CommaSeparated {
                                        inner: [
                                            ArithmeticOperation(
                                                PostIncrement {
                                                    left: Variable(
                                                        Variable {
                                                            position: 530,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    increment: 532,
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    right_parenthesis: 534,
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 536,
                                    statements: [],
                                    right_brace: 537,
                                },
                            },
                        ),
                        For(
                            ForStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                for: Keyword {
                                    value: "for",
                                    position: 543,
                                },
                                iterator: Standalone {
                                    initializations: CommaSeparated {
                                        inner: [
                                            Parenthesized(
                                                ParenthesizedExpression {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: 547,
                                                    expression: AssignmentOperation(
                                                        Assignment {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            left: Variable(
                                                                Variable {
                                                                    position: 548,
                                                                    name: "$a",
                                                                },
                                                            ),
                                                            equals: 551,
                                                            right: Literal(
                                                                Integer(
                                                                    LiteralInteger {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        value: "0",
                                                                        position: 553,
                                                                    },
                                                                ),
                                                            ),
                                                        },
                                                    ),
                                                    right_parenthesis: 554,
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    initializations_semicolon: 555,
                                    conditions: CommaSeparated {
                                        inner: [
                                            ComparisonOperation(
                                                LessThan {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 557,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    less_than: 560,
                                                    right: Literal(
                                                        Integer(
                                                            LiteralInteger {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                value: "10",
                                                                position: 562,
                                                            },
                                                        ),
                                                    ),
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    conditions_semicolon: 564,
                                    loop: CommaSeparated {
                                        inner: [
                                            ArithmeticOperation(
                                                PostIncrement {
                                                    left: Variable(
                                                        Variable {
                                                            position: 566,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    increment: 568,
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 571,
                                    statements: [],
                                    right_brace: 572,
                                },
                            },
                        ),
                        For(
                            ForStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                for: Keyword {
                                    value: "for",
                                    position: 578,
                                },
                                iterator: Standalone {
                                    initializations: CommaSeparated {
                                        inner: [
                                            Parenthesized(
                                                ParenthesizedExpression {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: 582,
                                                    expression: AssignmentOperation(
                                                        Assignment {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            left: Variable(
                                                                Variable {
                                                                    position: 583,
                                                                    name: "$a",
                                                                },
                                                            ),
                                                            equals: 586,
                                                            right: Literal(
                                                                Integer(
                                                                    LiteralInteger {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        value: "0",
                                                                        position: 588,
                                                                    },
                                                                ),
                                                            ),
                                                        },
                                                    ),
                                                    right_parenthesis: 589,
                                                },
                                            ),
                                            AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 592,
                                                            name: "$i",
                                                        },
                                                    ),
                                                    equals: 595,
                                                    right: Literal(
                                                        Integer(
                                                            LiteralInteger {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                value: "10",
                                                                position: 597,
                                                            },
                                                        ),
                                                    ),
                                                },
                                            ),
                                        ],
                                        commas: [
                                            590,
                                        ],
                                    },
                                    initializations_semicolon: 599,
                                    conditions: CommaSeparated {
                                        inner: [
                                            ComparisonOperation(
                                                LessThan {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 601,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    less_than: 604,
                                                    right: Literal(
                                                        Integer(
                                                            LiteralInteger {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                value: "10",
                                                                position: 606,
                                                            },
                                                        ),
                                                    ),
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    conditions_semicolon: 608,
                                    loop: CommaSeparated {
                                        inner: [
                                            ArithmeticOperation(
                                                PostIncrement {
                                                    left: Variable(
                                                        Variable {
                                                            position: 610,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    increment: 612,
                                                },
                                            ),
                                            Parenthesized(
                                                ParenthesizedExpression {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: 616,
                                                    expression: ArithmeticOperation(
                                                        PostDecrement {
                                                            left: Variable(
                                                                Variable {
                                                                    position: 617,
                                                                    name: "$i",
                                                                },
                                                            ),
                                                            decrement: 619,
                                                        },
                                                    ),
                                                    right_parenthesis: 621,
                                                },
                                            ),
                                        ],
                                        commas: [
                                            614,
                                        ],
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 623,
                                    statements: [],
                                    right_brace: 624,
                                },
                            },
                        ),
                        For(
                            ForStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                for: Keyword {
                                    value: "for",
                                    position: 631,
                                },
                                iterator: Standalone {
                                    initializations: CommaSeparated {
                                        inner: [],
                                        commas: [],
                                    },
                                    initializations_semicolon: 635,
                                    conditions: CommaSeparated {
                                        inner: [],
                                        commas: [],
                                    },
                                    conditions_semicolon: 636,
                                    loop: CommaSeparated {
                                        inner: [],
                                        commas: [],
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 638,
                                    statements: [],
                                    right_brace: 641,
                                },
                            },
                        ),
                        For(
                            ForStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                for: Keyword {
                                    value: "for",
                                    position: 647,
                                },
                                iterator: Parenthesized {
                                    left_parenthesis: 651,
                                    initializations: CommaSeparated {
                                        inner: [],
                                        commas: [],
                                    },
                                    initializations_semicolon: 652,
                                    conditions: CommaSeparated {
                                        inner: [],
                                        commas: [],
                                    },
                                    conditions_semicolon: 653,
                                    loop: CommaSeparated {
                                        inner: [],
                                        commas: [],
                                    },
                                    right_parenthesis: 654,
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 656,
                                    statements: [],
                                    right_brace: 657,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 664,
                                                name: "$a",
                                            },
                                        ),
                                        equals: 667,
                                        right: Match(
                                            MatchExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                match: Keyword {
                                                    value: "match",
                                                    position: 669,
                                                },
                                                expression: Some(
                                                    Variable(
                                                        Variable {
                                                            position: 675,
                                                            name: "$a",
                                                        },
                                                    ),
                                                ),
                                                body: MatchBodyExpression {
                                                    left_brace: 678,
                                                    arms: CommaSeparated {
                                                        inner: [
                                                            MatchArmExpression {
                                                                condition: Expressions(
                                                                    CommaSeparated {
                                                                        inner: [
                                                                            Literal(
                                                                                Integer(
                                                                                    LiteralInteger {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        value: "1",
                                                                                        position: 688,
                                                                                    },
                                                                                ),
                                                                            ),
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                ),
                                                                arrow: 690,
                                                                expression: Literal(
                                                                    Integer(
                                                                        LiteralInteger {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            value: "2",
                                                                            position: 693,
                                                                        },
                                                                    ),
                                                                ),
                                                            },
                                                            MatchArmExpression {
                                                                condition: Expressions(
                                                                    CommaSeparated {
                                                                        inner: [
                                                                            Literal(
                                                                                Integer(
                                                                                    LiteralInteger {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        value: "3",
                                                                                        position: 704,
                                                                                    },
                                                                                ),
                                                                            ),
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                ),
                                                                arrow: 706,
                                                                expression: Literal(
                                                                    Integer(
                                                                        LiteralInteger {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            value: "4",
                                                                            position: 709,
                                                                        },
                                                                    ),
                                                                ),
                                                            },
                                                            MatchArmExpression {
                                                                condition: Default(
                                                                    Keyword {
                                                                        value: "default",
                                                                        position: 720,
                                                                    },
                                                                ),
                                                                arrow: 728,
                                                                expression: Literal(
                                                                    Integer(
                                                                        LiteralInteger {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            value: "5",
                                                                            position: 731,
                                                                        },
                                                                    ),
                                                                ),
                                                            },
                                                        ],
                                                        commas: [
                                                            694,
                                                            710,
                                                            732,
                                                        ],
                                                    },
                                                    right_brace: 738,
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 739,
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 746,
                                                name: "$a",
                                            },
                                        ),
                                        equals: 749,
                                        right: Match(
                                            MatchExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                match: Keyword {
                                                    value: "match",
                                                    position: 751,
                                                },
                                                expression: Some(
                                                    Parenthesized(
                                                        ParenthesizedExpression {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            left_parenthesis: 757,
                                                            expression: Variable(
                                                                Variable {
                                                                    position: 758,
                                                                    name: "$a",
                                                                },
                                                            ),
                                                            right_parenthesis: 760,
                                                        },
                                                    ),
                                                ),
                                                body: MatchBodyExpression {
                                                    left_brace: 762,
                                                    arms: CommaSeparated {
                                                        inner: [
                                                            MatchArmExpression {
                                                                condition: Expressions(
                                                                    CommaSeparated {
                                                                        inner: [
                                                                            Literal(
                                                                                Integer(
                                                                                    LiteralInteger {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        value: "1",
                                                                                        position: 772,
                                                                                    },
                                                                                ),
                                                                            ),
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                ),
                                                                arrow: 774,
                                                                expression: Literal(
                                                                    Integer(
                                                                        LiteralInteger {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            value: "2",
                                                                            position: 777,
                                                                        },
                                                                    ),
                                                                ),
                                                            },
                                                            MatchArmExpression {
                                                                condition: Expressions(
                                                                    CommaSeparated {
                                                                        inner: [
                                                                            Literal(
                                                                                Integer(
                                                                                    LiteralInteger {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        value: "3",
                                                                                        position: 788,
                                                                                    },
                                                                                ),
                                                                            ),
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                ),
                                                                arrow: 790,
                                                                expression: Literal(
                                                                    Integer(
                                                                        LiteralInteger {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            value: "4",
                                                                            position: 793,
                                                                        },
                                                                    ),
                                                                ),
                                                            },
                                                            MatchArmExpression {
                                                                condition: Default(
                                                                    Keyword {
                                                                        value: "default",
                                                                        position: 804,
                                                                    },
                                                                ),
                                                                arrow: 812,
                                                                expression: Literal(
                                                                    Integer(
                                                                        LiteralInteger {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            value: "5",
                                                                            position: 815,
                                                                        },
                                                                    ),
                                                                ),
                                                            },
                                                        ],
                                                        commas: [
                                                            778,
                                                            794,
                                                            816,
                                                        ],
                                                    },
                                                    right_brace: 822,
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 823,
                            },
                        ),
                    ],
                    right_brace: 825,
                },
            },
        ),
    ],
    eof: 827,
}