[
    FullOpeningTag(
        FullOpeningTagStatement {
            span: Span {
                line: 1,
                column: 1,
                position: 0,
            },
        },
    ),
    BackedEnum(
        BackedEnumStatement {
            attributes: [],
            enum: Span {
                line: 3,
                column: 1,
                position: 7,
            },
            name: SimpleIdentifier {
                span: Span {
                    line: 3,
                    column: 6,
                    position: 12,
                },
                value: "a",
            },
            backed_type: Int(
                Span {
                    line: 3,
                    column: 7,
                    position: 13,
                },
                Span {
                    line: 3,
                    column: 9,
                    position: 15,
                },
            ),
            implements: [],
            body: BackedEnumBody {
                left_brace: Span {
                    line: 3,
                    column: 13,
                    position: 19,
                },
                members: [
                    Case(
                        BackedEnumCase {
                            attributes: [],
                            case: Span {
                                line: 4,
                                column: 5,
                                position: 25,
                            },
                            name: SimpleIdentifier {
                                span: Span {
                                    line: 4,
                                    column: 10,
                                    position: 30,
                                },
                                value: "static",
                            },
                            equals: Span {
                                line: 4,
                                column: 17,
                                position: 37,
                            },
                            value: Literal(
                                Integer(
                                    LiteralInteger {
                                        value: "2413",
                                        span: Span {
                                            line: 4,
                                            column: 19,
                                            position: 39,
                                        },
                                    },
                                ),
                            ),
                            semicolon: Span {
                                line: 4,
                                column: 23,
                                position: 43,
                            },
                        },
                    ),
                    Case(
                        BackedEnumCase {
                            attributes: [],
                            case: Span {
                                line: 5,
                                column: 5,
                                position: 49,
                            },
                            name: SimpleIdentifier {
                                span: Span {
                                    line: 5,
                                    column: 10,
                                    position: 54,
                                },
                                value: "self",
                            },
                            equals: Span {
                                line: 5,
                                column: 15,
                                position: 59,
                            },
                            value: Literal(
                                Integer(
                                    LiteralInteger {
                                        value: "2432",
                                        span: Span {
                                            line: 5,
                                            column: 17,
                                            position: 61,
                                        },
                                    },
                                ),
                            ),
                            semicolon: Span {
                                line: 5,
                                column: 21,
                                position: 65,
                            },
                        },
                    ),
                    Case(
                        BackedEnumCase {
                            attributes: [],
                            case: Span {
                                line: 6,
                                column: 5,
                                position: 71,
                            },
                            name: SimpleIdentifier {
                                span: Span {
                                    line: 6,
                                    column: 10,
                                    position: 76,
                                },
                                value: "return",
                            },
                            equals: Span {
                                line: 6,
                                column: 17,
                                position: 83,
                            },
                            value: Literal(
                                Integer(
                                    LiteralInteger {
                                        value: "2433",
                                        span: Span {
                                            line: 6,
                                            column: 19,
                                            position: 85,
                                        },
                                    },
                                ),
                            ),
                            semicolon: Span {
                                line: 6,
                                column: 23,
                                position: 89,
                            },
                        },
                    ),
                    Case(
                        BackedEnumCase {
                            attributes: [],
                            case: Span {
                                line: 7,
                                column: 5,
                                position: 95,
                            },
                            name: SimpleIdentifier {
                                span: Span {
                                    line: 7,
                                    column: 10,
                                    position: 100,
                                },
                                value: "parent",
                            },
                            equals: Span {
                                line: 7,
                                column: 17,
                                position: 107,
                            },
                            value: Literal(
                                Integer(
                                    LiteralInteger {
                                        value: "2543",
                                        span: Span {
                                            line: 7,
                                            column: 19,
                                            position: 109,
                                        },
                                    },
                                ),
                            ),
                            semicolon: Span {
                                line: 7,
                                column: 23,
                                position: 113,
                            },
                        },
                    ),
                    Case(
                        BackedEnumCase {
                            attributes: [],
                            case: Span {
                                line: 8,
                                column: 5,
                                position: 119,
                            },
                            name: SimpleIdentifier {
                                span: Span {
                                    line: 8,
                                    column: 10,
                                    position: 124,
                                },
                                value: "enum",
                            },
                            equals: Span {
                                line: 8,
                                column: 15,
                                position: 129,
                            },
                            value: Literal(
                                Integer(
                                    LiteralInteger {
                                        value: "24133",
                                        span: Span {
                                            line: 8,
                                            column: 17,
                                            position: 131,
                                        },
                                    },
                                ),
                            ),
                            semicolon: Span {
                                line: 8,
                                column: 22,
                                position: 136,
                            },
                        },
                    ),
                    Case(
                        BackedEnumCase {
                            attributes: [],
                            case: Span {
                                line: 9,
                                column: 5,
                                position: 142,
                            },
                            name: SimpleIdentifier {
                                span: Span {
                                    line: 9,
                                    column: 10,
                                    position: 147,
                                },
                                value: "from",
                            },
                            equals: Span {
                                line: 9,
                                column: 15,
                                position: 152,
                            },
                            value: Literal(
                                Integer(
                                    LiteralInteger {
                                        value: "25443",
                                        span: Span {
                                            line: 9,
                                            column: 17,
                                            position: 154,
                                        },
                                    },
                                ),
                            ),
                            semicolon: Span {
                                line: 9,
                                column: 22,
                                position: 159,
                            },
                        },
                    ),
                ],
                right_brace: Span {
                    line: 10,
                    column: 1,
                    position: 161,
                },
            },
        },
    ),
    Class(
        ClassStatement {
            attributes: [],
            modifiers: ClassModifierGroup {
                modifiers: [],
            },
            class: Span {
                line: 13,
                column: 1,
                position: 165,
            },
            name: SimpleIdentifier {
                span: Span {
                    line: 13,
                    column: 7,
                    position: 171,
                },
                value: "f",
            },
            extends: None,
            implements: None,
            body: ClassBody {
                left_brace: Span {
                    line: 13,
                    column: 9,
                    position: 173,
                },
                members: [
                    Constant(
                        ClassishConstant {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            modifiers: ConstantModifierGroup {
                                modifiers: [],
                            },
                            const: Span {
                                line: 14,
                                column: 5,
                                position: 179,
                            },
                            entries: [
                                ConstantEntry {
                                    name: SimpleIdentifier {
                                        span: Span {
                                            line: 14,
                                            column: 11,
                                            position: 185,
                                        },
                                        value: "static",
                                    },
                                    equals: Span {
                                        line: 14,
                                        column: 18,
                                        position: 192,
                                    },
                                    value: Literal(
                                        Integer(
                                            LiteralInteger {
                                                value: "2413",
                                                span: Span {
                                                    line: 14,
                                                    column: 20,
                                                    position: 194,
                                                },
                                            },
                                        ),
                                    ),
                                },
                            ],
                            semicolon: Span {
                                line: 14,
                                column: 24,
                                position: 198,
                            },
                        },
                    ),
                    Constant(
                        ClassishConstant {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            modifiers: ConstantModifierGroup {
                                modifiers: [],
                            },
                            const: Span {
                                line: 15,
                                column: 5,
                                position: 204,
                            },
                            entries: [
                                ConstantEntry {
                                    name: SimpleIdentifier {
                                        span: Span {
                                            line: 15,
                                            column: 11,
                                            position: 210,
                                        },
                                        value: "self",
                                    },
                                    equals: Span {
                                        line: 15,
                                        column: 16,
                                        position: 215,
                                    },
                                    value: Literal(
                                        Integer(
                                            LiteralInteger {
                                                value: "2432",
                                                span: Span {
                                                    line: 15,
                                                    column: 18,
                                                    position: 217,
                                                },
                                            },
                                        ),
                                    ),
                                },
                            ],
                            semicolon: Span {
                                line: 15,
                                column: 22,
                                position: 221,
                            },
                        },
                    ),
                    Constant(
                        ClassishConstant {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            modifiers: ConstantModifierGroup {
                                modifiers: [],
                            },
                            const: Span {
                                line: 16,
                                column: 5,
                                position: 227,
                            },
                            entries: [
                                ConstantEntry {
                                    name: SimpleIdentifier {
                                        span: Span {
                                            line: 16,
                                            column: 11,
                                            position: 233,
                                        },
                                        value: "return",
                                    },
                                    equals: Span {
                                        line: 16,
                                        column: 18,
                                        position: 240,
                                    },
                                    value: Literal(
                                        Integer(
                                            LiteralInteger {
                                                value: "2433",
                                                span: Span {
                                                    line: 16,
                                                    column: 20,
                                                    position: 242,
                                                },
                                            },
                                        ),
                                    ),
                                },
                            ],
                            semicolon: Span {
                                line: 16,
                                column: 24,
                                position: 246,
                            },
                        },
                    ),
                    Constant(
                        ClassishConstant {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            modifiers: ConstantModifierGroup {
                                modifiers: [],
                            },
                            const: Span {
                                line: 17,
                                column: 5,
                                position: 252,
                            },
                            entries: [
                                ConstantEntry {
                                    name: SimpleIdentifier {
                                        span: Span {
                                            line: 17,
                                            column: 11,
                                            position: 258,
                                        },
                                        value: "parent",
                                    },
                                    equals: Span {
                                        line: 17,
                                        column: 18,
                                        position: 265,
                                    },
                                    value: Literal(
                                        Integer(
                                            LiteralInteger {
                                                value: "2543",
                                                span: Span {
                                                    line: 17,
                                                    column: 20,
                                                    position: 267,
                                                },
                                            },
                                        ),
                                    ),
                                },
                            ],
                            semicolon: Span {
                                line: 17,
                                column: 24,
                                position: 271,
                            },
                        },
                    ),
                    Constant(
                        ClassishConstant {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            modifiers: ConstantModifierGroup {
                                modifiers: [],
                            },
                            const: Span {
                                line: 18,
                                column: 5,
                                position: 277,
                            },
                            entries: [
                                ConstantEntry {
                                    name: SimpleIdentifier {
                                        span: Span {
                                            line: 18,
                                            column: 11,
                                            position: 283,
                                        },
                                        value: "enum",
                                    },
                                    equals: Span {
                                        line: 18,
                                        column: 16,
                                        position: 288,
                                    },
                                    value: Literal(
                                        Integer(
                                            LiteralInteger {
                                                value: "24133",
                                                span: Span {
                                                    line: 18,
                                                    column: 18,
                                                    position: 290,
                                                },
                                            },
                                        ),
                                    ),
                                },
                            ],
                            semicolon: Span {
                                line: 18,
                                column: 23,
                                position: 295,
                            },
                        },
                    ),
                    Constant(
                        ClassishConstant {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            modifiers: ConstantModifierGroup {
                                modifiers: [],
                            },
                            const: Span {
                                line: 19,
                                column: 5,
                                position: 301,
                            },
                            entries: [
                                ConstantEntry {
                                    name: SimpleIdentifier {
                                        span: Span {
                                            line: 19,
                                            column: 11,
                                            position: 307,
                                        },
                                        value: "from",
                                    },
                                    equals: Span {
                                        line: 19,
                                        column: 16,
                                        position: 312,
                                    },
                                    value: Literal(
                                        Integer(
                                            LiteralInteger {
                                                value: "25443",
                                                span: Span {
                                                    line: 19,
                                                    column: 18,
                                                    position: 314,
                                                },
                                            },
                                        ),
                                    ),
                                },
                            ],
                            semicolon: Span {
                                line: 19,
                                column: 23,
                                position: 319,
                            },
                        },
                    ),
                ],
                right_brace: Span {
                    line: 20,
                    column: 1,
                    position: 321,
                },
            },
        },
    ),
    Constant(
        ConstantStatement {
            comments: CommentGroup {
                comments: [],
            },
            const: Span {
                line: 22,
                column: 1,
                position: 324,
            },
            entries: [
                ConstantEntry {
                    name: SimpleIdentifier {
                        span: Span {
                            line: 22,
                            column: 7,
                            position: 330,
                        },
                        value: "from",
                    },
                    equals: Span {
                        line: 22,
                        column: 12,
                        position: 335,
                    },
                    value: Literal(
                        Integer(
                            LiteralInteger {
                                value: "243",
                                span: Span {
                                    line: 22,
                                    column: 14,
                                    position: 337,
                                },
                            },
                        ),
                    ),
                },
            ],
            semicolon: Span {
                line: 22,
                column: 17,
                position: 340,
            },
        },
    ),
    Constant(
        ConstantStatement {
            comments: CommentGroup {
                comments: [],
            },
            const: Span {
                line: 23,
                column: 1,
                position: 342,
            },
            entries: [
                ConstantEntry {
                    name: SimpleIdentifier {
                        span: Span {
                            line: 23,
                            column: 7,
                            position: 348,
                        },
                        value: "enum",
                    },
                    equals: Span {
                        line: 23,
                        column: 12,
                        position: 353,
                    },
                    value: Literal(
                        Integer(
                            LiteralInteger {
                                value: "243",
                                span: Span {
                                    line: 23,
                                    column: 14,
                                    position: 355,
                                },
                            },
                        ),
                    ),
                },
            ],
            semicolon: Span {
                line: 23,
                column: 17,
                position: 358,
            },
        },
    ),
]