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,
                                },
                                else: None,
                                else_block: None,
                            },
                        ),
                        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,
                                },
                                else: None,
                                else_block: None,
                            },
                        ),
                        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,
                                },
                                else: None,
                                else_block: None,
                            },
                        ),
                        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,
                                },
                                else: None,
                                else_block: None,
                            },
                        ),
                        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,
                                },
                                else: None,
                                else_block: None,
                            },
                        ),
                        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,
                                },
                                else: None,
                                else_block: None,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: Keyword {
                                    value: "foreach",
                                    position: 472,
                                },
                                iterator: ParenthesizedKeyAndValue {
                                    left_parenthesis: 480,
                                    expression: Variable(
                                        Variable {
                                            position: 481,
                                            name: "$a",
                                        },
                                    ),
                                    as: Keyword {
                                        value: "as",
                                        position: 484,
                                    },
                                    key: Variable {
                                        position: 487,
                                        name: "$b",
                                    },
                                    double_arrow: 490,
                                    value: Variable {
                                        position: 493,
                                        name: "$c",
                                    },
                                    right_parenthesis: 495,
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 497,
                                    statements: [],
                                    right_brace: 498,
                                },
                                else: Some(
                                    Keyword {
                                        value: "else",
                                        position: 500,
                                    },
                                ),
                                else_block: Some(
                                    BlockStatement {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left_brace: 505,
                                        statements: [],
                                        right_brace: 506,
                                    },
                                ),
                            },
                        ),
                        For(
                            ForStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                for: Keyword {
                                    value: "for",
                                    position: 513,
                                },
                                iterator: Standalone {
                                    initializations: CommaSeparated {
                                        inner: [
                                            AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 517,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    equals: 520,
                                                    right: Literal(
                                                        Integer(
                                                            LiteralInteger {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                value: "0",
                                                                position: 522,
                                                            },
                                                        ),
                                                    ),
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    initializations_semicolon: 523,
                                    conditions: CommaSeparated {
                                        inner: [
                                            ComparisonOperation(
                                                LessThan {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 525,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    less_than: 528,
                                                    right: Literal(
                                                        Integer(
                                                            LiteralInteger {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                value: "10",
                                                                position: 530,
                                                            },
                                                        ),
                                                    ),
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    conditions_semicolon: 532,
                                    loop: CommaSeparated {
                                        inner: [
                                            ArithmeticOperation(
                                                PostIncrement {
                                                    left: Variable(
                                                        Variable {
                                                            position: 534,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    increment: 536,
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 539,
                                    statements: [],
                                    right_brace: 542,
                                },
                            },
                        ),
                        For(
                            ForStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                for: Keyword {
                                    value: "for",
                                    position: 548,
                                },
                                iterator: Parenthesized {
                                    left_parenthesis: 552,
                                    initializations: CommaSeparated {
                                        inner: [
                                            AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 553,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    equals: 556,
                                                    right: Literal(
                                                        Integer(
                                                            LiteralInteger {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                value: "0",
                                                                position: 558,
                                                            },
                                                        ),
                                                    ),
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    initializations_semicolon: 559,
                                    conditions: CommaSeparated {
                                        inner: [
                                            ComparisonOperation(
                                                LessThan {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 561,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    less_than: 564,
                                                    right: Literal(
                                                        Integer(
                                                            LiteralInteger {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                value: "10",
                                                                position: 566,
                                                            },
                                                        ),
                                                    ),
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    conditions_semicolon: 568,
                                    loop: CommaSeparated {
                                        inner: [
                                            ArithmeticOperation(
                                                PostIncrement {
                                                    left: Variable(
                                                        Variable {
                                                            position: 570,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    increment: 572,
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    right_parenthesis: 574,
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 576,
                                    statements: [],
                                    right_brace: 577,
                                },
                            },
                        ),
                        For(
                            ForStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                for: Keyword {
                                    value: "for",
                                    position: 583,
                                },
                                iterator: Standalone {
                                    initializations: CommaSeparated {
                                        inner: [
                                            Parenthesized(
                                                ParenthesizedExpression {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: 587,
                                                    expression: AssignmentOperation(
                                                        Assignment {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            left: Variable(
                                                                Variable {
                                                                    position: 588,
                                                                    name: "$a",
                                                                },
                                                            ),
                                                            equals: 591,
                                                            right: Literal(
                                                                Integer(
                                                                    LiteralInteger {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        value: "0",
                                                                        position: 593,
                                                                    },
                                                                ),
                                                            ),
                                                        },
                                                    ),
                                                    right_parenthesis: 594,
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    initializations_semicolon: 595,
                                    conditions: CommaSeparated {
                                        inner: [
                                            ComparisonOperation(
                                                LessThan {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 597,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    less_than: 600,
                                                    right: Literal(
                                                        Integer(
                                                            LiteralInteger {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                value: "10",
                                                                position: 602,
                                                            },
                                                        ),
                                                    ),
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    conditions_semicolon: 604,
                                    loop: CommaSeparated {
                                        inner: [
                                            ArithmeticOperation(
                                                PostIncrement {
                                                    left: Variable(
                                                        Variable {
                                                            position: 606,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    increment: 608,
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 611,
                                    statements: [],
                                    right_brace: 612,
                                },
                            },
                        ),
                        For(
                            ForStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                for: Keyword {
                                    value: "for",
                                    position: 618,
                                },
                                iterator: Standalone {
                                    initializations: CommaSeparated {
                                        inner: [
                                            Parenthesized(
                                                ParenthesizedExpression {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: 622,
                                                    expression: AssignmentOperation(
                                                        Assignment {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            left: Variable(
                                                                Variable {
                                                                    position: 623,
                                                                    name: "$a",
                                                                },
                                                            ),
                                                            equals: 626,
                                                            right: Literal(
                                                                Integer(
                                                                    LiteralInteger {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        value: "0",
                                                                        position: 628,
                                                                    },
                                                                ),
                                                            ),
                                                        },
                                                    ),
                                                    right_parenthesis: 629,
                                                },
                                            ),
                                            AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 632,
                                                            name: "$i",
                                                        },
                                                    ),
                                                    equals: 635,
                                                    right: Literal(
                                                        Integer(
                                                            LiteralInteger {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                value: "10",
                                                                position: 637,
                                                            },
                                                        ),
                                                    ),
                                                },
                                            ),
                                        ],
                                        commas: [
                                            630,
                                        ],
                                    },
                                    initializations_semicolon: 639,
                                    conditions: CommaSeparated {
                                        inner: [
                                            ComparisonOperation(
                                                LessThan {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 641,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    less_than: 644,
                                                    right: Literal(
                                                        Integer(
                                                            LiteralInteger {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                value: "10",
                                                                position: 646,
                                                            },
                                                        ),
                                                    ),
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    conditions_semicolon: 648,
                                    loop: CommaSeparated {
                                        inner: [
                                            ArithmeticOperation(
                                                PostIncrement {
                                                    left: Variable(
                                                        Variable {
                                                            position: 650,
                                                            name: "$a",
                                                        },
                                                    ),
                                                    increment: 652,
                                                },
                                            ),
                                            Parenthesized(
                                                ParenthesizedExpression {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: 656,
                                                    expression: ArithmeticOperation(
                                                        PostDecrement {
                                                            left: Variable(
                                                                Variable {
                                                                    position: 657,
                                                                    name: "$i",
                                                                },
                                                            ),
                                                            decrement: 659,
                                                        },
                                                    ),
                                                    right_parenthesis: 661,
                                                },
                                            ),
                                        ],
                                        commas: [
                                            654,
                                        ],
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 663,
                                    statements: [],
                                    right_brace: 664,
                                },
                            },
                        ),
                        For(
                            ForStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                for: Keyword {
                                    value: "for",
                                    position: 671,
                                },
                                iterator: Standalone {
                                    initializations: CommaSeparated {
                                        inner: [],
                                        commas: [],
                                    },
                                    initializations_semicolon: 675,
                                    conditions: CommaSeparated {
                                        inner: [],
                                        commas: [],
                                    },
                                    conditions_semicolon: 676,
                                    loop: CommaSeparated {
                                        inner: [],
                                        commas: [],
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 678,
                                    statements: [],
                                    right_brace: 681,
                                },
                            },
                        ),
                        For(
                            ForStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                for: Keyword {
                                    value: "for",
                                    position: 687,
                                },
                                iterator: Parenthesized {
                                    left_parenthesis: 691,
                                    initializations: CommaSeparated {
                                        inner: [],
                                        commas: [],
                                    },
                                    initializations_semicolon: 692,
                                    conditions: CommaSeparated {
                                        inner: [],
                                        commas: [],
                                    },
                                    conditions_semicolon: 693,
                                    loop: CommaSeparated {
                                        inner: [],
                                        commas: [],
                                    },
                                    right_parenthesis: 694,
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 696,
                                    statements: [],
                                    right_brace: 697,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 704,
                                                name: "$a",
                                            },
                                        ),
                                        equals: 707,
                                        right: Match(
                                            MatchExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                match: Keyword {
                                                    value: "match",
                                                    position: 709,
                                                },
                                                expression: Some(
                                                    Variable(
                                                        Variable {
                                                            position: 715,
                                                            name: "$a",
                                                        },
                                                    ),
                                                ),
                                                body: MatchBodyExpression {
                                                    left_brace: 718,
                                                    arms: CommaSeparated {
                                                        inner: [
                                                            MatchArmExpression {
                                                                condition: Expressions(
                                                                    CommaSeparated {
                                                                        inner: [
                                                                            Literal(
                                                                                Integer(
                                                                                    LiteralInteger {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        value: "1",
                                                                                        position: 728,
                                                                                    },
                                                                                ),
                                                                            ),
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                ),
                                                                arrow: 730,
                                                                expression: Literal(
                                                                    Integer(
                                                                        LiteralInteger {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            value: "2",
                                                                            position: 733,
                                                                        },
                                                                    ),
                                                                ),
                                                            },
                                                            MatchArmExpression {
                                                                condition: Expressions(
                                                                    CommaSeparated {
                                                                        inner: [
                                                                            Literal(
                                                                                Integer(
                                                                                    LiteralInteger {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        value: "3",
                                                                                        position: 744,
                                                                                    },
                                                                                ),
                                                                            ),
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                ),
                                                                arrow: 746,
                                                                expression: Literal(
                                                                    Integer(
                                                                        LiteralInteger {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            value: "4",
                                                                            position: 749,
                                                                        },
                                                                    ),
                                                                ),
                                                            },
                                                            MatchArmExpression {
                                                                condition: Default(
                                                                    Keyword {
                                                                        value: "default",
                                                                        position: 760,
                                                                    },
                                                                ),
                                                                arrow: 768,
                                                                expression: Literal(
                                                                    Integer(
                                                                        LiteralInteger {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            value: "5",
                                                                            position: 771,
                                                                        },
                                                                    ),
                                                                ),
                                                            },
                                                        ],
                                                        commas: [
                                                            734,
                                                            750,
                                                            772,
                                                        ],
                                                    },
                                                    right_brace: 778,
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 779,
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 786,
                                                name: "$a",
                                            },
                                        ),
                                        equals: 789,
                                        right: Match(
                                            MatchExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                match: Keyword {
                                                    value: "match",
                                                    position: 791,
                                                },
                                                expression: Some(
                                                    Parenthesized(
                                                        ParenthesizedExpression {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            left_parenthesis: 797,
                                                            expression: Variable(
                                                                Variable {
                                                                    position: 798,
                                                                    name: "$a",
                                                                },
                                                            ),
                                                            right_parenthesis: 800,
                                                        },
                                                    ),
                                                ),
                                                body: MatchBodyExpression {
                                                    left_brace: 802,
                                                    arms: CommaSeparated {
                                                        inner: [
                                                            MatchArmExpression {
                                                                condition: Expressions(
                                                                    CommaSeparated {
                                                                        inner: [
                                                                            Literal(
                                                                                Integer(
                                                                                    LiteralInteger {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        value: "1",
                                                                                        position: 812,
                                                                                    },
                                                                                ),
                                                                            ),
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                ),
                                                                arrow: 814,
                                                                expression: Literal(
                                                                    Integer(
                                                                        LiteralInteger {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            value: "2",
                                                                            position: 817,
                                                                        },
                                                                    ),
                                                                ),
                                                            },
                                                            MatchArmExpression {
                                                                condition: Expressions(
                                                                    CommaSeparated {
                                                                        inner: [
                                                                            Literal(
                                                                                Integer(
                                                                                    LiteralInteger {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        value: "3",
                                                                                        position: 828,
                                                                                    },
                                                                                ),
                                                                            ),
                                                                        ],
                                                                        commas: [],
                                                                    },
                                                                ),
                                                                arrow: 830,
                                                                expression: Literal(
                                                                    Integer(
                                                                        LiteralInteger {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            value: "4",
                                                                            position: 833,
                                                                        },
                                                                    ),
                                                                ),
                                                            },
                                                            MatchArmExpression {
                                                                condition: Default(
                                                                    Keyword {
                                                                        value: "default",
                                                                        position: 844,
                                                                    },
                                                                ),
                                                                arrow: 852,
                                                                expression: Literal(
                                                                    Integer(
                                                                        LiteralInteger {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            value: "5",
                                                                            position: 855,
                                                                        },
                                                                    ),
                                                                ),
                                                            },
                                                        ],
                                                        commas: [
                                                            818,
                                                            834,
                                                            856,
                                                        ],
                                                    },
                                                    right_brace: 862,
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 863,
                            },
                        ),
                    ],
                    right_brace: 865,
                },
            },
        ),
    ],
    eof: 867,
}