DefinitionTree {
    definitions: [
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: Span {
                    line: 1,
                    column: 1,
                    position: 0,
                },
                name: Identifier {
                    span: Span {
                        line: 1,
                        column: 10,
                        position: 9,
                    },
                    value: "foo",
                },
                templates: None,
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: Span {
                        line: 1,
                        column: 13,
                        position: 12,
                    },
                    parameters: CommaSeparated {
                        inner: [],
                        commas: [],
                    },
                    right_parenthesis: Span {
                        line: 1,
                        column: 14,
                        position: 13,
                    },
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: Span {
                        line: 1,
                        column: 15,
                        position: 14,
                    },
                    type_definition: Void(
                        Span {
                            line: 1,
                            column: 17,
                            position: 16,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: Span {
                        line: 1,
                        column: 22,
                        position: 21,
                    },
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: Identifier(
                                    Identifier {
                                        span: Span {
                                            line: 2,
                                            column: 5,
                                            position: 27,
                                        },
                                        value: "a",
                                    },
                                ),
                                semicolon: Span {
                                    line: 2,
                                    column: 6,
                                    position: 28,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: Variable(
                                    Variable {
                                        span: Span {
                                            line: 4,
                                            column: 5,
                                            position: 35,
                                        },
                                        name: "$a",
                                    },
                                ),
                                semicolon: Span {
                                    line: 4,
                                    column: 7,
                                    position: 37,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ClassOperation(
                                    ConstantFetch {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        class: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 6,
                                                    column: 5,
                                                    position: 44,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        double_colon: Span {
                                            line: 6,
                                            column: 7,
                                            position: 46,
                                        },
                                        constant: Identifier {
                                            span: Span {
                                                line: 6,
                                                column: 9,
                                                position: 48,
                                            },
                                            value: "b",
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 6,
                                    column: 10,
                                    position: 49,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    PropertyFetch {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 8,
                                                    column: 5,
                                                    position: 56,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        arrow: Span {
                                            line: 8,
                                            column: 7,
                                            position: 58,
                                        },
                                        property: Identifier {
                                            span: Span {
                                                line: 8,
                                                column: 9,
                                                position: 60,
                                            },
                                            value: "b",
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 8,
                                    column: 10,
                                    position: 61,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ClassOperation(
                                    StaticMethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        class: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 10,
                                                    column: 5,
                                                    position: 68,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        double_colon: Span {
                                            line: 10,
                                            column: 7,
                                            position: 70,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 10,
                                                column: 9,
                                                position: 72,
                                            },
                                            value: "b",
                                        },
                                        generics: None,
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 10,
                                                column: 10,
                                                position: 73,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 10,
                                                column: 11,
                                                position: 74,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 10,
                                    column: 12,
                                    position: 75,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ClassOperation(
                                    StaticMethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        class: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 11,
                                                    column: 5,
                                                    position: 81,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        double_colon: Span {
                                            line: 11,
                                            column: 7,
                                            position: 83,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 11,
                                                column: 9,
                                                position: 85,
                                            },
                                            value: "b",
                                        },
                                        generics: None,
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 11,
                                                column: 10,
                                                position: 86,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: None,
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 11,
                                                                    column: 11,
                                                                    position: 87,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 11,
                                                column: 13,
                                                position: 89,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 11,
                                    column: 14,
                                    position: 90,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ClassOperation(
                                    StaticMethodClosureCreation {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        class: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 12,
                                                    column: 5,
                                                    position: 96,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        double_colon: Span {
                                            line: 12,
                                            column: 7,
                                            position: 98,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 12,
                                                column: 9,
                                                position: 100,
                                            },
                                            value: "b",
                                        },
                                        generics: None,
                                        placeholder: ArgumentPlaceholderExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 12,
                                                column: 10,
                                                position: 101,
                                            },
                                            ellipsis: Span {
                                                line: 12,
                                                column: 11,
                                                position: 102,
                                            },
                                            right_parenthesis: Span {
                                                line: 12,
                                                column: 14,
                                                position: 105,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 12,
                                    column: 15,
                                    position: 106,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ClassOperation(
                                    StaticMethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        class: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 13,
                                                    column: 5,
                                                    position: 112,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        double_colon: Span {
                                            line: 13,
                                            column: 7,
                                            position: 114,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 13,
                                                column: 9,
                                                position: 116,
                                            },
                                            value: "b",
                                        },
                                        generics: None,
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 13,
                                                column: 10,
                                                position: 117,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: Some(
                                                            Span {
                                                                line: 13,
                                                                column: 11,
                                                                position: 118,
                                                            },
                                                        ),
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 13,
                                                                    column: 14,
                                                                    position: 121,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 13,
                                                column: 16,
                                                position: 123,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 13,
                                    column: 17,
                                    position: 124,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    MethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 15,
                                                    column: 5,
                                                    position: 131,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        arrow: Span {
                                            line: 15,
                                            column: 7,
                                            position: 133,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 15,
                                                column: 9,
                                                position: 135,
                                            },
                                            value: "b",
                                        },
                                        generics: None,
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 15,
                                                column: 10,
                                                position: 136,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 15,
                                                column: 11,
                                                position: 137,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 15,
                                    column: 12,
                                    position: 138,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    MethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 16,
                                                    column: 5,
                                                    position: 144,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        arrow: Span {
                                            line: 16,
                                            column: 7,
                                            position: 146,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 16,
                                                column: 9,
                                                position: 148,
                                            },
                                            value: "b",
                                        },
                                        generics: None,
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 16,
                                                column: 10,
                                                position: 149,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: None,
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 16,
                                                                    column: 11,
                                                                    position: 150,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 16,
                                                column: 13,
                                                position: 152,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 16,
                                    column: 14,
                                    position: 153,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    MethodClosureCreation {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 17,
                                                    column: 5,
                                                    position: 159,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        arrow: Span {
                                            line: 17,
                                            column: 7,
                                            position: 161,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 17,
                                                column: 9,
                                                position: 163,
                                            },
                                            value: "b",
                                        },
                                        generics: None,
                                        placeholder: ArgumentPlaceholderExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 17,
                                                column: 10,
                                                position: 164,
                                            },
                                            ellipsis: Span {
                                                line: 17,
                                                column: 11,
                                                position: 165,
                                            },
                                            right_parenthesis: Span {
                                                line: 17,
                                                column: 14,
                                                position: 168,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 17,
                                    column: 15,
                                    position: 169,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    MethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 18,
                                                    column: 5,
                                                    position: 175,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        arrow: Span {
                                            line: 18,
                                            column: 7,
                                            position: 177,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 18,
                                                column: 9,
                                                position: 179,
                                            },
                                            value: "b",
                                        },
                                        generics: None,
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 18,
                                                column: 10,
                                                position: 180,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: Some(
                                                            Span {
                                                                line: 18,
                                                                column: 11,
                                                                position: 181,
                                                            },
                                                        ),
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 18,
                                                                    column: 14,
                                                                    position: 184,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 18,
                                                column: 16,
                                                position: 186,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 18,
                                    column: 17,
                                    position: 187,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    NullsafeMethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 20,
                                                    column: 5,
                                                    position: 194,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        question_arrow: Span {
                                            line: 20,
                                            column: 7,
                                            position: 196,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 20,
                                                column: 10,
                                                position: 199,
                                            },
                                            value: "b",
                                        },
                                        generics: None,
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 20,
                                                column: 11,
                                                position: 200,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 20,
                                                column: 12,
                                                position: 201,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 20,
                                    column: 13,
                                    position: 202,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    NullsafeMethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 21,
                                                    column: 5,
                                                    position: 208,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        question_arrow: Span {
                                            line: 21,
                                            column: 7,
                                            position: 210,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 21,
                                                column: 10,
                                                position: 213,
                                            },
                                            value: "b",
                                        },
                                        generics: None,
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 21,
                                                column: 11,
                                                position: 214,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: None,
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 21,
                                                                    column: 12,
                                                                    position: 215,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 21,
                                                column: 14,
                                                position: 217,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 21,
                                    column: 15,
                                    position: 218,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    NullsafeMethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 22,
                                                    column: 5,
                                                    position: 224,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        question_arrow: Span {
                                            line: 22,
                                            column: 7,
                                            position: 226,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 22,
                                                column: 10,
                                                position: 229,
                                            },
                                            value: "b",
                                        },
                                        generics: None,
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 22,
                                                column: 11,
                                                position: 230,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: Some(
                                                            Span {
                                                                line: 22,
                                                                column: 12,
                                                                position: 231,
                                                            },
                                                        ),
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 22,
                                                                    column: 15,
                                                                    position: 234,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 22,
                                                column: 17,
                                                position: 236,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 22,
                                    column: 18,
                                    position: 237,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ClassOperation(
                                    StaticMethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        class: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 24,
                                                    column: 5,
                                                    position: 244,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        double_colon: Span {
                                            line: 24,
                                            column: 7,
                                            position: 246,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 24,
                                                column: 9,
                                                position: 248,
                                            },
                                            value: "b",
                                        },
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 24,
                                                    column: 10,
                                                    position: 249,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 24,
                                                                column: 13,
                                                                position: 252,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 24,
                                                    column: 16,
                                                    position: 255,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 24,
                                                column: 17,
                                                position: 256,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 24,
                                                column: 18,
                                                position: 257,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 24,
                                    column: 19,
                                    position: 258,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ClassOperation(
                                    StaticMethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        class: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 25,
                                                    column: 5,
                                                    position: 264,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        double_colon: Span {
                                            line: 25,
                                            column: 7,
                                            position: 266,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 25,
                                                column: 9,
                                                position: 268,
                                            },
                                            value: "b",
                                        },
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 25,
                                                    column: 10,
                                                    position: 269,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 25,
                                                                column: 13,
                                                                position: 272,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 25,
                                                    column: 16,
                                                    position: 275,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 25,
                                                column: 17,
                                                position: 276,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: None,
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 25,
                                                                    column: 18,
                                                                    position: 277,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 25,
                                                column: 20,
                                                position: 279,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 25,
                                    column: 21,
                                    position: 280,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ClassOperation(
                                    StaticMethodClosureCreation {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        class: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 26,
                                                    column: 5,
                                                    position: 286,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        double_colon: Span {
                                            line: 26,
                                            column: 7,
                                            position: 288,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 26,
                                                column: 9,
                                                position: 290,
                                            },
                                            value: "b",
                                        },
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 26,
                                                    column: 10,
                                                    position: 291,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 26,
                                                                column: 13,
                                                                position: 294,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 26,
                                                    column: 16,
                                                    position: 297,
                                                },
                                            },
                                        ),
                                        placeholder: ArgumentPlaceholderExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 26,
                                                column: 17,
                                                position: 298,
                                            },
                                            ellipsis: Span {
                                                line: 26,
                                                column: 18,
                                                position: 299,
                                            },
                                            right_parenthesis: Span {
                                                line: 26,
                                                column: 21,
                                                position: 302,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 26,
                                    column: 22,
                                    position: 303,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ClassOperation(
                                    StaticMethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        class: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 27,
                                                    column: 5,
                                                    position: 309,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        double_colon: Span {
                                            line: 27,
                                            column: 7,
                                            position: 311,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 27,
                                                column: 9,
                                                position: 313,
                                            },
                                            value: "b",
                                        },
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 27,
                                                    column: 10,
                                                    position: 314,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 27,
                                                                column: 13,
                                                                position: 317,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 27,
                                                    column: 16,
                                                    position: 320,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 27,
                                                column: 17,
                                                position: 321,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: Some(
                                                            Span {
                                                                line: 27,
                                                                column: 18,
                                                                position: 322,
                                                            },
                                                        ),
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 27,
                                                                    column: 21,
                                                                    position: 325,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 27,
                                                column: 23,
                                                position: 327,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 27,
                                    column: 24,
                                    position: 328,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    MethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 29,
                                                    column: 5,
                                                    position: 335,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        arrow: Span {
                                            line: 29,
                                            column: 7,
                                            position: 337,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 29,
                                                column: 9,
                                                position: 339,
                                            },
                                            value: "b",
                                        },
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 29,
                                                    column: 10,
                                                    position: 340,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 29,
                                                                column: 13,
                                                                position: 343,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 29,
                                                    column: 16,
                                                    position: 346,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 29,
                                                column: 17,
                                                position: 347,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 29,
                                                column: 18,
                                                position: 348,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 29,
                                    column: 19,
                                    position: 349,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    MethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 30,
                                                    column: 5,
                                                    position: 355,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        arrow: Span {
                                            line: 30,
                                            column: 7,
                                            position: 357,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 30,
                                                column: 9,
                                                position: 359,
                                            },
                                            value: "b",
                                        },
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 30,
                                                    column: 10,
                                                    position: 360,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 30,
                                                                column: 13,
                                                                position: 363,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 30,
                                                    column: 16,
                                                    position: 366,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 30,
                                                column: 17,
                                                position: 367,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: None,
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 30,
                                                                    column: 18,
                                                                    position: 368,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 30,
                                                column: 20,
                                                position: 370,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 30,
                                    column: 21,
                                    position: 371,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    MethodClosureCreation {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 31,
                                                    column: 5,
                                                    position: 377,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        arrow: Span {
                                            line: 31,
                                            column: 7,
                                            position: 379,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 31,
                                                column: 9,
                                                position: 381,
                                            },
                                            value: "b",
                                        },
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 31,
                                                    column: 10,
                                                    position: 382,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 31,
                                                                column: 13,
                                                                position: 385,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 31,
                                                    column: 16,
                                                    position: 388,
                                                },
                                            },
                                        ),
                                        placeholder: ArgumentPlaceholderExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 31,
                                                column: 17,
                                                position: 389,
                                            },
                                            ellipsis: Span {
                                                line: 31,
                                                column: 18,
                                                position: 390,
                                            },
                                            right_parenthesis: Span {
                                                line: 31,
                                                column: 21,
                                                position: 393,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 31,
                                    column: 22,
                                    position: 394,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    MethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 32,
                                                    column: 5,
                                                    position: 400,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        arrow: Span {
                                            line: 32,
                                            column: 7,
                                            position: 402,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 32,
                                                column: 9,
                                                position: 404,
                                            },
                                            value: "b",
                                        },
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 32,
                                                    column: 10,
                                                    position: 405,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 32,
                                                                column: 13,
                                                                position: 408,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 32,
                                                    column: 16,
                                                    position: 411,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 32,
                                                column: 17,
                                                position: 412,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: Some(
                                                            Span {
                                                                line: 32,
                                                                column: 18,
                                                                position: 413,
                                                            },
                                                        ),
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 32,
                                                                    column: 21,
                                                                    position: 416,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 32,
                                                column: 23,
                                                position: 418,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 32,
                                    column: 24,
                                    position: 419,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    NullsafeMethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 34,
                                                    column: 5,
                                                    position: 426,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        question_arrow: Span {
                                            line: 34,
                                            column: 7,
                                            position: 428,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 34,
                                                column: 10,
                                                position: 431,
                                            },
                                            value: "b",
                                        },
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 34,
                                                    column: 11,
                                                    position: 432,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 34,
                                                                column: 14,
                                                                position: 435,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 34,
                                                    column: 17,
                                                    position: 438,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 34,
                                                column: 18,
                                                position: 439,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 34,
                                                column: 19,
                                                position: 440,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 34,
                                    column: 20,
                                    position: 441,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    NullsafeMethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 35,
                                                    column: 5,
                                                    position: 447,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        question_arrow: Span {
                                            line: 35,
                                            column: 7,
                                            position: 449,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 35,
                                                column: 10,
                                                position: 452,
                                            },
                                            value: "b",
                                        },
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 35,
                                                    column: 11,
                                                    position: 453,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 35,
                                                                column: 14,
                                                                position: 456,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 35,
                                                    column: 17,
                                                    position: 459,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 35,
                                                column: 18,
                                                position: 460,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: None,
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 35,
                                                                    column: 19,
                                                                    position: 461,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 35,
                                                column: 21,
                                                position: 463,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 35,
                                    column: 22,
                                    position: 464,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ObjectOperation(
                                    NullsafeMethodCall {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        object: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 36,
                                                    column: 5,
                                                    position: 470,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        question_arrow: Span {
                                            line: 36,
                                            column: 7,
                                            position: 472,
                                        },
                                        method: Identifier {
                                            span: Span {
                                                line: 36,
                                                column: 10,
                                                position: 475,
                                            },
                                            value: "b",
                                        },
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 36,
                                                    column: 11,
                                                    position: 476,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 36,
                                                                column: 14,
                                                                position: 479,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 36,
                                                    column: 17,
                                                    position: 482,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 36,
                                                column: 18,
                                                position: 483,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: Some(
                                                            Span {
                                                                line: 36,
                                                                column: 19,
                                                                position: 484,
                                                            },
                                                        ),
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 36,
                                                                    column: 22,
                                                                    position: 487,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 36,
                                                column: 24,
                                                position: 489,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 36,
                                    column: 25,
                                    position: 490,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: FunctionOperation(
                                    Call {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        function: Identifier(
                                            Identifier {
                                                span: Span {
                                                    line: 38,
                                                    column: 5,
                                                    position: 497,
                                                },
                                                value: "a",
                                            },
                                        ),
                                        generics: None,
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 38,
                                                column: 6,
                                                position: 498,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 38,
                                                column: 7,
                                                position: 499,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 38,
                                    column: 8,
                                    position: 500,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: FunctionOperation(
                                    Call {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        function: Identifier(
                                            Identifier {
                                                span: Span {
                                                    line: 39,
                                                    column: 5,
                                                    position: 506,
                                                },
                                                value: "a",
                                            },
                                        ),
                                        generics: None,
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 39,
                                                column: 6,
                                                position: 507,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: None,
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 39,
                                                                    column: 7,
                                                                    position: 508,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 39,
                                                column: 9,
                                                position: 510,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 39,
                                    column: 10,
                                    position: 511,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: FunctionOperation(
                                    ClosureCreation {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        function: Identifier(
                                            Identifier {
                                                span: Span {
                                                    line: 40,
                                                    column: 5,
                                                    position: 517,
                                                },
                                                value: "a",
                                            },
                                        ),
                                        generics: None,
                                        placeholder: ArgumentPlaceholderExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 40,
                                                column: 6,
                                                position: 518,
                                            },
                                            ellipsis: Span {
                                                line: 40,
                                                column: 7,
                                                position: 519,
                                            },
                                            right_parenthesis: Span {
                                                line: 40,
                                                column: 10,
                                                position: 522,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 40,
                                    column: 11,
                                    position: 523,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: FunctionOperation(
                                    Call {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        function: Identifier(
                                            Identifier {
                                                span: Span {
                                                    line: 41,
                                                    column: 5,
                                                    position: 529,
                                                },
                                                value: "a",
                                            },
                                        ),
                                        generics: None,
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 41,
                                                column: 6,
                                                position: 530,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: Some(
                                                            Span {
                                                                line: 41,
                                                                column: 7,
                                                                position: 531,
                                                            },
                                                        ),
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 41,
                                                                    column: 10,
                                                                    position: 534,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 41,
                                                column: 12,
                                                position: 536,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 41,
                                    column: 13,
                                    position: 537,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: FunctionOperation(
                                    Call {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        function: Identifier(
                                            Identifier {
                                                span: Span {
                                                    line: 43,
                                                    column: 5,
                                                    position: 544,
                                                },
                                                value: "a",
                                            },
                                        ),
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 43,
                                                    column: 6,
                                                    position: 545,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 43,
                                                                column: 9,
                                                                position: 548,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 43,
                                                    column: 12,
                                                    position: 551,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 43,
                                                column: 13,
                                                position: 552,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 43,
                                                column: 14,
                                                position: 553,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 43,
                                    column: 15,
                                    position: 554,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: FunctionOperation(
                                    Call {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        function: Identifier(
                                            Identifier {
                                                span: Span {
                                                    line: 44,
                                                    column: 5,
                                                    position: 560,
                                                },
                                                value: "a",
                                            },
                                        ),
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 44,
                                                    column: 6,
                                                    position: 561,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 44,
                                                                column: 9,
                                                                position: 564,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 44,
                                                    column: 12,
                                                    position: 567,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 44,
                                                column: 13,
                                                position: 568,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: None,
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 44,
                                                                    column: 14,
                                                                    position: 569,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 44,
                                                column: 16,
                                                position: 571,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 44,
                                    column: 17,
                                    position: 572,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: FunctionOperation(
                                    ClosureCreation {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        function: Identifier(
                                            Identifier {
                                                span: Span {
                                                    line: 45,
                                                    column: 5,
                                                    position: 578,
                                                },
                                                value: "a",
                                            },
                                        ),
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 45,
                                                    column: 6,
                                                    position: 579,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 45,
                                                                column: 9,
                                                                position: 582,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 45,
                                                    column: 12,
                                                    position: 585,
                                                },
                                            },
                                        ),
                                        placeholder: ArgumentPlaceholderExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 45,
                                                column: 13,
                                                position: 586,
                                            },
                                            ellipsis: Span {
                                                line: 45,
                                                column: 14,
                                                position: 587,
                                            },
                                            right_parenthesis: Span {
                                                line: 45,
                                                column: 17,
                                                position: 590,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 45,
                                    column: 18,
                                    position: 591,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: FunctionOperation(
                                    Call {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        function: Identifier(
                                            Identifier {
                                                span: Span {
                                                    line: 46,
                                                    column: 5,
                                                    position: 597,
                                                },
                                                value: "a",
                                            },
                                        ),
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 46,
                                                    column: 6,
                                                    position: 598,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 46,
                                                                column: 9,
                                                                position: 601,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 46,
                                                    column: 12,
                                                    position: 604,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 46,
                                                column: 13,
                                                position: 605,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: Some(
                                                            Span {
                                                                line: 46,
                                                                column: 14,
                                                                position: 606,
                                                            },
                                                        ),
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 46,
                                                                    column: 17,
                                                                    position: 609,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 46,
                                                column: 19,
                                                position: 611,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 46,
                                    column: 20,
                                    position: 612,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ClassOperation(
                                    Initialization {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        new: Span {
                                            line: 48,
                                            column: 5,
                                            position: 619,
                                        },
                                        class: Identifier {
                                            span: Span {
                                                line: 48,
                                                column: 9,
                                                position: 623,
                                            },
                                            value: "Foo",
                                        },
                                        generics: None,
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 48,
                                                column: 12,
                                                position: 626,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 48,
                                                column: 13,
                                                position: 627,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 48,
                                    column: 14,
                                    position: 628,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ClassOperation(
                                    Initialization {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        new: Span {
                                            line: 49,
                                            column: 5,
                                            position: 634,
                                        },
                                        class: Identifier {
                                            span: Span {
                                                line: 49,
                                                column: 9,
                                                position: 638,
                                            },
                                            value: "Foo",
                                        },
                                        generics: None,
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 49,
                                                column: 12,
                                                position: 641,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: None,
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 49,
                                                                    column: 13,
                                                                    position: 642,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 49,
                                                column: 15,
                                                position: 644,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 49,
                                    column: 16,
                                    position: 645,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ClassOperation(
                                    Initialization {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        new: Span {
                                            line: 51,
                                            column: 5,
                                            position: 652,
                                        },
                                        class: Identifier {
                                            span: Span {
                                                line: 51,
                                                column: 9,
                                                position: 656,
                                            },
                                            value: "Foo",
                                        },
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 51,
                                                    column: 12,
                                                    position: 659,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 51,
                                                                column: 15,
                                                                position: 662,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 51,
                                                    column: 18,
                                                    position: 665,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 51,
                                                column: 19,
                                                position: 666,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: None,
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 51,
                                                                    column: 20,
                                                                    position: 667,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 51,
                                                column: 22,
                                                position: 669,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 51,
                                    column: 23,
                                    position: 670,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ClassOperation(
                                    Initialization {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        new: Span {
                                            line: 52,
                                            column: 5,
                                            position: 676,
                                        },
                                        class: Identifier {
                                            span: Span {
                                                line: 52,
                                                column: 9,
                                                position: 680,
                                            },
                                            value: "Foo",
                                        },
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 52,
                                                    column: 12,
                                                    position: 683,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 52,
                                                                column: 15,
                                                                position: 686,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: Span {
                                                    line: 52,
                                                    column: 18,
                                                    position: 689,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 52,
                                                column: 19,
                                                position: 690,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: Some(
                                                            Span {
                                                                line: 52,
                                                                column: 20,
                                                                position: 691,
                                                            },
                                                        ),
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 52,
                                                                    column: 23,
                                                                    position: 694,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 52,
                                                column: 25,
                                                position: 696,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 52,
                                    column: 26,
                                    position: 697,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ClassOperation(
                                    Initialization {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        new: Span {
                                            line: 54,
                                            column: 5,
                                            position: 704,
                                        },
                                        class: Identifier {
                                            span: Span {
                                                line: 54,
                                                column: 9,
                                                position: 708,
                                            },
                                            value: "Foo",
                                        },
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 54,
                                                    column: 12,
                                                    position: 711,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 54,
                                                                column: 15,
                                                                position: 714,
                                                            },
                                                        ),
                                                        String(
                                                            Span {
                                                                line: 54,
                                                                column: 20,
                                                                position: 719,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [
                                                        Span {
                                                            line: 54,
                                                            column: 18,
                                                            position: 717,
                                                        },
                                                    ],
                                                },
                                                greater_than: Span {
                                                    line: 54,
                                                    column: 26,
                                                    position: 725,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 54,
                                                column: 27,
                                                position: 726,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: None,
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 54,
                                                                    column: 28,
                                                                    position: 727,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 54,
                                                column: 30,
                                                position: 729,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 54,
                                    column: 31,
                                    position: 730,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ClassOperation(
                                    Initialization {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        new: Span {
                                            line: 55,
                                            column: 5,
                                            position: 736,
                                        },
                                        class: Identifier {
                                            span: Span {
                                                line: 55,
                                                column: 9,
                                                position: 740,
                                            },
                                            value: "Foo",
                                        },
                                        generics: Some(
                                            GenericGroupExpression {
                                                double_colon_less_than: Span {
                                                    line: 55,
                                                    column: 12,
                                                    position: 743,
                                                },
                                                types: CommaSeparated {
                                                    inner: [
                                                        Integer(
                                                            Span {
                                                                line: 55,
                                                                column: 15,
                                                                position: 746,
                                                            },
                                                        ),
                                                        String(
                                                            Span {
                                                                line: 55,
                                                                column: 20,
                                                                position: 751,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [
                                                        Span {
                                                            line: 55,
                                                            column: 18,
                                                            position: 749,
                                                        },
                                                    ],
                                                },
                                                greater_than: Span {
                                                    line: 55,
                                                    column: 26,
                                                    position: 757,
                                                },
                                            },
                                        ),
                                        arguments: ArgumentListExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            left_parenthesis: Span {
                                                line: 55,
                                                column: 27,
                                                position: 758,
                                            },
                                            arguments: CommaSeparated {
                                                inner: [
                                                    Positional {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        ellipsis: Some(
                                                            Span {
                                                                line: 55,
                                                                column: 28,
                                                                position: 759,
                                                            },
                                                        ),
                                                        value: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 55,
                                                                    column: 31,
                                                                    position: 762,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: Span {
                                                line: 55,
                                                column: 33,
                                                position: 764,
                                            },
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 55,
                                    column: 34,
                                    position: 765,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 57,
                                                    column: 5,
                                                    position: 772,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 57,
                                            column: 8,
                                            position: 775,
                                        },
                                        right: BitwiseOperation(
                                            Or {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 57,
                                                            column: 10,
                                                            position: 777,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                or: Span {
                                                    line: 57,
                                                    column: 13,
                                                    position: 780,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 57,
                                                            column: 15,
                                                            position: 782,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 57,
                                    column: 17,
                                    position: 784,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 58,
                                                    column: 5,
                                                    position: 790,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 58,
                                            column: 8,
                                            position: 793,
                                        },
                                        right: BitwiseOperation(
                                            And {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 58,
                                                            column: 10,
                                                            position: 795,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                and: Span {
                                                    line: 58,
                                                    column: 13,
                                                    position: 798,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 58,
                                                            column: 15,
                                                            position: 800,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 58,
                                    column: 17,
                                    position: 802,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 59,
                                                    column: 5,
                                                    position: 808,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 59,
                                            column: 8,
                                            position: 811,
                                        },
                                        right: BitwiseOperation(
                                            Xor {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 59,
                                                            column: 10,
                                                            position: 813,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                xor: Span {
                                                    line: 59,
                                                    column: 13,
                                                    position: 816,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 59,
                                                            column: 15,
                                                            position: 818,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 59,
                                    column: 17,
                                    position: 820,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 60,
                                                    column: 5,
                                                    position: 826,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 60,
                                            column: 8,
                                            position: 829,
                                        },
                                        right: BitwiseOperation(
                                            LeftShift {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 60,
                                                            column: 10,
                                                            position: 831,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                left_shift: Span {
                                                    line: 60,
                                                    column: 13,
                                                    position: 834,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 60,
                                                            column: 16,
                                                            position: 837,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 60,
                                    column: 18,
                                    position: 839,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 61,
                                                    column: 5,
                                                    position: 845,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 61,
                                            column: 8,
                                            position: 848,
                                        },
                                        right: BitwiseOperation(
                                            RightShift {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 61,
                                                            column: 10,
                                                            position: 850,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                right_shift: Span {
                                                    line: 61,
                                                    column: 13,
                                                    position: 853,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 61,
                                                            column: 16,
                                                            position: 856,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 61,
                                    column: 18,
                                    position: 858,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 63,
                                                    column: 5,
                                                    position: 865,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 63,
                                            column: 8,
                                            position: 868,
                                        },
                                        right: ArithmeticOperation(
                                            Exponentiation {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 63,
                                                            column: 10,
                                                            position: 870,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                pow: Span {
                                                    line: 63,
                                                    column: 13,
                                                    position: 873,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 63,
                                                            column: 16,
                                                            position: 876,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 63,
                                    column: 18,
                                    position: 878,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 64,
                                                    column: 5,
                                                    position: 884,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 64,
                                            column: 8,
                                            position: 887,
                                        },
                                        right: ArithmeticOperation(
                                            Addition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 64,
                                                            column: 10,
                                                            position: 889,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                plus: Span {
                                                    line: 64,
                                                    column: 13,
                                                    position: 892,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 64,
                                                            column: 15,
                                                            position: 894,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 64,
                                    column: 17,
                                    position: 896,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 65,
                                                    column: 5,
                                                    position: 902,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 65,
                                            column: 8,
                                            position: 905,
                                        },
                                        right: ArithmeticOperation(
                                            Subtraction {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 65,
                                                            column: 10,
                                                            position: 907,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                minus: Span {
                                                    line: 65,
                                                    column: 13,
                                                    position: 910,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 65,
                                                            column: 15,
                                                            position: 912,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 65,
                                    column: 17,
                                    position: 914,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 66,
                                                    column: 5,
                                                    position: 920,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 66,
                                            column: 8,
                                            position: 923,
                                        },
                                        right: ArithmeticOperation(
                                            Multiplication {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 66,
                                                            column: 10,
                                                            position: 925,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                asterisk: Span {
                                                    line: 66,
                                                    column: 13,
                                                    position: 928,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 66,
                                                            column: 15,
                                                            position: 930,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 66,
                                    column: 17,
                                    position: 932,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 67,
                                                    column: 5,
                                                    position: 938,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 67,
                                            column: 8,
                                            position: 941,
                                        },
                                        right: ArithmeticOperation(
                                            Division {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 67,
                                                            column: 10,
                                                            position: 943,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                slash: Span {
                                                    line: 67,
                                                    column: 13,
                                                    position: 946,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 67,
                                                            column: 15,
                                                            position: 948,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 67,
                                    column: 17,
                                    position: 950,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 68,
                                                    column: 5,
                                                    position: 956,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 68,
                                            column: 8,
                                            position: 959,
                                        },
                                        right: ArithmeticOperation(
                                            Modulo {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 68,
                                                            column: 10,
                                                            position: 961,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                percent: Span {
                                                    line: 68,
                                                    column: 13,
                                                    position: 964,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 68,
                                                            column: 15,
                                                            position: 966,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 68,
                                    column: 17,
                                    position: 968,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 69,
                                                    column: 5,
                                                    position: 974,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 69,
                                            column: 8,
                                            position: 977,
                                        },
                                        right: StringOperation(
                                            Concat {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 69,
                                                            column: 10,
                                                            position: 979,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                dot: Span {
                                                    line: 69,
                                                    column: 13,
                                                    position: 982,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 69,
                                                            column: 15,
                                                            position: 984,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 69,
                                    column: 17,
                                    position: 986,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 71,
                                                    column: 5,
                                                    position: 993,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 71,
                                            column: 8,
                                            position: 996,
                                        },
                                        right: CoalesceOperation(
                                            Coalesce {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 71,
                                                            column: 10,
                                                            position: 998,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                double_question: Span {
                                                    line: 71,
                                                    column: 13,
                                                    position: 1001,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 71,
                                                            column: 16,
                                                            position: 1004,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 71,
                                    column: 18,
                                    position: 1006,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 73,
                                                    column: 5,
                                                    position: 1013,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 73,
                                            column: 8,
                                            position: 1016,
                                        },
                                        right: LogicalOperation(
                                            And {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 73,
                                                            column: 10,
                                                            position: 1018,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                double_ampersand: Span {
                                                    line: 73,
                                                    column: 13,
                                                    position: 1021,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 73,
                                                            column: 16,
                                                            position: 1024,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 73,
                                    column: 18,
                                    position: 1026,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 74,
                                                    column: 5,
                                                    position: 1032,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 74,
                                            column: 8,
                                            position: 1035,
                                        },
                                        right: LogicalOperation(
                                            Or {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 74,
                                                            column: 10,
                                                            position: 1037,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                double_pipe: Span {
                                                    line: 74,
                                                    column: 13,
                                                    position: 1040,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 74,
                                                            column: 16,
                                                            position: 1043,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 74,
                                    column: 18,
                                    position: 1045,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 76,
                                                    column: 5,
                                                    position: 1052,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 76,
                                            column: 8,
                                            position: 1055,
                                        },
                                        right: ComparisonOperation(
                                            Equal {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 76,
                                                            column: 10,
                                                            position: 1057,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                double_equals: Span {
                                                    line: 76,
                                                    column: 13,
                                                    position: 1060,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 76,
                                                            column: 16,
                                                            position: 1063,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 76,
                                    column: 18,
                                    position: 1065,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 77,
                                                    column: 5,
                                                    position: 1071,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 77,
                                            column: 8,
                                            position: 1074,
                                        },
                                        right: ComparisonOperation(
                                            Identical {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 77,
                                                            column: 10,
                                                            position: 1076,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                triple_equals: Span {
                                                    line: 77,
                                                    column: 13,
                                                    position: 1079,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 77,
                                                            column: 17,
                                                            position: 1083,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 77,
                                    column: 19,
                                    position: 1085,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 78,
                                                    column: 5,
                                                    position: 1091,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 78,
                                            column: 8,
                                            position: 1094,
                                        },
                                        right: ComparisonOperation(
                                            NotEqual {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 78,
                                                            column: 10,
                                                            position: 1096,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                bang_equals: Span {
                                                    line: 78,
                                                    column: 13,
                                                    position: 1099,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 78,
                                                            column: 16,
                                                            position: 1102,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 78,
                                    column: 18,
                                    position: 1104,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 79,
                                                    column: 5,
                                                    position: 1110,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 79,
                                            column: 8,
                                            position: 1113,
                                        },
                                        right: ComparisonOperation(
                                            NotIdentical {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 79,
                                                            column: 10,
                                                            position: 1115,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                bang_double_equals: Span {
                                                    line: 79,
                                                    column: 13,
                                                    position: 1118,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 79,
                                                            column: 17,
                                                            position: 1122,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 79,
                                    column: 19,
                                    position: 1124,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 80,
                                                    column: 5,
                                                    position: 1130,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 80,
                                            column: 8,
                                            position: 1133,
                                        },
                                        right: ComparisonOperation(
                                            LessThanOrEqual {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 80,
                                                            column: 10,
                                                            position: 1135,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                less_than_equals: Span {
                                                    line: 80,
                                                    column: 13,
                                                    position: 1138,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 80,
                                                            column: 16,
                                                            position: 1141,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 80,
                                    column: 18,
                                    position: 1143,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 81,
                                                    column: 5,
                                                    position: 1149,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 81,
                                            column: 8,
                                            position: 1152,
                                        },
                                        right: ComparisonOperation(
                                            GreaterThanOrEqual {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 81,
                                                            column: 10,
                                                            position: 1154,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                greater_than_equals: Span {
                                                    line: 81,
                                                    column: 13,
                                                    position: 1157,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 81,
                                                            column: 16,
                                                            position: 1160,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 81,
                                    column: 18,
                                    position: 1162,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 82,
                                                    column: 5,
                                                    position: 1168,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 82,
                                            column: 8,
                                            position: 1171,
                                        },
                                        right: ComparisonOperation(
                                            LessThan {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 82,
                                                            column: 10,
                                                            position: 1173,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                less_than: Span {
                                                    line: 82,
                                                    column: 13,
                                                    position: 1176,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 82,
                                                            column: 15,
                                                            position: 1178,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 82,
                                    column: 17,
                                    position: 1180,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 83,
                                                    column: 5,
                                                    position: 1186,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 83,
                                            column: 8,
                                            position: 1189,
                                        },
                                        right: ComparisonOperation(
                                            GreaterThan {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 83,
                                                            column: 10,
                                                            position: 1191,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                greater_than: Span {
                                                    line: 83,
                                                    column: 13,
                                                    position: 1194,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 83,
                                                            column: 15,
                                                            position: 1196,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 83,
                                    column: 17,
                                    position: 1198,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 85,
                                                    column: 5,
                                                    position: 1205,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                        equals: Span {
                                            line: 85,
                                            column: 8,
                                            position: 1208,
                                        },
                                        right: ComparisonOperation(
                                            Spaceship {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 85,
                                                            column: 10,
                                                            position: 1210,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                spaceship: Span {
                                                    line: 85,
                                                    column: 13,
                                                    position: 1213,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 85,
                                                            column: 17,
                                                            position: 1217,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 85,
                                    column: 19,
                                    position: 1219,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Coalesce {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 87,
                                                    column: 5,
                                                    position: 1226,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        coalesce_equals: Span {
                                            line: 87,
                                            column: 8,
                                            position: 1229,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 87,
                                                    column: 12,
                                                    position: 1233,
                                                },
                                                name: "$b",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 87,
                                    column: 14,
                                    position: 1235,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Addition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 88,
                                                    column: 5,
                                                    position: 1241,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        plus_equals: Span {
                                            line: 88,
                                            column: 8,
                                            position: 1244,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 88,
                                                    column: 11,
                                                    position: 1247,
                                                },
                                                name: "$b",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 88,
                                    column: 13,
                                    position: 1249,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Subtraction {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 89,
                                                    column: 5,
                                                    position: 1255,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        minus_equals: Span {
                                            line: 89,
                                            column: 8,
                                            position: 1258,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 89,
                                                    column: 11,
                                                    position: 1261,
                                                },
                                                name: "$b",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 89,
                                    column: 13,
                                    position: 1263,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Multiplication {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 90,
                                                    column: 5,
                                                    position: 1269,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        asterisk_equals: Span {
                                            line: 90,
                                            column: 8,
                                            position: 1272,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 90,
                                                    column: 11,
                                                    position: 1275,
                                                },
                                                name: "$b",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 90,
                                    column: 13,
                                    position: 1277,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Division {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 91,
                                                    column: 5,
                                                    position: 1283,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        slash_equals: Span {
                                            line: 91,
                                            column: 8,
                                            position: 1286,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 91,
                                                    column: 11,
                                                    position: 1289,
                                                },
                                                name: "$b",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 91,
                                    column: 13,
                                    position: 1291,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Modulo {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 92,
                                                    column: 5,
                                                    position: 1297,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        percent_equals: Span {
                                            line: 92,
                                            column: 8,
                                            position: 1300,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 92,
                                                    column: 11,
                                                    position: 1303,
                                                },
                                                name: "$b",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 92,
                                    column: 13,
                                    position: 1305,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Concat {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 93,
                                                    column: 5,
                                                    position: 1311,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        dot_equals: Span {
                                            line: 93,
                                            column: 8,
                                            position: 1314,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 93,
                                                    column: 11,
                                                    position: 1317,
                                                },
                                                name: "$b",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 93,
                                    column: 13,
                                    position: 1319,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    BitwiseAnd {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 94,
                                                    column: 5,
                                                    position: 1325,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        ampersand_equals: Span {
                                            line: 94,
                                            column: 8,
                                            position: 1328,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 94,
                                                    column: 11,
                                                    position: 1331,
                                                },
                                                name: "$b",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 94,
                                    column: 13,
                                    position: 1333,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    BitwiseOr {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 95,
                                                    column: 5,
                                                    position: 1339,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        pipe_equals: Span {
                                            line: 95,
                                            column: 8,
                                            position: 1342,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 95,
                                                    column: 11,
                                                    position: 1345,
                                                },
                                                name: "$b",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 95,
                                    column: 13,
                                    position: 1347,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    BitwiseXor {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 96,
                                                    column: 5,
                                                    position: 1353,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        caret_equals: Span {
                                            line: 96,
                                            column: 8,
                                            position: 1356,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 96,
                                                    column: 11,
                                                    position: 1359,
                                                },
                                                name: "$b",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 96,
                                    column: 13,
                                    position: 1361,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    LeftShift {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 97,
                                                    column: 5,
                                                    position: 1367,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        left_shift_equals: Span {
                                            line: 97,
                                            column: 8,
                                            position: 1370,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 97,
                                                    column: 12,
                                                    position: 1374,
                                                },
                                                name: "$b",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 97,
                                    column: 14,
                                    position: 1376,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    RightShift {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 98,
                                                    column: 5,
                                                    position: 1382,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        right_shift_equals: Span {
                                            line: 98,
                                            column: 8,
                                            position: 1385,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 98,
                                                    column: 12,
                                                    position: 1389,
                                                },
                                                name: "$b",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 98,
                                    column: 14,
                                    position: 1391,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Exponentiation {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 99,
                                                    column: 5,
                                                    position: 1397,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        pow_equals: Span {
                                            line: 99,
                                            column: 8,
                                            position: 1400,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 99,
                                                    column: 12,
                                                    position: 1404,
                                                },
                                                name: "$b",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 99,
                                    column: 14,
                                    position: 1406,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ArithmeticOperation(
                                    PostIncrement {
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 101,
                                                    column: 5,
                                                    position: 1413,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        increment: Span {
                                            line: 101,
                                            column: 7,
                                            position: 1415,
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 101,
                                    column: 9,
                                    position: 1417,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ArithmeticOperation(
                                    PostDecrement {
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 102,
                                                    column: 5,
                                                    position: 1423,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        decrement: Span {
                                            line: 102,
                                            column: 7,
                                            position: 1425,
                                        },
                                    },
                                ),
                                semicolon: Span {
                                    line: 102,
                                    column: 9,
                                    position: 1427,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ArithmeticOperation(
                                    PreIncrement {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        increment: Span {
                                            line: 103,
                                            column: 5,
                                            position: 1433,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 103,
                                                    column: 7,
                                                    position: 1435,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 103,
                                    column: 9,
                                    position: 1437,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: ArithmeticOperation(
                                    PreDecrement {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        decrement: Span {
                                            line: 104,
                                            column: 5,
                                            position: 1443,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 104,
                                                    column: 7,
                                                    position: 1445,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 104,
                                    column: 9,
                                    position: 1447,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 106,
                                                    column: 5,
                                                    position: 1454,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        equals: Span {
                                            line: 106,
                                            column: 8,
                                            position: 1457,
                                        },
                                        right: LogicalOperation(
                                            Not {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                bang: Span {
                                                    line: 106,
                                                    column: 10,
                                                    position: 1459,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 106,
                                                            column: 11,
                                                            position: 1460,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 106,
                                    column: 13,
                                    position: 1462,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 107,
                                                    column: 5,
                                                    position: 1468,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        equals: Span {
                                            line: 107,
                                            column: 8,
                                            position: 1471,
                                        },
                                        right: BitwiseOperation(
                                            Not {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                not: Span {
                                                    line: 107,
                                                    column: 10,
                                                    position: 1473,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 107,
                                                            column: 11,
                                                            position: 1474,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 107,
                                    column: 13,
                                    position: 1476,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 108,
                                                    column: 5,
                                                    position: 1482,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        equals: Span {
                                            line: 108,
                                            column: 8,
                                            position: 1485,
                                        },
                                        right: ArithmeticOperation(
                                            Positive {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                plus: Span {
                                                    line: 108,
                                                    column: 10,
                                                    position: 1487,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 108,
                                                            column: 11,
                                                            position: 1488,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 108,
                                    column: 13,
                                    position: 1490,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 109,
                                                    column: 5,
                                                    position: 1496,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        equals: Span {
                                            line: 109,
                                            column: 8,
                                            position: 1499,
                                        },
                                        right: ArithmeticOperation(
                                            Negative {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                minus: Span {
                                                    line: 109,
                                                    column: 10,
                                                    position: 1501,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 109,
                                                            column: 11,
                                                            position: 1502,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 109,
                                    column: 13,
                                    position: 1504,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 111,
                                                    column: 5,
                                                    position: 1511,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        equals: Span {
                                            line: 111,
                                            column: 8,
                                            position: 1514,
                                        },
                                        right: Vec(
                                            VecExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                vec: Span {
                                                    line: 111,
                                                    column: 10,
                                                    position: 1516,
                                                },
                                                left_bracket: Span {
                                                    line: 111,
                                                    column: 13,
                                                    position: 1519,
                                                },
                                                members: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: Span {
                                                    line: 111,
                                                    column: 14,
                                                    position: 1520,
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 111,
                                    column: 15,
                                    position: 1521,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 112,
                                                    column: 5,
                                                    position: 1527,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        equals: Span {
                                            line: 112,
                                            column: 8,
                                            position: 1530,
                                        },
                                        right: Vec(
                                            VecExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                vec: Span {
                                                    line: 112,
                                                    column: 10,
                                                    position: 1532,
                                                },
                                                left_bracket: Span {
                                                    line: 112,
                                                    column: 13,
                                                    position: 1535,
                                                },
                                                members: CommaSeparated {
                                                    inner: [
                                                        VecExpressionItem {
                                                            value: Variable(
                                                                Variable {
                                                                    span: Span {
                                                                        line: 112,
                                                                        column: 14,
                                                                        position: 1536,
                                                                    },
                                                                    name: "$a",
                                                                },
                                                            ),
                                                        },
                                                        VecExpressionItem {
                                                            value: Variable(
                                                                Variable {
                                                                    span: Span {
                                                                        line: 112,
                                                                        column: 18,
                                                                        position: 1540,
                                                                    },
                                                                    name: "$b",
                                                                },
                                                            ),
                                                        },
                                                    ],
                                                    commas: [
                                                        Span {
                                                            line: 112,
                                                            column: 16,
                                                            position: 1538,
                                                        },
                                                    ],
                                                },
                                                right_bracket: Span {
                                                    line: 112,
                                                    column: 20,
                                                    position: 1542,
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 112,
                                    column: 21,
                                    position: 1543,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 113,
                                                    column: 5,
                                                    position: 1549,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        equals: Span {
                                            line: 113,
                                            column: 8,
                                            position: 1552,
                                        },
                                        right: Vec(
                                            VecExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                vec: Span {
                                                    line: 113,
                                                    column: 10,
                                                    position: 1554,
                                                },
                                                left_bracket: Span {
                                                    line: 113,
                                                    column: 13,
                                                    position: 1557,
                                                },
                                                members: CommaSeparated {
                                                    inner: [
                                                        VecExpressionItem {
                                                            value: Variable(
                                                                Variable {
                                                                    span: Span {
                                                                        line: 113,
                                                                        column: 14,
                                                                        position: 1558,
                                                                    },
                                                                    name: "$a",
                                                                },
                                                            ),
                                                        },
                                                        VecExpressionItem {
                                                            value: Variable(
                                                                Variable {
                                                                    span: Span {
                                                                        line: 113,
                                                                        column: 18,
                                                                        position: 1562,
                                                                    },
                                                                    name: "$b",
                                                                },
                                                            ),
                                                        },
                                                    ],
                                                    commas: [
                                                        Span {
                                                            line: 113,
                                                            column: 16,
                                                            position: 1560,
                                                        },
                                                        Span {
                                                            line: 113,
                                                            column: 20,
                                                            position: 1564,
                                                        },
                                                    ],
                                                },
                                                right_bracket: Span {
                                                    line: 113,
                                                    column: 21,
                                                    position: 1565,
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 113,
                                    column: 22,
                                    position: 1566,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 115,
                                                    column: 5,
                                                    position: 1573,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        equals: Span {
                                            line: 115,
                                            column: 8,
                                            position: 1576,
                                        },
                                        right: Dict(
                                            DictExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                dict: Span {
                                                    line: 115,
                                                    column: 10,
                                                    position: 1578,
                                                },
                                                left_bracket: Span {
                                                    line: 115,
                                                    column: 14,
                                                    position: 1582,
                                                },
                                                members: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: Span {
                                                    line: 115,
                                                    column: 15,
                                                    position: 1583,
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 115,
                                    column: 16,
                                    position: 1584,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 116,
                                                    column: 5,
                                                    position: 1590,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        equals: Span {
                                            line: 116,
                                            column: 8,
                                            position: 1593,
                                        },
                                        right: Dict(
                                            DictExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                dict: Span {
                                                    line: 116,
                                                    column: 10,
                                                    position: 1595,
                                                },
                                                left_bracket: Span {
                                                    line: 116,
                                                    column: 14,
                                                    position: 1599,
                                                },
                                                members: CommaSeparated {
                                                    inner: [
                                                        DictExpressionItem {
                                                            key: Variable(
                                                                Variable {
                                                                    span: Span {
                                                                        line: 116,
                                                                        column: 15,
                                                                        position: 1600,
                                                                    },
                                                                    name: "$a",
                                                                },
                                                            ),
                                                            double_arrow: Span {
                                                                line: 116,
                                                                column: 18,
                                                                position: 1603,
                                                            },
                                                            value: Variable(
                                                                Variable {
                                                                    span: Span {
                                                                        line: 116,
                                                                        column: 21,
                                                                        position: 1606,
                                                                    },
                                                                    name: "$b",
                                                                },
                                                            ),
                                                        },
                                                        DictExpressionItem {
                                                            key: Variable(
                                                                Variable {
                                                                    span: Span {
                                                                        line: 116,
                                                                        column: 25,
                                                                        position: 1610,
                                                                    },
                                                                    name: "$a",
                                                                },
                                                            ),
                                                            double_arrow: Span {
                                                                line: 116,
                                                                column: 28,
                                                                position: 1613,
                                                            },
                                                            value: Variable(
                                                                Variable {
                                                                    span: Span {
                                                                        line: 116,
                                                                        column: 31,
                                                                        position: 1616,
                                                                    },
                                                                    name: "$b",
                                                                },
                                                            ),
                                                        },
                                                    ],
                                                    commas: [
                                                        Span {
                                                            line: 116,
                                                            column: 23,
                                                            position: 1608,
                                                        },
                                                    ],
                                                },
                                                right_bracket: Span {
                                                    line: 116,
                                                    column: 33,
                                                    position: 1618,
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 116,
                                    column: 34,
                                    position: 1619,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 117,
                                                    column: 5,
                                                    position: 1625,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        equals: Span {
                                            line: 117,
                                            column: 8,
                                            position: 1628,
                                        },
                                        right: Dict(
                                            DictExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                dict: Span {
                                                    line: 117,
                                                    column: 10,
                                                    position: 1630,
                                                },
                                                left_bracket: Span {
                                                    line: 117,
                                                    column: 14,
                                                    position: 1634,
                                                },
                                                members: CommaSeparated {
                                                    inner: [
                                                        DictExpressionItem {
                                                            key: Variable(
                                                                Variable {
                                                                    span: Span {
                                                                        line: 117,
                                                                        column: 15,
                                                                        position: 1635,
                                                                    },
                                                                    name: "$a",
                                                                },
                                                            ),
                                                            double_arrow: Span {
                                                                line: 117,
                                                                column: 18,
                                                                position: 1638,
                                                            },
                                                            value: Variable(
                                                                Variable {
                                                                    span: Span {
                                                                        line: 117,
                                                                        column: 21,
                                                                        position: 1641,
                                                                    },
                                                                    name: "$b",
                                                                },
                                                            ),
                                                        },
                                                        DictExpressionItem {
                                                            key: Variable(
                                                                Variable {
                                                                    span: Span {
                                                                        line: 117,
                                                                        column: 25,
                                                                        position: 1645,
                                                                    },
                                                                    name: "$a",
                                                                },
                                                            ),
                                                            double_arrow: Span {
                                                                line: 117,
                                                                column: 28,
                                                                position: 1648,
                                                            },
                                                            value: Variable(
                                                                Variable {
                                                                    span: Span {
                                                                        line: 117,
                                                                        column: 31,
                                                                        position: 1651,
                                                                    },
                                                                    name: "$b",
                                                                },
                                                            ),
                                                        },
                                                    ],
                                                    commas: [
                                                        Span {
                                                            line: 117,
                                                            column: 23,
                                                            position: 1643,
                                                        },
                                                        Span {
                                                            line: 117,
                                                            column: 33,
                                                            position: 1653,
                                                        },
                                                    ],
                                                },
                                                right_bracket: Span {
                                                    line: 117,
                                                    column: 34,
                                                    position: 1654,
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 117,
                                    column: 35,
                                    position: 1655,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 119,
                                                    column: 5,
                                                    position: 1662,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        equals: Span {
                                            line: 119,
                                            column: 8,
                                            position: 1665,
                                        },
                                        right: ArrayOperation(
                                            Access {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                array: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 119,
                                                            column: 10,
                                                            position: 1667,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                left_bracket: Span {
                                                    line: 119,
                                                    column: 12,
                                                    position: 1669,
                                                },
                                                index: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 119,
                                                            column: 13,
                                                            position: 1670,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                                right_bracket: Span {
                                                    line: 119,
                                                    column: 15,
                                                    position: 1672,
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 119,
                                    column: 16,
                                    position: 1673,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 121,
                                                    column: 5,
                                                    position: 1680,
                                                },
                                                name: "$a",
                                            },
                                        ),
                                        equals: Span {
                                            line: 121,
                                            column: 8,
                                            position: 1683,
                                        },
                                        right: CoalesceOperation(
                                            Coalesce {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left: ArrayOperation(
                                                    Access {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        array: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 121,
                                                                    column: 10,
                                                                    position: 1685,
                                                                },
                                                                name: "$a",
                                                            },
                                                        ),
                                                        left_bracket: Span {
                                                            line: 121,
                                                            column: 12,
                                                            position: 1687,
                                                        },
                                                        index: Variable(
                                                            Variable {
                                                                span: Span {
                                                                    line: 121,
                                                                    column: 13,
                                                                    position: 1688,
                                                                },
                                                                name: "$b",
                                                            },
                                                        ),
                                                        right_bracket: Span {
                                                            line: 121,
                                                            column: 15,
                                                            position: 1690,
                                                        },
                                                    },
                                                ),
                                                double_question: Span {
                                                    line: 121,
                                                    column: 17,
                                                    position: 1692,
                                                },
                                                right: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 121,
                                                            column: 20,
                                                            position: 1695,
                                                        },
                                                        name: "$c",
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 121,
                                    column: 22,
                                    position: 1697,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: ArrayOperation(
                                            Access {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                array: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 123,
                                                            column: 5,
                                                            position: 1704,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                left_bracket: Span {
                                                    line: 123,
                                                    column: 7,
                                                    position: 1706,
                                                },
                                                index: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 123,
                                                            column: 8,
                                                            position: 1707,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                                right_bracket: Span {
                                                    line: 123,
                                                    column: 10,
                                                    position: 1709,
                                                },
                                            },
                                        ),
                                        equals: Span {
                                            line: 123,
                                            column: 12,
                                            position: 1711,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 123,
                                                    column: 14,
                                                    position: 1713,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 123,
                                    column: 16,
                                    position: 1715,
                                },
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Coalesce {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: ArrayOperation(
                                            Access {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                array: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 124,
                                                            column: 5,
                                                            position: 1721,
                                                        },
                                                        name: "$a",
                                                    },
                                                ),
                                                left_bracket: Span {
                                                    line: 124,
                                                    column: 7,
                                                    position: 1723,
                                                },
                                                index: Variable(
                                                    Variable {
                                                        span: Span {
                                                            line: 124,
                                                            column: 8,
                                                            position: 1724,
                                                        },
                                                        name: "$b",
                                                    },
                                                ),
                                                right_bracket: Span {
                                                    line: 124,
                                                    column: 10,
                                                    position: 1726,
                                                },
                                            },
                                        ),
                                        coalesce_equals: Span {
                                            line: 124,
                                            column: 12,
                                            position: 1728,
                                        },
                                        right: Variable(
                                            Variable {
                                                span: Span {
                                                    line: 124,
                                                    column: 16,
                                                    position: 1732,
                                                },
                                                name: "$c",
                                            },
                                        ),
                                    },
                                ),
                                semicolon: Span {
                                    line: 124,
                                    column: 18,
                                    position: 1734,
                                },
                            },
                        ),
                    ],
                    right_brace: Span {
                        line: 125,
                        column: 1,
                        position: 1736,
                    },
                },
            },
        ),
    ],
    eof: Span {
        line: 126,
        column: 1,
        position: 1738,
    },
}