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