DefinitionTree {
    definitions: [
        Interface(
            InterfaceDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                interface: 0,
                name: Identifier {
                    position: 10,
                    value: "ObjectCollection",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 26,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Covariance(
                                        27,
                                    ),
                                    name: Identifier {
                                        position: 28,
                                        value: "T",
                                    },
                                    constraint: SubType(
                                        30,
                                        Object(
                                            33,
                                        ),
                                    ),
                                },
                            ],
                            commas: [],
                        },
                        greater_than: 39,
                    },
                ),
                extends: Some(
                    InterfaceDefinitionExtends {
                        extends: 41,
                        parents: CommaSeparated {
                            inner: [
                                TemplatedIdentifier {
                                    name: Identifier {
                                        position: 49,
                                        value: "IteratorAggregate",
                                    },
                                    templates: Some(
                                        TypeTemplateGroupDefinition {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            less_than: 66,
                                            members: CommaSeparated {
                                                inner: [
                                                    Integer(
                                                        67,
                                                    ),
                                                    Identifier(
                                                        TemplatedIdentifier {
                                                            name: Identifier {
                                                                position: 72,
                                                                value: "T",
                                                            },
                                                            templates: None,
                                                        },
                                                    ),
                                                ],
                                                commas: [
                                                    70,
                                                ],
                                            },
                                            greater_than: 73,
                                        },
                                    ),
                                },
                            ],
                            commas: [],
                        },
                    },
                ),
                body: InterfaceDefinitionBody {
                    left_brace: 75,
                    members: [],
                    right_brace: 76,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 79,
                name: Identifier {
                    position: 88,
                    value: "foo",
                },
                templates: None,
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 91,
                    parameters: CommaSeparated {
                        inner: [],
                        commas: [],
                    },
                    right_parenthesis: 92,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 93,
                    type_definition: Vec(
                        95,
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 98,
                            members: CommaSeparated {
                                inner: [
                                    Integer(
                                        99,
                                    ),
                                ],
                                commas: [],
                            },
                            greater_than: 102,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 104,
                    statements: [
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: 110,
                                expression: Some(
                                    Vec(
                                        VecExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            vec: 117,
                                            left_bracket: 120,
                                            members: CommaSeparated {
                                                inner: [
                                                    VecExpressionItem {
                                                        value: Literal(
                                                            Integer(
                                                                LiteralInteger {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    value: "1",
                                                                    position: 121,
                                                                },
                                                            ),
                                                        ),
                                                    },
                                                    VecExpressionItem {
                                                        value: Literal(
                                                            Integer(
                                                                LiteralInteger {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    value: "2",
                                                                    position: 124,
                                                                },
                                                            ),
                                                        ),
                                                    },
                                                    VecExpressionItem {
                                                        value: Literal(
                                                            Integer(
                                                                LiteralInteger {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    value: "3",
                                                                    position: 127,
                                                                },
                                                            ),
                                                        ),
                                                    },
                                                ],
                                                commas: [
                                                    122,
                                                    125,
                                                ],
                                            },
                                            right_bracket: 128,
                                        },
                                    ),
                                ),
                                semicolon: 129,
                            },
                        ),
                    ],
                    right_brace: 131,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 134,
                name: Identifier {
                    position: 143,
                    value: "bar",
                },
                templates: None,
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 146,
                    parameters: CommaSeparated {
                        inner: [],
                        commas: [],
                    },
                    right_parenthesis: 147,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 148,
                    type_definition: Dict(
                        150,
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 154,
                            members: CommaSeparated {
                                inner: [
                                    String(
                                        155,
                                    ),
                                    Integer(
                                        163,
                                    ),
                                ],
                                commas: [
                                    161,
                                ],
                            },
                            greater_than: 166,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 168,
                    statements: [
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: 174,
                                expression: Some(
                                    Dict(
                                        DictExpression {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            dict: 181,
                                            left_bracket: 185,
                                            members: CommaSeparated {
                                                inner: [
                                                    DictExpressionItem {
                                                        key: Literal(
                                                            String(
                                                                LiteralString {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    value: "'a'",
                                                                    position: 186,
                                                                },
                                                            ),
                                                        ),
                                                        double_arrow: 190,
                                                        value: Literal(
                                                            Integer(
                                                                LiteralInteger {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    value: "1",
                                                                    position: 193,
                                                                },
                                                            ),
                                                        ),
                                                    },
                                                    DictExpressionItem {
                                                        key: Literal(
                                                            String(
                                                                LiteralString {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    value: "'b'",
                                                                    position: 196,
                                                                },
                                                            ),
                                                        ),
                                                        double_arrow: 200,
                                                        value: Literal(
                                                            Integer(
                                                                LiteralInteger {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    value: "2",
                                                                    position: 203,
                                                                },
                                                            ),
                                                        ),
                                                    },
                                                    DictExpressionItem {
                                                        key: Literal(
                                                            String(
                                                                LiteralString {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    value: "'c'",
                                                                    position: 206,
                                                                },
                                                            ),
                                                        ),
                                                        double_arrow: 210,
                                                        value: Literal(
                                                            Integer(
                                                                LiteralInteger {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    value: "3",
                                                                    position: 213,
                                                                },
                                                            ),
                                                        ),
                                                    },
                                                ],
                                                commas: [
                                                    194,
                                                    204,
                                                ],
                                            },
                                            right_bracket: 214,
                                        },
                                    ),
                                ),
                                semicolon: 215,
                            },
                        ),
                    ],
                    right_brace: 217,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 220,
                name: Identifier {
                    position: 229,
                    value: "baz",
                },
                templates: None,
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 232,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Boolean(
                                    233,
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 238,
                                    name: "$a",
                                },
                                default: None,
                            },
                        ],
                        commas: [],
                    },
                    right_parenthesis: 240,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 241,
                    type_definition: Iterable(
                        243,
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 251,
                            members: CommaSeparated {
                                inner: [
                                    Integer(
                                        252,
                                    ),
                                    Integer(
                                        257,
                                    ),
                                ],
                                commas: [
                                    255,
                                ],
                            },
                            greater_than: 260,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 262,
                    statements: [
                        If(
                            IfStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                if: 268,
                                condition: Variable(
                                    Variable {
                                        position: 271,
                                        name: "$a",
                                    },
                                ),
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 274,
                                    statements: [
                                        Return(
                                            Explicit {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                return: 284,
                                                expression: Some(
                                                    Vec(
                                                        VecExpression {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            vec: 291,
                                                            left_bracket: 294,
                                                            members: CommaSeparated {
                                                                inner: [
                                                                    VecExpressionItem {
                                                                        value: Literal(
                                                                            Integer(
                                                                                LiteralInteger {
                                                                                    comments: CommentGroup {
                                                                                        comments: [],
                                                                                    },
                                                                                    value: "1",
                                                                                    position: 295,
                                                                                },
                                                                            ),
                                                                        ),
                                                                    },
                                                                    VecExpressionItem {
                                                                        value: Literal(
                                                                            Integer(
                                                                                LiteralInteger {
                                                                                    comments: CommentGroup {
                                                                                        comments: [],
                                                                                    },
                                                                                    value: "2",
                                                                                    position: 298,
                                                                                },
                                                                            ),
                                                                        ),
                                                                    },
                                                                    VecExpressionItem {
                                                                        value: Literal(
                                                                            Integer(
                                                                                LiteralInteger {
                                                                                    comments: CommentGroup {
                                                                                        comments: [],
                                                                                    },
                                                                                    value: "3",
                                                                                    position: 301,
                                                                                },
                                                                            ),
                                                                        ),
                                                                    },
                                                                ],
                                                                commas: [
                                                                    296,
                                                                    299,
                                                                ],
                                                            },
                                                            right_bracket: 302,
                                                        },
                                                    ),
                                                ),
                                                semicolon: 303,
                                            },
                                        ),
                                    ],
                                    right_brace: 309,
                                },
                                elseifs: [],
                                else: Some(
                                    IfStatementElse {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        else: 311,
                                        block: Block(
                                            BlockStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left_brace: 316,
                                                statements: [
                                                    Return(
                                                        Explicit {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            return: 326,
                                                            expression: Some(
                                                                Dict(
                                                                    DictExpression {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        dict: 333,
                                                                        left_bracket: 337,
                                                                        members: CommaSeparated {
                                                                            inner: [
                                                                                DictExpressionItem {
                                                                                    key: Literal(
                                                                                        Integer(
                                                                                            LiteralInteger {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: "1",
                                                                                                position: 338,
                                                                                            },
                                                                                        ),
                                                                                    ),
                                                                                    double_arrow: 340,
                                                                                    value: Literal(
                                                                                        Integer(
                                                                                            LiteralInteger {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: "1",
                                                                                                position: 343,
                                                                                            },
                                                                                        ),
                                                                                    ),
                                                                                },
                                                                                DictExpressionItem {
                                                                                    key: Literal(
                                                                                        Integer(
                                                                                            LiteralInteger {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: "2",
                                                                                                position: 346,
                                                                                            },
                                                                                        ),
                                                                                    ),
                                                                                    double_arrow: 348,
                                                                                    value: Literal(
                                                                                        Integer(
                                                                                            LiteralInteger {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: "2",
                                                                                                position: 351,
                                                                                            },
                                                                                        ),
                                                                                    ),
                                                                                },
                                                                                DictExpressionItem {
                                                                                    key: Literal(
                                                                                        Integer(
                                                                                            LiteralInteger {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: "3",
                                                                                                position: 354,
                                                                                            },
                                                                                        ),
                                                                                    ),
                                                                                    double_arrow: 356,
                                                                                    value: Literal(
                                                                                        Integer(
                                                                                            LiteralInteger {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: "3",
                                                                                                position: 359,
                                                                                            },
                                                                                        ),
                                                                                    ),
                                                                                },
                                                                            ],
                                                                            commas: [
                                                                                344,
                                                                                352,
                                                                            ],
                                                                        },
                                                                        right_bracket: 360,
                                                                    },
                                                                ),
                                                            ),
                                                            semicolon: 361,
                                                        },
                                                    ),
                                                ],
                                                right_brace: 367,
                                            },
                                        ),
                                    },
                                ),
                            },
                        ),
                    ],
                    right_brace: 369,
                },
            },
        ),
        Class(
            ClassDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                modifiers: ClassModifierDefinitionGroup {
                    modifiers: [
                        Final(
                            372,
                        ),
                    ],
                },
                class: 378,
                name: Identifier {
                    position: 384,
                    value: "Box",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 387,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 388,
                                        value: "T",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [],
                        },
                        greater_than: 389,
                    },
                ),
                extends: None,
                implements: None,
                body: ClassDefinitionBody {
                    left_brace: 391,
                    members: [
                        ConcreteConstructor(
                            ConcreteConstructorDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                modifiers: MethodModifierDefinitionGroup {
                                    modifiers: [
                                        Public(
                                            397,
                                        ),
                                    ],
                                },
                                function: 404,
                                name: Identifier {
                                    position: 413,
                                    value: "__construct",
                                },
                                parameters: ConstructorParameterListDefinition {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_parenthesis: 424,
                                    parameters: CommaSeparated {
                                        inner: [
                                            ConstructorParameterDefinition {
                                                attributes: [],
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                modifiers: PromotedPropertyModifierDefinitionGroup {
                                                    modifiers: [
                                                        Public(
                                                            425,
                                                        ),
                                                    ],
                                                },
                                                type_definition: Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 432,
                                                            value: "T",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                ellipsis: None,
                                                variable: Variable {
                                                    position: 434,
                                                    name: "$value",
                                                },
                                                default: None,
                                            },
                                        ],
                                        commas: [],
                                    },
                                    right_parenthesis: 440,
                                },
                                body: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 442,
                                    statements: [],
                                    right_brace: 443,
                                },
                            },
                        ),
                    ],
                    right_brace: 445,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 448,
                name: Identifier {
                    position: 457,
                    value: "box",
                },
                templates: None,
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 460,
                    parameters: CommaSeparated {
                        inner: [],
                        commas: [],
                    },
                    right_parenthesis: 461,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 462,
                    type_definition: Identifier(
                        TemplatedIdentifier {
                            name: Identifier {
                                position: 464,
                                value: "Box",
                            },
                            templates: Some(
                                TypeTemplateGroupDefinition {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    less_than: 467,
                                    members: CommaSeparated {
                                        inner: [
                                            Vec(
                                                468,
                                                TypeTemplateGroupDefinition {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    less_than: 471,
                                                    members: CommaSeparated {
                                                        inner: [
                                                            Integer(
                                                                472,
                                                            ),
                                                        ],
                                                        commas: [],
                                                    },
                                                    greater_than: 475,
                                                },
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    greater_than: 476,
                                },
                            ),
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 478,
                    statements: [
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: 484,
                                expression: Some(
                                    ClassOperation(
                                        Initialization {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            new: 491,
                                            class: Identifier {
                                                position: 495,
                                                value: "Box",
                                            },
                                            generics: None,
                                            arguments: ArgumentListExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left_parenthesis: 498,
                                                arguments: CommaSeparated {
                                                    inner: [
                                                        Positional {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            ellipsis: None,
                                                            value: Vec(
                                                                VecExpression {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    vec: 499,
                                                                    left_bracket: 502,
                                                                    members: CommaSeparated {
                                                                        inner: [
                                                                            VecExpressionItem {
                                                                                value: Literal(
                                                                                    Integer(
                                                                                        LiteralInteger {
                                                                                            comments: CommentGroup {
                                                                                                comments: [],
                                                                                            },
                                                                                            value: "1",
                                                                                            position: 503,
                                                                                        },
                                                                                    ),
                                                                                ),
                                                                            },
                                                                            VecExpressionItem {
                                                                                value: Literal(
                                                                                    Integer(
                                                                                        LiteralInteger {
                                                                                            comments: CommentGroup {
                                                                                                comments: [],
                                                                                            },
                                                                                            value: "2",
                                                                                            position: 506,
                                                                                        },
                                                                                    ),
                                                                                ),
                                                                            },
                                                                            VecExpressionItem {
                                                                                value: Literal(
                                                                                    Integer(
                                                                                        LiteralInteger {
                                                                                            comments: CommentGroup {
                                                                                                comments: [],
                                                                                            },
                                                                                            value: "3",
                                                                                            position: 509,
                                                                                        },
                                                                                    ),
                                                                                ),
                                                                            },
                                                                        ],
                                                                        commas: [
                                                                            504,
                                                                            507,
                                                                        ],
                                                                    },
                                                                    right_bracket: 510,
                                                                },
                                                            ),
                                                        },
                                                    ],
                                                    commas: [],
                                                },
                                                right_parenthesis: 511,
                                            },
                                        },
                                    ),
                                ),
                                semicolon: 512,
                            },
                        ),
                    ],
                    right_brace: 514,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 517,
                name: Identifier {
                    position: 526,
                    value: "unbox",
                },
                templates: None,
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 531,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 532,
                                            value: "Box",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 535,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Vec(
                                                            536,
                                                            TypeTemplateGroupDefinition {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                less_than: 539,
                                                                members: CommaSeparated {
                                                                    inner: [
                                                                        Integer(
                                                                            540,
                                                                        ),
                                                                    ],
                                                                    commas: [],
                                                                },
                                                                greater_than: 543,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: 544,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 546,
                                    name: "$box",
                                },
                                default: None,
                            },
                        ],
                        commas: [],
                    },
                    right_parenthesis: 550,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 551,
                    type_definition: Vec(
                        553,
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 556,
                            members: CommaSeparated {
                                inner: [
                                    Integer(
                                        557,
                                    ),
                                ],
                                commas: [],
                            },
                            greater_than: 560,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 562,
                    statements: [
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: 568,
                                expression: Some(
                                    ObjectOperation(
                                        PropertyFetch {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            object: Variable(
                                                Variable {
                                                    position: 575,
                                                    name: "$box",
                                                },
                                            ),
                                            arrow: 579,
                                            property: Identifier {
                                                position: 581,
                                                value: "value",
                                            },
                                        },
                                    ),
                                ),
                                semicolon: 586,
                            },
                        ),
                    ],
                    right_brace: 588,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 591,
                name: Identifier {
                    position: 600,
                    value: "foo",
                },
                templates: None,
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 603,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Boolean(
                                    604,
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 609,
                                    name: "$a",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Boolean(
                                    613,
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 618,
                                    name: "$b",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            611,
                        ],
                    },
                    right_parenthesis: 620,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 621,
                    type_definition: Union(
                        [
                            Vec(
                                623,
                                TypeTemplateGroupDefinition {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    less_than: 626,
                                    members: CommaSeparated {
                                        inner: [
                                            Integer(
                                                627,
                                            ),
                                        ],
                                        commas: [],
                                    },
                                    greater_than: 630,
                                },
                            ),
                            Dict(
                                632,
                                TypeTemplateGroupDefinition {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    less_than: 636,
                                    members: CommaSeparated {
                                        inner: [
                                            String(
                                                637,
                                            ),
                                            Integer(
                                                645,
                                            ),
                                        ],
                                        commas: [
                                            643,
                                        ],
                                    },
                                    greater_than: 648,
                                },
                            ),
                            Identifier(
                                TemplatedIdentifier {
                                    name: Identifier {
                                        position: 650,
                                        value: "Box",
                                    },
                                    templates: Some(
                                        TypeTemplateGroupDefinition {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            less_than: 653,
                                            members: CommaSeparated {
                                                inner: [
                                                    Vec(
                                                        654,
                                                        TypeTemplateGroupDefinition {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            less_than: 657,
                                                            members: CommaSeparated {
                                                                inner: [
                                                                    Integer(
                                                                        658,
                                                                    ),
                                                                ],
                                                                commas: [],
                                                            },
                                                            greater_than: 661,
                                                        },
                                                    ),
                                                ],
                                                commas: [],
                                            },
                                            greater_than: 662,
                                        },
                                    ),
                                },
                            ),
                        ],
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 664,
                    statements: [
                        If(
                            IfStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                if: 670,
                                condition: Variable(
                                    Variable {
                                        position: 673,
                                        name: "$a",
                                    },
                                ),
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 676,
                                    statements: [
                                        Return(
                                            Explicit {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                return: 686,
                                                expression: Some(
                                                    Vec(
                                                        VecExpression {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            vec: 693,
                                                            left_bracket: 696,
                                                            members: CommaSeparated {
                                                                inner: [
                                                                    VecExpressionItem {
                                                                        value: Literal(
                                                                            Integer(
                                                                                LiteralInteger {
                                                                                    comments: CommentGroup {
                                                                                        comments: [],
                                                                                    },
                                                                                    value: "1",
                                                                                    position: 697,
                                                                                },
                                                                            ),
                                                                        ),
                                                                    },
                                                                    VecExpressionItem {
                                                                        value: Literal(
                                                                            Integer(
                                                                                LiteralInteger {
                                                                                    comments: CommentGroup {
                                                                                        comments: [],
                                                                                    },
                                                                                    value: "2",
                                                                                    position: 700,
                                                                                },
                                                                            ),
                                                                        ),
                                                                    },
                                                                    VecExpressionItem {
                                                                        value: Literal(
                                                                            Integer(
                                                                                LiteralInteger {
                                                                                    comments: CommentGroup {
                                                                                        comments: [],
                                                                                    },
                                                                                    value: "3",
                                                                                    position: 703,
                                                                                },
                                                                            ),
                                                                        ),
                                                                    },
                                                                ],
                                                                commas: [
                                                                    698,
                                                                    701,
                                                                ],
                                                            },
                                                            right_bracket: 704,
                                                        },
                                                    ),
                                                ),
                                                semicolon: 705,
                                            },
                                        ),
                                    ],
                                    right_brace: 711,
                                },
                                elseifs: [],
                                else: Some(
                                    IfStatementElse {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        else: 713,
                                        block: If(
                                            IfStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                if: 718,
                                                condition: Variable(
                                                    Variable {
                                                        position: 721,
                                                        name: "$b",
                                                    },
                                                ),
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: 724,
                                                    statements: [
                                                        Return(
                                                            Explicit {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                return: 734,
                                                                expression: Some(
                                                                    Dict(
                                                                        DictExpression {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            dict: 741,
                                                                            left_bracket: 745,
                                                                            members: CommaSeparated {
                                                                                inner: [
                                                                                    DictExpressionItem {
                                                                                        key: Literal(
                                                                                            String(
                                                                                                LiteralString {
                                                                                                    comments: CommentGroup {
                                                                                                        comments: [],
                                                                                                    },
                                                                                                    value: "'a'",
                                                                                                    position: 746,
                                                                                                },
                                                                                            ),
                                                                                        ),
                                                                                        double_arrow: 750,
                                                                                        value: Literal(
                                                                                            Integer(
                                                                                                LiteralInteger {
                                                                                                    comments: CommentGroup {
                                                                                                        comments: [],
                                                                                                    },
                                                                                                    value: "1",
                                                                                                    position: 753,
                                                                                                },
                                                                                            ),
                                                                                        ),
                                                                                    },
                                                                                    DictExpressionItem {
                                                                                        key: Literal(
                                                                                            String(
                                                                                                LiteralString {
                                                                                                    comments: CommentGroup {
                                                                                                        comments: [],
                                                                                                    },
                                                                                                    value: "'b'",
                                                                                                    position: 756,
                                                                                                },
                                                                                            ),
                                                                                        ),
                                                                                        double_arrow: 760,
                                                                                        value: Literal(
                                                                                            Integer(
                                                                                                LiteralInteger {
                                                                                                    comments: CommentGroup {
                                                                                                        comments: [],
                                                                                                    },
                                                                                                    value: "2",
                                                                                                    position: 763,
                                                                                                },
                                                                                            ),
                                                                                        ),
                                                                                    },
                                                                                    DictExpressionItem {
                                                                                        key: Literal(
                                                                                            String(
                                                                                                LiteralString {
                                                                                                    comments: CommentGroup {
                                                                                                        comments: [],
                                                                                                    },
                                                                                                    value: "'c'",
                                                                                                    position: 766,
                                                                                                },
                                                                                            ),
                                                                                        ),
                                                                                        double_arrow: 770,
                                                                                        value: Literal(
                                                                                            Integer(
                                                                                                LiteralInteger {
                                                                                                    comments: CommentGroup {
                                                                                                        comments: [],
                                                                                                    },
                                                                                                    value: "3",
                                                                                                    position: 773,
                                                                                                },
                                                                                            ),
                                                                                        ),
                                                                                    },
                                                                                ],
                                                                                commas: [
                                                                                    754,
                                                                                    764,
                                                                                ],
                                                                            },
                                                                            right_bracket: 774,
                                                                        },
                                                                    ),
                                                                ),
                                                                semicolon: 775,
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: 781,
                                                },
                                                elseifs: [],
                                                else: Some(
                                                    IfStatementElse {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        else: 783,
                                                        block: Block(
                                                            BlockStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_brace: 788,
                                                                statements: [
                                                                    Return(
                                                                        Explicit {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            return: 798,
                                                                            expression: Some(
                                                                                ClassOperation(
                                                                                    Initialization {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        new: 805,
                                                                                        class: Identifier {
                                                                                            position: 809,
                                                                                            value: "Box",
                                                                                        },
                                                                                        generics: None,
                                                                                        arguments: ArgumentListExpression {
                                                                                            comments: CommentGroup {
                                                                                                comments: [],
                                                                                            },
                                                                                            left_parenthesis: 812,
                                                                                            arguments: CommaSeparated {
                                                                                                inner: [
                                                                                                    Positional {
                                                                                                        comments: CommentGroup {
                                                                                                            comments: [],
                                                                                                        },
                                                                                                        ellipsis: None,
                                                                                                        value: Vec(
                                                                                                            VecExpression {
                                                                                                                comments: CommentGroup {
                                                                                                                    comments: [],
                                                                                                                },
                                                                                                                vec: 813,
                                                                                                                left_bracket: 816,
                                                                                                                members: CommaSeparated {
                                                                                                                    inner: [
                                                                                                                        VecExpressionItem {
                                                                                                                            value: Literal(
                                                                                                                                Integer(
                                                                                                                                    LiteralInteger {
                                                                                                                                        comments: CommentGroup {
                                                                                                                                            comments: [],
                                                                                                                                        },
                                                                                                                                        value: "1",
                                                                                                                                        position: 817,
                                                                                                                                    },
                                                                                                                                ),
                                                                                                                            ),
                                                                                                                        },
                                                                                                                        VecExpressionItem {
                                                                                                                            value: Literal(
                                                                                                                                Integer(
                                                                                                                                    LiteralInteger {
                                                                                                                                        comments: CommentGroup {
                                                                                                                                            comments: [],
                                                                                                                                        },
                                                                                                                                        value: "2",
                                                                                                                                        position: 820,
                                                                                                                                    },
                                                                                                                                ),
                                                                                                                            ),
                                                                                                                        },
                                                                                                                        VecExpressionItem {
                                                                                                                            value: Literal(
                                                                                                                                Integer(
                                                                                                                                    LiteralInteger {
                                                                                                                                        comments: CommentGroup {
                                                                                                                                            comments: [],
                                                                                                                                        },
                                                                                                                                        value: "3",
                                                                                                                                        position: 823,
                                                                                                                                    },
                                                                                                                                ),
                                                                                                                            ),
                                                                                                                        },
                                                                                                                    ],
                                                                                                                    commas: [
                                                                                                                        818,
                                                                                                                        821,
                                                                                                                    ],
                                                                                                                },
                                                                                                                right_bracket: 824,
                                                                                                            },
                                                                                                        ),
                                                                                                    },
                                                                                                ],
                                                                                                commas: [],
                                                                                            },
                                                                                            right_parenthesis: 825,
                                                                                        },
                                                                                    },
                                                                                ),
                                                                            ),
                                                                            semicolon: 826,
                                                                        },
                                                                    ),
                                                                ],
                                                                right_brace: 832,
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            },
                        ),
                    ],
                    right_brace: 834,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 837,
                name: Identifier {
                    position: 846,
                    value: "into_vec",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 854,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 855,
                                        value: "T",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [],
                        },
                        greater_than: 856,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 857,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Iterable(
                                    858,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 866,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 867,
                                                            value: "_",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 870,
                                                            value: "Tv",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                868,
                                            ],
                                        },
                                        greater_than: 872,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 874,
                                    name: "$iterable",
                                },
                                default: None,
                            },
                        ],
                        commas: [],
                    },
                    right_parenthesis: 883,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 884,
                    type_definition: Vec(
                        886,
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 889,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 890,
                                                value: "T",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [],
                            },
                            greater_than: 891,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 893,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 899,
                                                name: "$vec",
                                            },
                                        ),
                                        equals: 904,
                                        right: Vec(
                                            VecExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                vec: 906,
                                                left_bracket: 909,
                                                members: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 910,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 911,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: 917,
                                iterator: Value {
                                    expression: Variable(
                                        Variable {
                                            position: 925,
                                            name: "$iterable",
                                        },
                                    ),
                                    as: 935,
                                    value: Variable {
                                        position: 938,
                                        name: "$value",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 945,
                                    statements: [
                                        Expression(
                                            ExpressionStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                expression: AssignmentOperation(
                                                    Assignment {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        left: ArrayOperation(
                                                            Push {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                array: Variable(
                                                                    Variable {
                                                                        position: 955,
                                                                        name: "$vec",
                                                                    },
                                                                ),
                                                                left_bracket: 959,
                                                                right_bracket: 960,
                                                            },
                                                        ),
                                                        equals: 962,
                                                        right: Variable(
                                                            Variable {
                                                                position: 964,
                                                                name: "$value",
                                                            },
                                                        ),
                                                    },
                                                ),
                                                semicolon: 970,
                                            },
                                        ),
                                    ],
                                    right_brace: 976,
                                },
                            },
                        ),
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: 983,
                                expression: Some(
                                    Variable(
                                        Variable {
                                            position: 990,
                                            name: "$vec",
                                        },
                                    ),
                                ),
                                semicolon: 994,
                            },
                        ),
                    ],
                    right_brace: 996,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 999,
                name: Identifier {
                    position: 1008,
                    value: "into_dict",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 1017,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 1018,
                                        value: "Tk",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 1022,
                                        value: "Tv",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [
                                1020,
                            ],
                        },
                        greater_than: 1024,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 1025,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Iterable(
                                    1026,
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 1034,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1035,
                                                            value: "Tk",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 1039,
                                                            value: "Tv",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                1037,
                                            ],
                                        },
                                        greater_than: 1041,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 1043,
                                    name: "$iterable",
                                },
                                default: None,
                            },
                        ],
                        commas: [],
                    },
                    right_parenthesis: 1052,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 1053,
                    type_definition: Dict(
                        1055,
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 1059,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 1060,
                                                value: "Tk",
                                            },
                                            templates: None,
                                        },
                                    ),
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 1064,
                                                value: "Tv",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [
                                    1062,
                                ],
                            },
                            greater_than: 1066,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 1068,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 1074,
                                                name: "$dict",
                                            },
                                        ),
                                        equals: 1080,
                                        right: Dict(
                                            DictExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                dict: 1082,
                                                left_bracket: 1086,
                                                members: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 1087,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 1088,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: 1094,
                                iterator: KeyAndValue {
                                    expression: Variable(
                                        Variable {
                                            position: 1102,
                                            name: "$iterable",
                                        },
                                    ),
                                    as: 1112,
                                    key: Variable {
                                        position: 1115,
                                        name: "$key",
                                    },
                                    double_arrow: 1120,
                                    value: Variable {
                                        position: 1123,
                                        name: "$value",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 1130,
                                    statements: [
                                        Expression(
                                            ExpressionStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                expression: AssignmentOperation(
                                                    Assignment {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        left: ArrayOperation(
                                                            Access {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                array: Variable(
                                                                    Variable {
                                                                        position: 1140,
                                                                        name: "$dict",
                                                                    },
                                                                ),
                                                                left_bracket: 1145,
                                                                index: Variable(
                                                                    Variable {
                                                                        position: 1146,
                                                                        name: "$key",
                                                                    },
                                                                ),
                                                                right_bracket: 1150,
                                                            },
                                                        ),
                                                        equals: 1152,
                                                        right: Variable(
                                                            Variable {
                                                                position: 1154,
                                                                name: "$value",
                                                            },
                                                        ),
                                                    },
                                                ),
                                                semicolon: 1160,
                                            },
                                        ),
                                    ],
                                    right_brace: 1166,
                                },
                            },
                        ),
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: 1173,
                                expression: Some(
                                    Variable(
                                        Variable {
                                            position: 1180,
                                            name: "$dict",
                                        },
                                    ),
                                ),
                                semicolon: 1185,
                            },
                        ),
                    ],
                    right_brace: 1187,
                },
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: 1190,
                name: Identifier {
                    position: 1199,
                    value: "baz",
                },
                templates: None,
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 1202,
                    parameters: CommaSeparated {
                        inner: [],
                        commas: [],
                    },
                    right_parenthesis: 1203,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 1204,
                    type_definition: Void(
                        1206,
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 1211,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 1217,
                                                name: "$dict",
                                            },
                                        ),
                                        equals: 1223,
                                        right: Dict(
                                            DictExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                dict: 1225,
                                                left_bracket: 1229,
                                                members: CommaSeparated {
                                                    inner: [
                                                        DictExpressionItem {
                                                            key: Literal(
                                                                Integer(
                                                                    LiteralInteger {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        value: "1",
                                                                        position: 1230,
                                                                    },
                                                                ),
                                                            ),
                                                            double_arrow: 1232,
                                                            value: Literal(
                                                                Integer(
                                                                    LiteralInteger {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        value: "1",
                                                                        position: 1235,
                                                                    },
                                                                ),
                                                            ),
                                                        },
                                                        DictExpressionItem {
                                                            key: Literal(
                                                                Integer(
                                                                    LiteralInteger {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        value: "2",
                                                                        position: 1238,
                                                                    },
                                                                ),
                                                            ),
                                                            double_arrow: 1240,
                                                            value: Literal(
                                                                Integer(
                                                                    LiteralInteger {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        value: "2",
                                                                        position: 1243,
                                                                    },
                                                                ),
                                                            ),
                                                        },
                                                        DictExpressionItem {
                                                            key: Literal(
                                                                Integer(
                                                                    LiteralInteger {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        value: "3",
                                                                        position: 1246,
                                                                    },
                                                                ),
                                                            ),
                                                            double_arrow: 1248,
                                                            value: Literal(
                                                                Integer(
                                                                    LiteralInteger {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        value: "3",
                                                                        position: 1251,
                                                                    },
                                                                ),
                                                            ),
                                                        },
                                                    ],
                                                    commas: [
                                                        1236,
                                                        1244,
                                                    ],
                                                },
                                                right_bracket: 1252,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 1253,
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 1259,
                                                name: "$vec",
                                            },
                                        ),
                                        equals: 1264,
                                        right: Vec(
                                            VecExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                vec: 1266,
                                                left_bracket: 1269,
                                                members: CommaSeparated {
                                                    inner: [
                                                        VecExpressionItem {
                                                            value: Literal(
                                                                Integer(
                                                                    LiteralInteger {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        value: "1",
                                                                        position: 1270,
                                                                    },
                                                                ),
                                                            ),
                                                        },
                                                        VecExpressionItem {
                                                            value: Literal(
                                                                Integer(
                                                                    LiteralInteger {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        value: "2",
                                                                        position: 1273,
                                                                    },
                                                                ),
                                                            ),
                                                        },
                                                        VecExpressionItem {
                                                            value: Literal(
                                                                Integer(
                                                                    LiteralInteger {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        value: "3",
                                                                        position: 1276,
                                                                    },
                                                                ),
                                                            ),
                                                        },
                                                    ],
                                                    commas: [
                                                        1271,
                                                        1274,
                                                    ],
                                                },
                                                right_bracket: 1277,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 1278,
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 1285,
                                                name: "$dict2",
                                            },
                                        ),
                                        equals: 1292,
                                        right: FunctionOperation(
                                            Call {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                function: Identifier(
                                                    Identifier {
                                                        position: 1294,
                                                        value: "into_dict",
                                                    },
                                                ),
                                                generics: Some(
                                                    GenericGroupExpression {
                                                        double_colon_less_than: 1303,
                                                        types: CommaSeparated {
                                                            inner: [
                                                                Integer(
                                                                    1306,
                                                                ),
                                                                Integer(
                                                                    1311,
                                                                ),
                                                            ],
                                                            commas: [
                                                                1309,
                                                            ],
                                                        },
                                                        greater_than: 1314,
                                                    },
                                                ),
                                                arguments: ArgumentListExpression {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: 1315,
                                                    arguments: CommaSeparated {
                                                        inner: [
                                                            Positional {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                ellipsis: None,
                                                                value: Variable(
                                                                    Variable {
                                                                        position: 1316,
                                                                        name: "$vec",
                                                                    },
                                                                ),
                                                            },
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: 1320,
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 1321,
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 1327,
                                                name: "$vec2",
                                            },
                                        ),
                                        equals: 1333,
                                        right: FunctionOperation(
                                            Call {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                function: Identifier(
                                                    Identifier {
                                                        position: 1335,
                                                        value: "into_vec",
                                                    },
                                                ),
                                                generics: Some(
                                                    GenericGroupExpression {
                                                        double_colon_less_than: 1343,
                                                        types: CommaSeparated {
                                                            inner: [
                                                                Integer(
                                                                    1346,
                                                                ),
                                                            ],
                                                            commas: [],
                                                        },
                                                        greater_than: 1349,
                                                    },
                                                ),
                                                arguments: ArgumentListExpression {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: 1350,
                                                    arguments: CommaSeparated {
                                                        inner: [
                                                            Positional {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                ellipsis: None,
                                                                value: Variable(
                                                                    Variable {
                                                                        position: 1351,
                                                                        name: "$dict",
                                                                    },
                                                                ),
                                                            },
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: 1356,
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 1357,
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 1364,
                                                name: "$a",
                                            },
                                        ),
                                        equals: 1367,
                                        right: Vec(
                                            VecExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                vec: 1369,
                                                left_bracket: 1372,
                                                members: CommaSeparated {
                                                    inner: [
                                                        VecExpressionItem {
                                                            value: Variable(
                                                                Variable {
                                                                    position: 1373,
                                                                    name: "$dict1",
                                                                },
                                                            ),
                                                        },
                                                        VecExpressionItem {
                                                            value: Variable(
                                                                Variable {
                                                                    position: 1381,
                                                                    name: "$dict2",
                                                                },
                                                            ),
                                                        },
                                                    ],
                                                    commas: [
                                                        1379,
                                                    ],
                                                },
                                                right_bracket: 1387,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 1388,
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 1394,
                                                name: "$b",
                                            },
                                        ),
                                        equals: 1397,
                                        right: FunctionOperation(
                                            Call {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                function: Identifier(
                                                    Identifier {
                                                        position: 1399,
                                                        value: "into_dict",
                                                    },
                                                ),
                                                generics: Some(
                                                    GenericGroupExpression {
                                                        double_colon_less_than: 1408,
                                                        types: CommaSeparated {
                                                            inner: [
                                                                Integer(
                                                                    1411,
                                                                ),
                                                                Dict(
                                                                    1416,
                                                                    TypeTemplateGroupDefinition {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        less_than: 1420,
                                                                        members: CommaSeparated {
                                                                            inner: [
                                                                                Integer(
                                                                                    1421,
                                                                                ),
                                                                                Integer(
                                                                                    1426,
                                                                                ),
                                                                            ],
                                                                            commas: [
                                                                                1424,
                                                                            ],
                                                                        },
                                                                        greater_than: 1429,
                                                                    },
                                                                ),
                                                            ],
                                                            commas: [
                                                                1414,
                                                            ],
                                                        },
                                                        greater_than: 1430,
                                                    },
                                                ),
                                                arguments: ArgumentListExpression {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: 1431,
                                                    arguments: CommaSeparated {
                                                        inner: [
                                                            Positional {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                ellipsis: None,
                                                                value: Variable(
                                                                    Variable {
                                                                        position: 1432,
                                                                        name: "$a",
                                                                    },
                                                                ),
                                                            },
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: 1434,
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 1435,
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 1442,
                                                name: "$c",
                                            },
                                        ),
                                        equals: 1445,
                                        right: ClassOperation(
                                            Initialization {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                new: 1447,
                                                class: Identifier {
                                                    position: 1451,
                                                    value: "Box",
                                                },
                                                generics: Some(
                                                    GenericGroupExpression {
                                                        double_colon_less_than: 1454,
                                                        types: CommaSeparated {
                                                            inner: [
                                                                Dict(
                                                                    1457,
                                                                    TypeTemplateGroupDefinition {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        less_than: 1461,
                                                                        members: CommaSeparated {
                                                                            inner: [
                                                                                Integer(
                                                                                    1462,
                                                                                ),
                                                                                Dict(
                                                                                    1467,
                                                                                    TypeTemplateGroupDefinition {
                                                                                        comments: CommentGroup {
                                                                                            comments: [],
                                                                                        },
                                                                                        less_than: 1471,
                                                                                        members: CommaSeparated {
                                                                                            inner: [
                                                                                                Integer(
                                                                                                    1472,
                                                                                                ),
                                                                                                Integer(
                                                                                                    1477,
                                                                                                ),
                                                                                            ],
                                                                                            commas: [
                                                                                                1475,
                                                                                            ],
                                                                                        },
                                                                                        greater_than: 1480,
                                                                                    },
                                                                                ),
                                                                            ],
                                                                            commas: [
                                                                                1465,
                                                                            ],
                                                                        },
                                                                        greater_than: 1481,
                                                                    },
                                                                ),
                                                            ],
                                                            commas: [],
                                                        },
                                                        greater_than: 1482,
                                                    },
                                                ),
                                                arguments: ArgumentListExpression {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: 1483,
                                                    arguments: CommaSeparated {
                                                        inner: [
                                                            Positional {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                ellipsis: None,
                                                                value: Variable(
                                                                    Variable {
                                                                        position: 1484,
                                                                        name: "$b",
                                                                    },
                                                                ),
                                                            },
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: 1486,
                                                },
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 1487,
                            },
                        ),
                    ],
                    right_brace: 1489,
                },
            },
        ),
    ],
    eof: 1491,
}