DefinitionTree {
    definitions: [
        TypeAlias(
            TypeAliasDefinition {
                type: Keyword {
                    value: "type",
                    position: 0,
                },
                name: TemplatedIdentifier {
                    name: Identifier {
                        position: 5,
                        value: "Predicate",
                    },
                    templates: Some(
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 14,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 15,
                                                value: "T",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [],
                            },
                            greater_than: 16,
                        },
                    ),
                },
                equals: 18,
                type_definition: Identifier(
                    TemplatedIdentifier {
                        name: Identifier {
                            position: 20,
                            value: "Closure",
                        },
                        templates: Some(
                            TypeTemplateGroupDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                less_than: 27,
                                members: CommaSeparated {
                                    inner: [
                                        Tuple {
                                            left_parenthesis: 28,
                                            type_definitions: CommaSeparated {
                                                inner: [
                                                    Identifier(
                                                        TemplatedIdentifier {
                                                            name: Identifier {
                                                                position: 29,
                                                                value: "T",
                                                            },
                                                            templates: None,
                                                        },
                                                    ),
                                                ],
                                                commas: [],
                                            },
                                            right_parenthesis: 30,
                                        },
                                        Boolean(
                                            Keyword {
                                                value: "bool",
                                                position: 33,
                                            },
                                        ),
                                    ],
                                    commas: [
                                        31,
                                    ],
                                },
                                greater_than: 37,
                            },
                        ),
                    },
                ),
                semicolon: 38,
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: Keyword {
                    value: "function",
                    position: 41,
                },
                name: Identifier {
                    position: 50,
                    value: "filter",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 56,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 57,
                                        value: "T",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [],
                        },
                        greater_than: 58,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 59,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Vec(
                                    Keyword {
                                        value: "vec",
                                        position: 60,
                                    },
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 63,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 64,
                                                            value: "T",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [],
                                        },
                                        greater_than: 65,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 67,
                                    name: "$vec",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 73,
                                            value: "Predicate",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 82,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 83,
                                                                    value: "T",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [],
                                                },
                                                greater_than: 84,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 86,
                                    name: "$predicate",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            71,
                        ],
                    },
                    right_parenthesis: 96,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 97,
                    type_definition: Vec(
                        Keyword {
                            value: "vec",
                            position: 99,
                        },
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 102,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 103,
                                                value: "T",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [],
                            },
                            greater_than: 104,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 106,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 112,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 120,
                                        right: Vec(
                                            VecExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                vec: Keyword {
                                                    value: "vec",
                                                    position: 122,
                                                },
                                                left_bracket: 125,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 126,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 127,
                            },
                        ),
                        Foreach(
                            ForeachStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                foreach: Keyword {
                                    value: "foreach",
                                    position: 133,
                                },
                                iterator: Value {
                                    expression: Variable(
                                        Variable {
                                            position: 141,
                                            name: "$vec",
                                        },
                                    ),
                                    as: Keyword {
                                        value: "as",
                                        position: 146,
                                    },
                                    value: Variable {
                                        position: 149,
                                        name: "$item",
                                    },
                                },
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 155,
                                    statements: [
                                        If(
                                            IfStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                if: Keyword {
                                                    value: "if",
                                                    position: 165,
                                                },
                                                condition: FunctionOperation(
                                                    Call {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        function: Variable(
                                                            Variable {
                                                                position: 168,
                                                                name: "$predicate",
                                                            },
                                                        ),
                                                        generics: None,
                                                        arguments: ArgumentListExpression {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            left_parenthesis: 178,
                                                            arguments: CommaSeparated {
                                                                inner: [
                                                                    Value {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        value: Variable(
                                                                            Variable {
                                                                                position: 179,
                                                                                name: "$item",
                                                                            },
                                                                        ),
                                                                    },
                                                                ],
                                                                commas: [],
                                                            },
                                                            right_parenthesis: 184,
                                                        },
                                                    },
                                                ),
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: 186,
                                                    statements: [
                                                        Expression(
                                                            ExpressionStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                expression: AssignmentOperation(
                                                                    Assignment {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        left: ArrayOperation(
                                                                            Push {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                array: Variable(
                                                                                    Variable {
                                                                                        position: 200,
                                                                                        name: "$result",
                                                                                    },
                                                                                ),
                                                                                left_bracket: 207,
                                                                                right_bracket: 208,
                                                                            },
                                                                        ),
                                                                        equals: 210,
                                                                        right: Variable(
                                                                            Variable {
                                                                                position: 212,
                                                                                name: "$item",
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                semicolon: 217,
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: 227,
                                                },
                                                elseifs: [],
                                                else: None,
                                            },
                                        ),
                                    ],
                                    right_brace: 233,
                                },
                                else: None,
                                else_block: None,
                            },
                        ),
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: Keyword {
                                    value: "return",
                                    position: 240,
                                },
                                expression: Some(
                                    Variable(
                                        Variable {
                                            position: 247,
                                            name: "$result",
                                        },
                                    ),
                                ),
                                semicolon: 254,
                            },
                        ),
                    ],
                    right_brace: 256,
                },
            },
        ),
        TypeAlias(
            TypeAliasDefinition {
                type: Keyword {
                    value: "type",
                    position: 259,
                },
                name: TemplatedIdentifier {
                    name: Identifier {
                        position: 264,
                        value: "Mapper",
                    },
                    templates: Some(
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 270,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 271,
                                                value: "K",
                                            },
                                            templates: None,
                                        },
                                    ),
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 274,
                                                value: "V",
                                            },
                                            templates: None,
                                        },
                                    ),
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 277,
                                                value: "U",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [
                                    272,
                                    275,
                                ],
                            },
                            greater_than: 278,
                        },
                    ),
                },
                equals: 280,
                type_definition: Union(
                    [
                        Identifier(
                            TemplatedIdentifier {
                                name: Identifier {
                                    position: 282,
                                    value: "Closure",
                                },
                                templates: Some(
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 289,
                                        members: CommaSeparated {
                                            inner: [
                                                Tuple {
                                                    left_parenthesis: 290,
                                                    type_definitions: CommaSeparated {
                                                        inner: [
                                                            Identifier(
                                                                TemplatedIdentifier {
                                                                    name: Identifier {
                                                                        position: 291,
                                                                        value: "K",
                                                                    },
                                                                    templates: None,
                                                                },
                                                            ),
                                                            Identifier(
                                                                TemplatedIdentifier {
                                                                    name: Identifier {
                                                                        position: 294,
                                                                        value: "V",
                                                                    },
                                                                    templates: None,
                                                                },
                                                            ),
                                                        ],
                                                        commas: [
                                                            292,
                                                        ],
                                                    },
                                                    right_parenthesis: 295,
                                                },
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 298,
                                                            value: "U",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                296,
                                            ],
                                        },
                                        greater_than: 299,
                                    },
                                ),
                            },
                        ),
                        Identifier(
                            TemplatedIdentifier {
                                name: Identifier {
                                    position: 301,
                                    value: "SomeOtherType",
                                },
                                templates: Some(
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 314,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 315,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 318,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 321,
                                                            value: "U",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                316,
                                                319,
                                            ],
                                        },
                                        greater_than: 322,
                                    },
                                ),
                            },
                        ),
                    ],
                ),
                semicolon: 323,
            },
        ),
        Function(
            FunctionDefinition {
                comments: CommentGroup {
                    comments: [],
                },
                attributes: [],
                function: Keyword {
                    value: "function",
                    position: 326,
                },
                name: Identifier {
                    position: 335,
                    value: "map",
                },
                templates: Some(
                    TemplateGroupDefinition {
                        comments: CommentGroup {
                            comments: [],
                        },
                        less_than: 338,
                        members: CommaSeparated {
                            inner: [
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 339,
                                        value: "K",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 342,
                                        value: "V",
                                    },
                                    constraint: None,
                                },
                                TemplateDefinition {
                                    variance: Invaraint,
                                    name: Identifier {
                                        position: 345,
                                        value: "U",
                                    },
                                    constraint: None,
                                },
                            ],
                            commas: [
                                340,
                                343,
                            ],
                        },
                        greater_than: 346,
                    },
                ),
                parameters: FunctionLikeParameterListDefinition {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_parenthesis: 347,
                    parameters: CommaSeparated {
                        inner: [
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Dict(
                                    Keyword {
                                        value: "dict",
                                        position: 348,
                                    },
                                    TypeTemplateGroupDefinition {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        less_than: 352,
                                        members: CommaSeparated {
                                            inner: [
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 353,
                                                            value: "K",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                                Identifier(
                                                    TemplatedIdentifier {
                                                        name: Identifier {
                                                            position: 356,
                                                            value: "V",
                                                        },
                                                        templates: None,
                                                    },
                                                ),
                                            ],
                                            commas: [
                                                354,
                                            ],
                                        },
                                        greater_than: 357,
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 359,
                                    name: "$dict",
                                },
                                default: None,
                            },
                            FunctionLikeParameterDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 366,
                                            value: "Mapper",
                                        },
                                        templates: Some(
                                            TypeTemplateGroupDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                less_than: 372,
                                                members: CommaSeparated {
                                                    inner: [
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 373,
                                                                    value: "K",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 376,
                                                                    value: "V",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                        Identifier(
                                                            TemplatedIdentifier {
                                                                name: Identifier {
                                                                    position: 379,
                                                                    value: "U",
                                                                },
                                                                templates: None,
                                                            },
                                                        ),
                                                    ],
                                                    commas: [
                                                        374,
                                                        377,
                                                    ],
                                                },
                                                greater_than: 380,
                                            },
                                        ),
                                    },
                                ),
                                ellipsis: None,
                                variable: Variable {
                                    position: 382,
                                    name: "$mapper",
                                },
                                default: None,
                            },
                        ],
                        commas: [
                            364,
                        ],
                    },
                    right_parenthesis: 389,
                },
                return_type: FunctionLikeReturnTypeDefinition {
                    colon: 390,
                    type_definition: Dict(
                        Keyword {
                            value: "dict",
                            position: 392,
                        },
                        TypeTemplateGroupDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            less_than: 396,
                            members: CommaSeparated {
                                inner: [
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 397,
                                                value: "K",
                                            },
                                            templates: None,
                                        },
                                    ),
                                    Identifier(
                                        TemplatedIdentifier {
                                            name: Identifier {
                                                position: 400,
                                                value: "U",
                                            },
                                            templates: None,
                                        },
                                    ),
                                ],
                                commas: [
                                    398,
                                ],
                            },
                            greater_than: 401,
                        },
                    ),
                },
                body: BlockStatement {
                    comments: CommentGroup {
                        comments: [],
                    },
                    left_brace: 403,
                    statements: [
                        Expression(
                            ExpressionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                expression: AssignmentOperation(
                                    Assignment {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 409,
                                                name: "$result",
                                            },
                                        ),
                                        equals: 417,
                                        right: Dict(
                                            DictExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                dict: Keyword {
                                                    value: "dict",
                                                    position: 419,
                                                },
                                                left_bracket: 423,
                                                elements: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_bracket: 424,
                                            },
                                        ),
                                    },
                                ),
                                semicolon: 425,
                            },
                        ),
                        If(
                            IfStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                if: Keyword {
                                    value: "if",
                                    position: 431,
                                },
                                condition: TypeOperation(
                                    Is {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        left: Variable(
                                            Variable {
                                                position: 434,
                                                name: "$mapper",
                                            },
                                        ),
                                        is: Keyword {
                                            value: "is",
                                            position: 442,
                                        },
                                        right: Identifier(
                                            TemplatedIdentifier {
                                                name: Identifier {
                                                    position: 445,
                                                    value: "SomeOtherType",
                                                },
                                                templates: Some(
                                                    TypeTemplateGroupDefinition {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        less_than: 458,
                                                        members: CommaSeparated {
                                                            inner: [
                                                                Identifier(
                                                                    TemplatedIdentifier {
                                                                        name: Identifier {
                                                                            position: 459,
                                                                            value: "_",
                                                                        },
                                                                        templates: None,
                                                                    },
                                                                ),
                                                                Identifier(
                                                                    TemplatedIdentifier {
                                                                        name: Identifier {
                                                                            position: 462,
                                                                            value: "_",
                                                                        },
                                                                        templates: None,
                                                                    },
                                                                ),
                                                                Identifier(
                                                                    TemplatedIdentifier {
                                                                        name: Identifier {
                                                                            position: 465,
                                                                            value: "_",
                                                                        },
                                                                        templates: None,
                                                                    },
                                                                ),
                                                            ],
                                                            commas: [
                                                                460,
                                                                463,
                                                            ],
                                                        },
                                                        greater_than: 466,
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                block: BlockStatement {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: 468,
                                    statements: [
                                        Foreach(
                                            ForeachStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                foreach: Keyword {
                                                    value: "foreach",
                                                    position: 478,
                                                },
                                                iterator: KeyAndValue {
                                                    expression: Variable(
                                                        Variable {
                                                            position: 486,
                                                            name: "$dict",
                                                        },
                                                    ),
                                                    as: Keyword {
                                                        value: "as",
                                                        position: 492,
                                                    },
                                                    key: Variable {
                                                        position: 495,
                                                        name: "$key",
                                                    },
                                                    double_arrow: 500,
                                                    value: Variable {
                                                        position: 503,
                                                        name: "$value",
                                                    },
                                                },
                                                block: BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: 510,
                                                    statements: [
                                                        Expression(
                                                            ExpressionStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                expression: AssignmentOperation(
                                                                    Assignment {
                                                                        comments: CommentGroup {
                                                                            comments: [],
                                                                        },
                                                                        left: ArrayOperation(
                                                                            Access {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                array: Variable(
                                                                                    Variable {
                                                                                        position: 524,
                                                                                        name: "$result",
                                                                                    },
                                                                                ),
                                                                                left_bracket: 531,
                                                                                index: Variable(
                                                                                    Variable {
                                                                                        position: 532,
                                                                                        name: "$key",
                                                                                    },
                                                                                ),
                                                                                right_bracket: 536,
                                                                            },
                                                                        ),
                                                                        equals: 538,
                                                                        right: ObjectOperation(
                                                                            MethodCall {
                                                                                comments: CommentGroup {
                                                                                    comments: [],
                                                                                },
                                                                                object: Variable(
                                                                                    Variable {
                                                                                        position: 540,
                                                                                        name: "$mapper",
                                                                                    },
                                                                                ),
                                                                                arrow: 547,
                                                                                method: Identifier {
                                                                                    position: 549,
                                                                                    value: "doMap",
                                                                                },
                                                                                generics: None,
                                                                                arguments: ArgumentListExpression {
                                                                                    comments: CommentGroup {
                                                                                        comments: [],
                                                                                    },
                                                                                    left_parenthesis: 554,
                                                                                    arguments: CommaSeparated {
                                                                                        inner: [
                                                                                            Value {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: Variable(
                                                                                                    Variable {
                                                                                                        position: 555,
                                                                                                        name: "$key",
                                                                                                    },
                                                                                                ),
                                                                                            },
                                                                                            Value {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                value: Variable(
                                                                                                    Variable {
                                                                                                        position: 561,
                                                                                                        name: "$value",
                                                                                                    },
                                                                                                ),
                                                                                            },
                                                                                        ],
                                                                                        commas: [
                                                                                            559,
                                                                                        ],
                                                                                    },
                                                                                    right_parenthesis: 567,
                                                                                },
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                semicolon: 568,
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: 578,
                                                },
                                                else: None,
                                                else_block: None,
                                            },
                                        ),
                                    ],
                                    right_brace: 584,
                                },
                                elseifs: [],
                                else: Some(
                                    IfElseStatement {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        else: Keyword {
                                            value: "else",
                                            position: 586,
                                        },
                                        block: Block(
                                            BlockStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left_brace: 591,
                                                statements: [
                                                    Foreach(
                                                        ForeachStatement {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            foreach: Keyword {
                                                                value: "foreach",
                                                                position: 601,
                                                            },
                                                            iterator: KeyAndValue {
                                                                expression: Variable(
                                                                    Variable {
                                                                        position: 609,
                                                                        name: "$dict",
                                                                    },
                                                                ),
                                                                as: Keyword {
                                                                    value: "as",
                                                                    position: 615,
                                                                },
                                                                key: Variable {
                                                                    position: 618,
                                                                    name: "$key",
                                                                },
                                                                double_arrow: 623,
                                                                value: Variable {
                                                                    position: 626,
                                                                    name: "$value",
                                                                },
                                                            },
                                                            block: BlockStatement {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_brace: 633,
                                                                statements: [
                                                                    Expression(
                                                                        ExpressionStatement {
                                                                            comments: CommentGroup {
                                                                                comments: [],
                                                                            },
                                                                            expression: AssignmentOperation(
                                                                                Assignment {
                                                                                    comments: CommentGroup {
                                                                                        comments: [],
                                                                                    },
                                                                                    left: ArrayOperation(
                                                                                        Access {
                                                                                            comments: CommentGroup {
                                                                                                comments: [],
                                                                                            },
                                                                                            array: Variable(
                                                                                                Variable {
                                                                                                    position: 647,
                                                                                                    name: "$result",
                                                                                                },
                                                                                            ),
                                                                                            left_bracket: 654,
                                                                                            index: Variable(
                                                                                                Variable {
                                                                                                    position: 655,
                                                                                                    name: "$key",
                                                                                                },
                                                                                            ),
                                                                                            right_bracket: 659,
                                                                                        },
                                                                                    ),
                                                                                    equals: 661,
                                                                                    right: FunctionOperation(
                                                                                        Call {
                                                                                            comments: CommentGroup {
                                                                                                comments: [],
                                                                                            },
                                                                                            function: Variable(
                                                                                                Variable {
                                                                                                    position: 663,
                                                                                                    name: "$mapper",
                                                                                                },
                                                                                            ),
                                                                                            generics: None,
                                                                                            arguments: ArgumentListExpression {
                                                                                                comments: CommentGroup {
                                                                                                    comments: [],
                                                                                                },
                                                                                                left_parenthesis: 670,
                                                                                                arguments: CommaSeparated {
                                                                                                    inner: [
                                                                                                        Value {
                                                                                                            comments: CommentGroup {
                                                                                                                comments: [],
                                                                                                            },
                                                                                                            value: Variable(
                                                                                                                Variable {
                                                                                                                    position: 671,
                                                                                                                    name: "$key",
                                                                                                                },
                                                                                                            ),
                                                                                                        },
                                                                                                        Value {
                                                                                                            comments: CommentGroup {
                                                                                                                comments: [],
                                                                                                            },
                                                                                                            value: Variable(
                                                                                                                Variable {
                                                                                                                    position: 677,
                                                                                                                    name: "$value",
                                                                                                                },
                                                                                                            ),
                                                                                                        },
                                                                                                    ],
                                                                                                    commas: [
                                                                                                        675,
                                                                                                    ],
                                                                                                },
                                                                                                right_parenthesis: 683,
                                                                                            },
                                                                                        },
                                                                                    ),
                                                                                },
                                                                            ),
                                                                            semicolon: 684,
                                                                        },
                                                                    ),
                                                                ],
                                                                right_brace: 694,
                                                            },
                                                            else: None,
                                                            else_block: None,
                                                        },
                                                    ),
                                                ],
                                                right_brace: 700,
                                            },
                                        ),
                                    },
                                ),
                            },
                        ),
                        Return(
                            Explicit {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                return: Keyword {
                                    value: "return",
                                    position: 707,
                                },
                                expression: Some(
                                    Variable(
                                        Variable {
                                            position: 714,
                                            name: "$result",
                                        },
                                    ),
                                ),
                                semicolon: 721,
                            },
                        ),
                    ],
                    right_brace: 723,
                },
            },
        ),
    ],
    eof: 725,
}