[
    FullOpeningTag(
        Span {
            line: 1,
            column: 1,
            position: 0,
        },
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 3,
                    column: 1,
                    position: 7,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 3,
                        column: 11,
                        position: 17,
                    },
                    value: "True",
                },
                end: Span {
                    line: 3,
                    column: 15,
                    position: 21,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 4,
                    column: 1,
                    position: 23,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 4,
                        column: 11,
                        position: 33,
                    },
                    value: "False",
                },
                end: Span {
                    line: 4,
                    column: 16,
                    position: 38,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 5,
                    column: 1,
                    position: 40,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 5,
                        column: 11,
                        position: 50,
                    },
                    value: "Null",
                },
                end: Span {
                    line: 5,
                    column: 15,
                    position: 54,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 6,
                    column: 1,
                    position: 56,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 6,
                        column: 11,
                        position: 66,
                    },
                    value: "Int",
                },
                end: Span {
                    line: 6,
                    column: 14,
                    position: 69,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 7,
                    column: 1,
                    position: 71,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 7,
                        column: 11,
                        position: 81,
                    },
                    value: "Float",
                },
                end: Span {
                    line: 7,
                    column: 16,
                    position: 86,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 8,
                    column: 1,
                    position: 88,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 8,
                        column: 11,
                        position: 98,
                    },
                    value: "String",
                },
                end: Span {
                    line: 8,
                    column: 17,
                    position: 104,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 9,
                    column: 1,
                    position: 106,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 9,
                        column: 11,
                        position: 116,
                    },
                    value: "Array",
                },
                end: Span {
                    line: 9,
                    column: 16,
                    position: 121,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 10,
                    column: 1,
                    position: 123,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 10,
                        column: 11,
                        position: 133,
                    },
                    value: "Object",
                },
                end: Span {
                    line: 10,
                    column: 17,
                    position: 139,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 11,
                    column: 1,
                    position: 141,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 11,
                        column: 11,
                        position: 151,
                    },
                    value: "Resource",
                },
                end: Span {
                    line: 11,
                    column: 19,
                    position: 159,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 12,
                    column: 1,
                    position: 161,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 12,
                        column: 11,
                        position: 171,
                    },
                    value: "Mixed",
                },
                end: Span {
                    line: 12,
                    column: 16,
                    position: 176,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 13,
                    column: 1,
                    position: 178,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 13,
                        column: 11,
                        position: 188,
                    },
                    value: "Num",
                },
                end: Span {
                    line: 13,
                    column: 14,
                    position: 191,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 14,
                    column: 1,
                    position: 193,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 14,
                        column: 11,
                        position: 203,
                    },
                    value: "Scalar",
                },
                end: Span {
                    line: 14,
                    column: 17,
                    position: 209,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 15,
                    column: 1,
                    position: 211,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 15,
                        column: 11,
                        position: 221,
                    },
                    value: "Callable",
                },
                end: Span {
                    line: 15,
                    column: 19,
                    position: 229,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 16,
                    column: 1,
                    position: 231,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 16,
                        column: 11,
                        position: 241,
                    },
                    value: "Void",
                },
                end: Span {
                    line: 16,
                    column: 15,
                    position: 245,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 17,
                    column: 1,
                    position: 247,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 17,
                        column: 11,
                        position: 257,
                    },
                    value: "Iterable",
                },
                end: Span {
                    line: 17,
                    column: 19,
                    position: 265,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 18,
                    column: 1,
                    position: 267,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 18,
                        column: 11,
                        position: 277,
                    },
                    value: "Never",
                },
                end: Span {
                    line: 18,
                    column: 16,
                    position: 282,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 19,
                    column: 1,
                    position: 284,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 19,
                        column: 11,
                        position: 294,
                    },
                    value: "Class",
                },
                end: Span {
                    line: 19,
                    column: 16,
                    position: 299,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 20,
                    column: 1,
                    position: 301,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 20,
                        column: 11,
                        position: 311,
                    },
                    value: "Function",
                },
                end: Span {
                    line: 20,
                    column: 19,
                    position: 319,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 21,
                    column: 1,
                    position: 321,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 21,
                        column: 11,
                        position: 331,
                    },
                    value: "Fn",
                },
                end: Span {
                    line: 21,
                    column: 13,
                    position: 333,
                },
                statements: [],
            },
        ),
    ),
    Namespace(
        Unbraced(
            UnbracedNamespace {
                start: Span {
                    line: 22,
                    column: 1,
                    position: 335,
                },
                name: SimpleIdentifier {
                    span: Span {
                        line: 22,
                        column: 11,
                        position: 345,
                    },
                    value: "From",
                },
                end: Span {
                    line: 22,
                    column: 15,
                    position: 349,
                },
                statements: [
                    Function(
                        FunctionStatement {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            function: Span {
                                line: 24,
                                column: 1,
                                position: 352,
                            },
                            ampersand: None,
                            name: SimpleIdentifier {
                                span: Span {
                                    line: 24,
                                    column: 10,
                                    position: 361,
                                },
                                value: "foo",
                            },
                            parameters: FunctionParameterList {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_parenthesis: Span {
                                    line: 24,
                                    column: 13,
                                    position: 364,
                                },
                                parameters: CommaSeparated {
                                    inner: [],
                                    commas: [],
                                },
                                right_parenthesis: Span {
                                    line: 24,
                                    column: 14,
                                    position: 365,
                                },
                            },
                            return_type: Some(
                                ReturnType {
                                    colon: Span {
                                        line: 24,
                                        column: 15,
                                        position: 366,
                                    },
                                    data_type: Void(
                                        Span {
                                            line: 24,
                                            column: 17,
                                            position: 368,
                                        },
                                    ),
                                },
                            ),
                            body: FunctionBody {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_brace: Span {
                                    line: 24,
                                    column: 22,
                                    position: 373,
                                },
                                statements: [
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 25,
                                                                column: 5,
                                                                position: 379,
                                                            },
                                                            value: "\True\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 25,
                                                        column: 14,
                                                        position: 388,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 25,
                                                        column: 15,
                                                        position: 389,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 25,
                                                    column: 16,
                                                    position: 390,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 26,
                                                                column: 5,
                                                                position: 396,
                                                            },
                                                            value: "\False\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 26,
                                                        column: 15,
                                                        position: 406,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 26,
                                                        column: 16,
                                                        position: 407,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 26,
                                                    column: 17,
                                                    position: 408,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 27,
                                                                column: 5,
                                                                position: 414,
                                                            },
                                                            value: "\Null\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 27,
                                                        column: 14,
                                                        position: 423,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 27,
                                                        column: 15,
                                                        position: 424,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 27,
                                                    column: 16,
                                                    position: 425,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 28,
                                                                column: 5,
                                                                position: 431,
                                                            },
                                                            value: "\Int\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 28,
                                                        column: 13,
                                                        position: 439,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 28,
                                                        column: 14,
                                                        position: 440,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 28,
                                                    column: 15,
                                                    position: 441,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 29,
                                                                column: 5,
                                                                position: 447,
                                                            },
                                                            value: "\Float\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 29,
                                                        column: 15,
                                                        position: 457,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 29,
                                                        column: 16,
                                                        position: 458,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 29,
                                                    column: 17,
                                                    position: 459,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 30,
                                                                column: 5,
                                                                position: 465,
                                                            },
                                                            value: "\String\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 30,
                                                        column: 16,
                                                        position: 476,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 30,
                                                        column: 17,
                                                        position: 477,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 30,
                                                    column: 18,
                                                    position: 478,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 31,
                                                                column: 5,
                                                                position: 484,
                                                            },
                                                            value: "\Array\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 31,
                                                        column: 15,
                                                        position: 494,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 31,
                                                        column: 16,
                                                        position: 495,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 31,
                                                    column: 17,
                                                    position: 496,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 32,
                                                                column: 5,
                                                                position: 502,
                                                            },
                                                            value: "\Object\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 32,
                                                        column: 16,
                                                        position: 513,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 32,
                                                        column: 17,
                                                        position: 514,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 32,
                                                    column: 18,
                                                    position: 515,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 33,
                                                                column: 5,
                                                                position: 521,
                                                            },
                                                            value: "\Resource\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 33,
                                                        column: 18,
                                                        position: 534,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 33,
                                                        column: 19,
                                                        position: 535,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 33,
                                                    column: 20,
                                                    position: 536,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 34,
                                                                column: 5,
                                                                position: 542,
                                                            },
                                                            value: "\Mixed\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 34,
                                                        column: 15,
                                                        position: 552,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 34,
                                                        column: 16,
                                                        position: 553,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 34,
                                                    column: 17,
                                                    position: 554,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 35,
                                                                column: 5,
                                                                position: 560,
                                                            },
                                                            value: "\Num\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 35,
                                                        column: 13,
                                                        position: 568,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 35,
                                                        column: 14,
                                                        position: 569,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 35,
                                                    column: 15,
                                                    position: 570,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 36,
                                                                column: 5,
                                                                position: 576,
                                                            },
                                                            value: "\Scalar\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 36,
                                                        column: 16,
                                                        position: 587,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 36,
                                                        column: 17,
                                                        position: 588,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 36,
                                                    column: 18,
                                                    position: 589,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 37,
                                                                column: 5,
                                                                position: 595,
                                                            },
                                                            value: "\Callable\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 37,
                                                        column: 18,
                                                        position: 608,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 37,
                                                        column: 19,
                                                        position: 609,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 37,
                                                    column: 20,
                                                    position: 610,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 38,
                                                                column: 5,
                                                                position: 616,
                                                            },
                                                            value: "\Void\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 38,
                                                        column: 14,
                                                        position: 625,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 38,
                                                        column: 15,
                                                        position: 626,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 38,
                                                    column: 16,
                                                    position: 627,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 39,
                                                                column: 5,
                                                                position: 633,
                                                            },
                                                            value: "\Iterable\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 39,
                                                        column: 18,
                                                        position: 646,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 39,
                                                        column: 19,
                                                        position: 647,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 39,
                                                    column: 20,
                                                    position: 648,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 40,
                                                                column: 5,
                                                                position: 654,
                                                            },
                                                            value: "\Never\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 40,
                                                        column: 15,
                                                        position: 664,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 40,
                                                        column: 16,
                                                        position: 665,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 40,
                                                    column: 17,
                                                    position: 666,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 41,
                                                                column: 5,
                                                                position: 672,
                                                            },
                                                            value: "\Class\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 41,
                                                        column: 15,
                                                        position: 682,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 41,
                                                        column: 16,
                                                        position: 683,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 41,
                                                    column: 17,
                                                    position: 684,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 42,
                                                                column: 5,
                                                                position: 690,
                                                            },
                                                            value: "\Function\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 42,
                                                        column: 18,
                                                        position: 703,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 42,
                                                        column: 19,
                                                        position: 704,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 42,
                                                    column: 20,
                                                    position: 705,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 43,
                                                                column: 5,
                                                                position: 711,
                                                            },
                                                            value: "\From\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 43,
                                                        column: 14,
                                                        position: 720,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 43,
                                                        column: 15,
                                                        position: 721,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 43,
                                                    column: 16,
                                                    position: 722,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 45,
                                                                column: 5,
                                                                position: 729,
                                                            },
                                                            value: "True\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 45,
                                                        column: 13,
                                                        position: 737,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 45,
                                                        column: 14,
                                                        position: 738,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 45,
                                                    column: 15,
                                                    position: 739,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 46,
                                                                column: 5,
                                                                position: 745,
                                                            },
                                                            value: "False\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 46,
                                                        column: 14,
                                                        position: 754,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 46,
                                                        column: 15,
                                                        position: 755,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 46,
                                                    column: 16,
                                                    position: 756,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 47,
                                                                column: 5,
                                                                position: 762,
                                                            },
                                                            value: "Null\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 47,
                                                        column: 13,
                                                        position: 770,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 47,
                                                        column: 14,
                                                        position: 771,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 47,
                                                    column: 15,
                                                    position: 772,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 48,
                                                                column: 5,
                                                                position: 778,
                                                            },
                                                            value: "Int\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 48,
                                                        column: 12,
                                                        position: 785,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 48,
                                                        column: 13,
                                                        position: 786,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 48,
                                                    column: 14,
                                                    position: 787,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 49,
                                                                column: 5,
                                                                position: 793,
                                                            },
                                                            value: "Float\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 49,
                                                        column: 14,
                                                        position: 802,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 49,
                                                        column: 15,
                                                        position: 803,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 49,
                                                    column: 16,
                                                    position: 804,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 50,
                                                                column: 5,
                                                                position: 810,
                                                            },
                                                            value: "String\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 50,
                                                        column: 15,
                                                        position: 820,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 50,
                                                        column: 16,
                                                        position: 821,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 50,
                                                    column: 17,
                                                    position: 822,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 51,
                                                                column: 5,
                                                                position: 828,
                                                            },
                                                            value: "Array\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 51,
                                                        column: 14,
                                                        position: 837,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 51,
                                                        column: 15,
                                                        position: 838,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 51,
                                                    column: 16,
                                                    position: 839,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 52,
                                                                column: 5,
                                                                position: 845,
                                                            },
                                                            value: "Object\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 52,
                                                        column: 15,
                                                        position: 855,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 52,
                                                        column: 16,
                                                        position: 856,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 52,
                                                    column: 17,
                                                    position: 857,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 53,
                                                                column: 5,
                                                                position: 863,
                                                            },
                                                            value: "Resource\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 53,
                                                        column: 17,
                                                        position: 875,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 53,
                                                        column: 18,
                                                        position: 876,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 53,
                                                    column: 19,
                                                    position: 877,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 54,
                                                                column: 5,
                                                                position: 883,
                                                            },
                                                            value: "Mixed\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 54,
                                                        column: 14,
                                                        position: 892,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 54,
                                                        column: 15,
                                                        position: 893,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 54,
                                                    column: 16,
                                                    position: 894,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 55,
                                                                column: 5,
                                                                position: 900,
                                                            },
                                                            value: "Num\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 55,
                                                        column: 12,
                                                        position: 907,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 55,
                                                        column: 13,
                                                        position: 908,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 55,
                                                    column: 14,
                                                    position: 909,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 56,
                                                                column: 5,
                                                                position: 915,
                                                            },
                                                            value: "Scalar\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 56,
                                                        column: 15,
                                                        position: 925,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 56,
                                                        column: 16,
                                                        position: 926,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 56,
                                                    column: 17,
                                                    position: 927,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 57,
                                                                column: 5,
                                                                position: 933,
                                                            },
                                                            value: "Callable\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 57,
                                                        column: 17,
                                                        position: 945,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 57,
                                                        column: 18,
                                                        position: 946,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 57,
                                                    column: 19,
                                                    position: 947,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 58,
                                                                column: 5,
                                                                position: 953,
                                                            },
                                                            value: "Void\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 58,
                                                        column: 13,
                                                        position: 961,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 58,
                                                        column: 14,
                                                        position: 962,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 58,
                                                    column: 15,
                                                    position: 963,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 59,
                                                                column: 5,
                                                                position: 969,
                                                            },
                                                            value: "Iterable\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 59,
                                                        column: 17,
                                                        position: 981,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 59,
                                                        column: 18,
                                                        position: 982,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 59,
                                                    column: 19,
                                                    position: 983,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 60,
                                                                column: 5,
                                                                position: 989,
                                                            },
                                                            value: "Never\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 60,
                                                        column: 14,
                                                        position: 998,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 60,
                                                        column: 15,
                                                        position: 999,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 60,
                                                    column: 16,
                                                    position: 1000,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 61,
                                                                column: 5,
                                                                position: 1006,
                                                            },
                                                            value: "Class\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 61,
                                                        column: 14,
                                                        position: 1015,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 61,
                                                        column: 15,
                                                        position: 1016,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 61,
                                                    column: 16,
                                                    position: 1017,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 62,
                                                                column: 5,
                                                                position: 1023,
                                                            },
                                                            value: "Function\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 62,
                                                        column: 17,
                                                        position: 1035,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 62,
                                                        column: 18,
                                                        position: 1036,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 62,
                                                    column: 19,
                                                    position: 1037,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 63,
                                                                column: 5,
                                                                position: 1043,
                                                            },
                                                            value: "From\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 63,
                                                        column: 13,
                                                        position: 1051,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 63,
                                                        column: 14,
                                                        position: 1052,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 63,
                                                    column: 15,
                                                    position: 1053,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 65,
                                                                column: 5,
                                                                position: 1060,
                                                            },
                                                            value: "Foo\True\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 65,
                                                        column: 17,
                                                        position: 1072,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 65,
                                                        column: 18,
                                                        position: 1073,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 65,
                                                    column: 19,
                                                    position: 1074,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 66,
                                                                column: 5,
                                                                position: 1080,
                                                            },
                                                            value: "Foo\False\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 66,
                                                        column: 18,
                                                        position: 1093,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 66,
                                                        column: 19,
                                                        position: 1094,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 66,
                                                    column: 20,
                                                    position: 1095,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 67,
                                                                column: 5,
                                                                position: 1101,
                                                            },
                                                            value: "Foo\Null\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 67,
                                                        column: 17,
                                                        position: 1113,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 67,
                                                        column: 18,
                                                        position: 1114,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 67,
                                                    column: 19,
                                                    position: 1115,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 68,
                                                                column: 5,
                                                                position: 1121,
                                                            },
                                                            value: "Foo\Int\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 68,
                                                        column: 16,
                                                        position: 1132,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 68,
                                                        column: 17,
                                                        position: 1133,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 68,
                                                    column: 18,
                                                    position: 1134,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 69,
                                                                column: 5,
                                                                position: 1140,
                                                            },
                                                            value: "Foo\Float\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 69,
                                                        column: 18,
                                                        position: 1153,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 69,
                                                        column: 19,
                                                        position: 1154,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 69,
                                                    column: 20,
                                                    position: 1155,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 70,
                                                                column: 5,
                                                                position: 1161,
                                                            },
                                                            value: "Foo\String\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 70,
                                                        column: 19,
                                                        position: 1175,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 70,
                                                        column: 20,
                                                        position: 1176,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 70,
                                                    column: 21,
                                                    position: 1177,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 71,
                                                                column: 5,
                                                                position: 1183,
                                                            },
                                                            value: "Foo\Array\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 71,
                                                        column: 18,
                                                        position: 1196,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 71,
                                                        column: 19,
                                                        position: 1197,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 71,
                                                    column: 20,
                                                    position: 1198,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 72,
                                                                column: 5,
                                                                position: 1204,
                                                            },
                                                            value: "Foo\Object\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 72,
                                                        column: 19,
                                                        position: 1218,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 72,
                                                        column: 20,
                                                        position: 1219,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 72,
                                                    column: 21,
                                                    position: 1220,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 73,
                                                                column: 5,
                                                                position: 1226,
                                                            },
                                                            value: "Foo\Resource\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 73,
                                                        column: 21,
                                                        position: 1242,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 73,
                                                        column: 22,
                                                        position: 1243,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 73,
                                                    column: 23,
                                                    position: 1244,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 74,
                                                                column: 5,
                                                                position: 1250,
                                                            },
                                                            value: "Foo\Mixed\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 74,
                                                        column: 18,
                                                        position: 1263,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 74,
                                                        column: 19,
                                                        position: 1264,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 74,
                                                    column: 20,
                                                    position: 1265,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 75,
                                                                column: 5,
                                                                position: 1271,
                                                            },
                                                            value: "Foo\Num\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 75,
                                                        column: 16,
                                                        position: 1282,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 75,
                                                        column: 17,
                                                        position: 1283,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 75,
                                                    column: 18,
                                                    position: 1284,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 76,
                                                                column: 5,
                                                                position: 1290,
                                                            },
                                                            value: "Foo\Scalar\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 76,
                                                        column: 19,
                                                        position: 1304,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 76,
                                                        column: 20,
                                                        position: 1305,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 76,
                                                    column: 21,
                                                    position: 1306,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 77,
                                                                column: 5,
                                                                position: 1312,
                                                            },
                                                            value: "Foo\Callable\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 77,
                                                        column: 21,
                                                        position: 1328,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 77,
                                                        column: 22,
                                                        position: 1329,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 77,
                                                    column: 23,
                                                    position: 1330,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 78,
                                                                column: 5,
                                                                position: 1336,
                                                            },
                                                            value: "Foo\Void\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 78,
                                                        column: 17,
                                                        position: 1348,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 78,
                                                        column: 18,
                                                        position: 1349,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 78,
                                                    column: 19,
                                                    position: 1350,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 79,
                                                                column: 5,
                                                                position: 1356,
                                                            },
                                                            value: "Foo\Iterable\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 79,
                                                        column: 21,
                                                        position: 1372,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 79,
                                                        column: 22,
                                                        position: 1373,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 79,
                                                    column: 23,
                                                    position: 1374,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 80,
                                                                column: 5,
                                                                position: 1380,
                                                            },
                                                            value: "Foo\Never\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 80,
                                                        column: 18,
                                                        position: 1393,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 80,
                                                        column: 19,
                                                        position: 1394,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 80,
                                                    column: 20,
                                                    position: 1395,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 81,
                                                                column: 5,
                                                                position: 1401,
                                                            },
                                                            value: "Foo\Class\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 81,
                                                        column: 18,
                                                        position: 1414,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 81,
                                                        column: 19,
                                                        position: 1415,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 81,
                                                    column: 20,
                                                    position: 1416,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 82,
                                                                column: 5,
                                                                position: 1422,
                                                            },
                                                            value: "Foo\Function\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 82,
                                                        column: 21,
                                                        position: 1438,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 82,
                                                        column: 22,
                                                        position: 1439,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 82,
                                                    column: 23,
                                                    position: 1440,
                                                },
                                            ),
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            expression: FunctionCall {
                                                target: Identifier(
                                                    SimpleIdentifier(
                                                        SimpleIdentifier {
                                                            span: Span {
                                                                line: 83,
                                                                column: 5,
                                                                position: 1446,
                                                            },
                                                            value: "Foo\From\foo",
                                                        },
                                                    ),
                                                ),
                                                arguments: ArgumentList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 83,
                                                        column: 17,
                                                        position: 1458,
                                                    },
                                                    arguments: [],
                                                    right_parenthesis: Span {
                                                        line: 83,
                                                        column: 18,
                                                        position: 1459,
                                                    },
                                                },
                                            },
                                            ending: Semicolon(
                                                Span {
                                                    line: 83,
                                                    column: 19,
                                                    position: 1460,
                                                },
                                            ),
                                        },
                                    ),
                                ],
                                right_brace: Span {
                                    line: 84,
                                    column: 1,
                                    position: 1462,
                                },
                            },
                        },
                    ),
                ],
            },
        ),
    ),
]
