TransUnit(
    [
        DefModule {
            name: Name {
                data: "DefinitionsAndSpecifiers",
                node_id: Span {
                    start: <stdin>:2:8,
                    end: <stdin>:2:32,
                },
            },
            members: [
                DefAliasType {
                    name: Name {
                        data: "FwSizeStoreType",
                        node_id: Span {
                            start: <stdin>:4:8,
                            end: <stdin>:4:23,
                        },
                    },
                    type_name: TypeName {
                        kind: Integer(
                            U16,
                        ),
                        node_id: Span {
                            start: <stdin>:4:26,
                            end: <stdin>:4:29,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:4:3,
                        end: <stdin>:4:29,
                    },
                },
                DefConstant {
                    name: Name {
                        data: "FW_FIXED_LENGTH_STRING_SIZE",
                        node_id: Span {
                            start: <stdin>:5:12,
                            end: <stdin>:5:39,
                        },
                    },
                    value: Expr {
                        kind: LiteralInt(
                            "256",
                        ),
                        node_id: Span {
                            start: <stdin>:5:42,
                            end: <stdin>:5:45,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:5:3,
                        end: <stdin>:5:45,
                    },
                },
                DefAbsType {
                    name: Name {
                        data: "T",
                        node_id: Span {
                            start: <stdin>:8:8,
                            end: <stdin>:8:9,
                        },
                    },
                    node_id: Span {
                        start: <stdin>:8:3,
                        end: <stdin>:8:9,
                    },
                    pre_annotation: [
                        "Abstract type definition",
                    ],
                    post_annotation: [
                        "Abstract type definition",
                    ],
                },
                DefAliasType {
                    name: Name {
                        data: "TA",
                        node_id: Span {
                            start: <stdin>:12:8,
                            end: <stdin>:12:10,
                        },
                    },
                    type_name: TypeName {
                        kind: QualIdent(
                            Unqualified {
                                name: Ident {
                                    data: "T",
                                    node_id: Span {
                                        start: <stdin>:12:13,
                                        end: <stdin>:12:14,
                                    },
                                },
                                is_absolute: false,
                                node_id: Span {
                                    start: <stdin>:12:13,
                                    end: <stdin>:12:14,
                                },
                            },
                        ),
                        node_id: Span {
                            start: <stdin>:12:13,
                            end: <stdin>:12:14,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:12:3,
                        end: <stdin>:12:14,
                    },
                    pre_annotation: [
                        "Type alias definition",
                    ],
                    post_annotation: [
                        "Type alias definition",
                    ],
                },
                DefArray {
                    name: Name {
                        data: "A",
                        node_id: Span {
                            start: <stdin>:16:9,
                            end: <stdin>:16:10,
                        },
                    },
                    size: Expr {
                        kind: LiteralInt(
                            "10",
                        ),
                        node_id: Span {
                            start: <stdin>:16:14,
                            end: <stdin>:16:16,
                        },
                    },
                    elt_type: TypeName {
                        kind: Integer(
                            U32,
                        ),
                        node_id: Span {
                            start: <stdin>:16:18,
                            end: <stdin>:16:21,
                        },
                    },
                    default: Some(
                        Expr {
                            kind: LiteralInt(
                                "0",
                            ),
                            node_id: Span {
                                start: <stdin>:16:30,
                                end: <stdin>:16:31,
                            },
                        },
                    ),
                    format: Some(
                        LitString {
                            data: "{} counts",
                            inner_span: Span {
                                start: <stdin>:16:40,
                                end: <stdin>:16:49,
                            },
                            node_id: Span {
                                start: <stdin>:16:39,
                                end: <stdin>:16:50,
                            },
                        },
                    ),
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:16:3,
                        end: <stdin>:16:50,
                    },
                    pre_annotation: [
                        "Array definition",
                    ],
                    post_annotation: [
                        "Array definition",
                    ],
                },
                DefStateMachine {
                    name: Name {
                        data: "SO",
                        node_id: Span {
                            start: <stdin>:20:17,
                            end: <stdin>:20:19,
                        },
                    },
                    members: None,
                    node_id: Span {
                        start: <stdin>:20:3,
                        end: <stdin>:20:19,
                    },
                    pre_annotation: [
                        "State machine outside a component",
                    ],
                    post_annotation: [
                        "State machine outside a component",
                    ],
                },
                DefInterface {
                    name: Name {
                        data: "I",
                        node_id: Span {
                            start: <stdin>:24:13,
                            end: <stdin>:24:14,
                        },
                    },
                    members: [
                        SpecGeneralPortInstance {
                            kind: Input(
                                Sync,
                            ),
                            name: Name {
                                data: "pI",
                                node_id: Span {
                                    start: <stdin>:26:21,
                                    end: <stdin>:26:23,
                                },
                            },
                            size: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "10",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:26:26,
                                        end: <stdin>:26:28,
                                    },
                                },
                            ),
                            port: Some(
                                Unqualified {
                                    name: Ident {
                                        data: "P",
                                        node_id: Span {
                                            start: <stdin>:26:30,
                                            end: <stdin>:26:31,
                                        },
                                    },
                                    is_absolute: false,
                                    node_id: Span {
                                        start: <stdin>:26:30,
                                        end: <stdin>:26:31,
                                    },
                                },
                            ),
                            priority: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "10",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:26:41,
                                        end: <stdin>:26:43,
                                    },
                                },
                            ),
                            queue_full: Some(
                                QueueFullSpecifier {
                                    kind: Assert,
                                    node_id: Span {
                                        start: <stdin>:26:44,
                                        end: <stdin>:26:50,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:26:5,
                                end: <stdin>:26:50,
                            },
                            pre_annotation: [
                                "General port instance specifier",
                            ],
                            post_annotation: [
                                "General port instance specifier",
                            ],
                        },
                        SpecSpecialPortInstance {
                            input_kind: None,
                            kind: CommandRecv,
                            name: Name {
                                data: "cmdIn",
                                node_id: Span {
                                    start: <stdin>:30:23,
                                    end: <stdin>:30:28,
                                },
                            },
                            priority: None,
                            queue_full: None,
                            node_id: Span {
                                start: <stdin>:30:5,
                                end: <stdin>:30:28,
                            },
                            pre_annotation: [
                                "Special port instance specifier",
                            ],
                            post_annotation: [
                                "Special port instance specifier",
                            ],
                        },
                        SpecInterfaceImport {
                            interface: Unqualified {
                                name: Ident {
                                    data: "J",
                                    node_id: Span {
                                        start: <stdin>:34:12,
                                        end: <stdin>:34:13,
                                    },
                                },
                                is_absolute: false,
                                node_id: Span {
                                    start: <stdin>:34:12,
                                    end: <stdin>:34:13,
                                },
                            },
                            node_id: Span {
                                start: <stdin>:34:5,
                                end: <stdin>:34:13,
                            },
                            pre_annotation: [
                                "Interface import specifier",
                            ],
                            post_annotation: [
                                "Interface import specifier",
                            ],
                        },
                    ],
                    node_id: Span {
                        start: <stdin>:24:3,
                        end: <stdin>:36:4,
                    },
                    pre_annotation: [
                        "Interface definition",
                    ],
                    post_annotation: [
                        "Interface definition",
                    ],
                },
                DefComponent {
                    kind: Active,
                    name: Name {
                        data: "C",
                        node_id: Span {
                            start: <stdin>:40:20,
                            end: <stdin>:40:21,
                        },
                    },
                    members: [
                        DefAbsType {
                            name: Name {
                                data: "T",
                                node_id: Span {
                                    start: <stdin>:42:10,
                                    end: <stdin>:42:11,
                                },
                            },
                            node_id: Span {
                                start: <stdin>:42:5,
                                end: <stdin>:42:11,
                            },
                        },
                        DefArray {
                            name: Name {
                                data: "A",
                                node_id: Span {
                                    start: <stdin>:43:11,
                                    end: <stdin>:43:12,
                                },
                            },
                            size: Expr {
                                kind: LiteralInt(
                                    "3",
                                ),
                                node_id: Span {
                                    start: <stdin>:43:16,
                                    end: <stdin>:43:17,
                                },
                            },
                            elt_type: TypeName {
                                kind: Integer(
                                    U32,
                                ),
                                node_id: Span {
                                    start: <stdin>:43:19,
                                    end: <stdin>:43:22,
                                },
                            },
                            default: None,
                            format: None,
                            is_dictionary_def: false,
                            node_id: Span {
                                start: <stdin>:43:5,
                                end: <stdin>:43:22,
                            },
                        },
                        DefStruct {
                            name: Name {
                                data: "S",
                                node_id: Span {
                                    start: <stdin>:44:12,
                                    end: <stdin>:44:13,
                                },
                            },
                            members: [
                                StructTypeMember {
                                    name: Name {
                                        data: "x",
                                        node_id: Span {
                                            start: <stdin>:44:16,
                                            end: <stdin>:44:17,
                                        },
                                    },
                                    size: Some(
                                        Expr {
                                            kind: LiteralInt(
                                                "3",
                                            ),
                                            node_id: Span {
                                                start: <stdin>:44:20,
                                                end: <stdin>:44:21,
                                            },
                                        },
                                    ),
                                    type_name: TypeName {
                                        kind: Integer(
                                            U32,
                                        ),
                                        node_id: Span {
                                            start: <stdin>:44:23,
                                            end: <stdin>:44:26,
                                        },
                                    },
                                    format: None,
                                    node_id: Span {
                                        start: <stdin>:44:16,
                                        end: <stdin>:44:26,
                                    },
                                },
                                StructTypeMember {
                                    name: Name {
                                        data: "y",
                                        node_id: Span {
                                            start: <stdin>:44:28,
                                            end: <stdin>:44:29,
                                        },
                                    },
                                    size: None,
                                    type_name: TypeName {
                                        kind: Floating(
                                            F32,
                                        ),
                                        node_id: Span {
                                            start: <stdin>:44:31,
                                            end: <stdin>:44:34,
                                        },
                                    },
                                    format: None,
                                    node_id: Span {
                                        start: <stdin>:44:28,
                                        end: <stdin>:44:34,
                                    },
                                },
                                StructTypeMember {
                                    name: Name {
                                        data: "z",
                                        node_id: Span {
                                            start: <stdin>:44:36,
                                            end: <stdin>:44:37,
                                        },
                                    },
                                    size: None,
                                    type_name: TypeName {
                                        kind: String(
                                            None,
                                        ),
                                        node_id: Span {
                                            start: <stdin>:44:39,
                                            end: <stdin>:44:45,
                                        },
                                    },
                                    format: None,
                                    node_id: Span {
                                        start: <stdin>:44:36,
                                        end: <stdin>:44:45,
                                    },
                                },
                            ],
                            default: None,
                            is_dictionary_def: false,
                            node_id: Span {
                                start: <stdin>:44:5,
                                end: <stdin>:44:47,
                            },
                        },
                        DefEnum {
                            name: Name {
                                data: "E",
                                node_id: Span {
                                    start: <stdin>:45:10,
                                    end: <stdin>:45:11,
                                },
                            },
                            type_name: None,
                            constants: [
                                DefEnumConstant {
                                    name: Name {
                                        data: "X",
                                        node_id: Span {
                                            start: <stdin>:45:14,
                                            end: <stdin>:45:15,
                                        },
                                    },
                                    value: None,
                                    node_id: Span {
                                        start: <stdin>:45:14,
                                        end: <stdin>:45:15,
                                    },
                                },
                                DefEnumConstant {
                                    name: Name {
                                        data: "Y",
                                        node_id: Span {
                                            start: <stdin>:45:17,
                                            end: <stdin>:45:18,
                                        },
                                    },
                                    value: None,
                                    node_id: Span {
                                        start: <stdin>:45:17,
                                        end: <stdin>:45:18,
                                    },
                                },
                                DefEnumConstant {
                                    name: Name {
                                        data: "Z",
                                        node_id: Span {
                                            start: <stdin>:45:20,
                                            end: <stdin>:45:21,
                                        },
                                    },
                                    value: None,
                                    node_id: Span {
                                        start: <stdin>:45:20,
                                        end: <stdin>:45:21,
                                    },
                                },
                            ],
                            default: Some(
                                Expr {
                                    kind: Ident {
                                        value: "X",
                                        is_absolute: false,
                                    },
                                    node_id: Span {
                                        start: <stdin>:45:32,
                                        end: <stdin>:45:33,
                                    },
                                },
                            ),
                            is_dictionary_def: false,
                            node_id: Span {
                                start: <stdin>:45:5,
                                end: <stdin>:45:33,
                            },
                        },
                        SpecContainer {
                            name: Name {
                                data: "C",
                                node_id: Span {
                                    start: <stdin>:48:23,
                                    end: <stdin>:48:24,
                                },
                            },
                            id: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "0x00",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:48:28,
                                        end: <stdin>:48:32,
                                    },
                                },
                            ),
                            default_priority: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "10",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:48:50,
                                        end: <stdin>:48:52,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:48:5,
                                end: <stdin>:48:52,
                            },
                            pre_annotation: [
                                "Container specifier",
                            ],
                            post_annotation: [
                                "Container specifier",
                            ],
                        },
                        SpecRecord {
                            name: Name {
                                data: "R",
                                node_id: Span {
                                    start: <stdin>:52:20,
                                    end: <stdin>:52:21,
                                },
                            },
                            record_type: TypeName {
                                kind: Integer(
                                    U32,
                                ),
                                node_id: Span {
                                    start: <stdin>:52:23,
                                    end: <stdin>:52:26,
                                },
                            },
                            is_array: true,
                            id: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "0x00",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:52:36,
                                        end: <stdin>:52:40,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:52:5,
                                end: <stdin>:52:40,
                            },
                            pre_annotation: [
                                "Record specifier",
                            ],
                            post_annotation: [
                                "Record specifier",
                            ],
                        },
                        SpecCommand {
                            kind: Async,
                            name: Name {
                                data: "C",
                                node_id: Span {
                                    start: <stdin>:56:19,
                                    end: <stdin>:56:20,
                                },
                            },
                            params: [
                                FormalParam {
                                    kind: Value,
                                    name: Name {
                                        data: "a",
                                        node_id: Span {
                                            start: <stdin>:56:21,
                                            end: <stdin>:56:22,
                                        },
                                    },
                                    type_name: TypeName {
                                        kind: Integer(
                                            U32,
                                        ),
                                        node_id: Span {
                                            start: <stdin>:56:24,
                                            end: <stdin>:56:27,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:56:21,
                                        end: <stdin>:56:27,
                                    },
                                },
                                FormalParam {
                                    kind: Value,
                                    name: Name {
                                        data: "b",
                                        node_id: Span {
                                            start: <stdin>:56:29,
                                            end: <stdin>:56:30,
                                        },
                                    },
                                    type_name: TypeName {
                                        kind: Floating(
                                            F32,
                                        ),
                                        node_id: Span {
                                            start: <stdin>:56:32,
                                            end: <stdin>:56:35,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:56:29,
                                        end: <stdin>:56:35,
                                    },
                                },
                            ],
                            opcode: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "0x00",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:56:44,
                                        end: <stdin>:56:48,
                                    },
                                },
                            ),
                            priority: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "10",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:56:58,
                                        end: <stdin>:56:60,
                                    },
                                },
                            ),
                            queue_full: Some(
                                QueueFullSpecifier {
                                    kind: Assert,
                                    node_id: Span {
                                        start: <stdin>:56:61,
                                        end: <stdin>:56:67,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:56:5,
                                end: <stdin>:56:67,
                            },
                            pre_annotation: [
                                "Command specifier",
                            ],
                            post_annotation: [
                                "Command specifier",
                            ],
                        },
                        SpecParam {
                            name: Name {
                                data: "P",
                                node_id: Span {
                                    start: <stdin>:60:20,
                                    end: <stdin>:60:21,
                                },
                            },
                            type_name: TypeName {
                                kind: Integer(
                                    U32,
                                ),
                                node_id: Span {
                                    start: <stdin>:60:23,
                                    end: <stdin>:60:26,
                                },
                            },
                            default: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "0",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:60:35,
                                        end: <stdin>:60:36,
                                    },
                                },
                            ),
                            id: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "0x00",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:60:40,
                                        end: <stdin>:60:44,
                                    },
                                },
                            ),
                            set_opcode: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "0x01",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:60:56,
                                        end: <stdin>:60:60,
                                    },
                                },
                            ),
                            save_opcode: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "0x02",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:60:73,
                                        end: <stdin>:60:77,
                                    },
                                },
                            ),
                            is_external: true,
                            node_id: Span {
                                start: <stdin>:60:5,
                                end: <stdin>:60:77,
                            },
                            pre_annotation: [
                                "Parameter specifier",
                            ],
                            post_annotation: [
                                "Parameter specifier",
                            ],
                        },
                        SpecGeneralPortInstance {
                            kind: Input(
                                Sync,
                            ),
                            name: Name {
                                data: "p1",
                                node_id: Span {
                                    start: <stdin>:64:21,
                                    end: <stdin>:64:23,
                                },
                            },
                            size: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "10",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:64:26,
                                        end: <stdin>:64:28,
                                    },
                                },
                            ),
                            port: Some(
                                Unqualified {
                                    name: Ident {
                                        data: "P",
                                        node_id: Span {
                                            start: <stdin>:64:30,
                                            end: <stdin>:64:31,
                                        },
                                    },
                                    is_absolute: false,
                                    node_id: Span {
                                        start: <stdin>:64:30,
                                        end: <stdin>:64:31,
                                    },
                                },
                            ),
                            priority: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "10",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:64:41,
                                        end: <stdin>:64:43,
                                    },
                                },
                            ),
                            queue_full: Some(
                                QueueFullSpecifier {
                                    kind: Assert,
                                    node_id: Span {
                                        start: <stdin>:64:44,
                                        end: <stdin>:64:50,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:64:5,
                                end: <stdin>:64:50,
                            },
                            pre_annotation: [
                                "General port instance specifier",
                            ],
                            post_annotation: [
                                "General port instance specifier",
                            ],
                        },
                        SpecSpecialPortInstance {
                            input_kind: None,
                            kind: CommandRecv,
                            name: Name {
                                data: "cmdIn",
                                node_id: Span {
                                    start: <stdin>:68:23,
                                    end: <stdin>:68:28,
                                },
                            },
                            priority: None,
                            queue_full: None,
                            node_id: Span {
                                start: <stdin>:68:5,
                                end: <stdin>:68:28,
                            },
                            pre_annotation: [
                                "Special port instance specifier",
                            ],
                            post_annotation: [
                                "Special port instance specifier",
                            ],
                        },
                        SpecSpecialPortInstance {
                            input_kind: Some(
                                Async,
                            ),
                            kind: ProductRecv,
                            name: Name {
                                data: "productRecvIn",
                                node_id: Span {
                                    start: <stdin>:72:29,
                                    end: <stdin>:72:42,
                                },
                            },
                            priority: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "10",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:72:52,
                                        end: <stdin>:72:54,
                                    },
                                },
                            ),
                            queue_full: Some(
                                QueueFullSpecifier {
                                    kind: Assert,
                                    node_id: Span {
                                        start: <stdin>:72:55,
                                        end: <stdin>:72:61,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:72:5,
                                end: <stdin>:72:61,
                            },
                            pre_annotation: [
                                "Async product receive port",
                            ],
                            post_annotation: [
                                "Async product receive port",
                            ],
                        },
                        DefStateMachine {
                            name: Name {
                                data: "SM",
                                node_id: Span {
                                    start: <stdin>:76:19,
                                    end: <stdin>:76:21,
                                },
                            },
                            members: None,
                            node_id: Span {
                                start: <stdin>:76:5,
                                end: <stdin>:76:21,
                            },
                            pre_annotation: [
                                "Internal Component State machine definition",
                            ],
                            post_annotation: [
                                "State machine definition",
                            ],
                        },
                        SpecStateMachineInstance {
                            name: Name {
                                data: "s1",
                                node_id: Span {
                                    start: <stdin>:80:28,
                                    end: <stdin>:80:30,
                                },
                            },
                            state_machine: Unqualified {
                                name: Ident {
                                    data: "SM",
                                    node_id: Span {
                                        start: <stdin>:80:32,
                                        end: <stdin>:80:34,
                                    },
                                },
                                is_absolute: false,
                                node_id: Span {
                                    start: <stdin>:80:32,
                                    end: <stdin>:80:34,
                                },
                            },
                            priority: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "10",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:80:44,
                                        end: <stdin>:80:46,
                                    },
                                },
                            ),
                            queue_full: Some(
                                Drop,
                            ),
                            node_id: Span {
                                start: <stdin>:80:5,
                                end: <stdin>:80:51,
                            },
                            pre_annotation: [
                                "State machine instance 1",
                            ],
                            post_annotation: [
                                "State machine instance 1",
                            ],
                        },
                        SpecStateMachineInstance {
                            name: Name {
                                data: "s2",
                                node_id: Span {
                                    start: <stdin>:84:28,
                                    end: <stdin>:84:30,
                                },
                            },
                            state_machine: Unqualified {
                                name: Ident {
                                    data: "SM",
                                    node_id: Span {
                                        start: <stdin>:84:32,
                                        end: <stdin>:84:34,
                                    },
                                },
                                is_absolute: false,
                                node_id: Span {
                                    start: <stdin>:84:32,
                                    end: <stdin>:84:34,
                                },
                            },
                            priority: None,
                            queue_full: None,
                            node_id: Span {
                                start: <stdin>:84:5,
                                end: <stdin>:84:34,
                            },
                            pre_annotation: [
                                "State machine instance 2",
                            ],
                            post_annotation: [
                                "State machine instance 2",
                            ],
                        },
                        SpecStateMachineInstance {
                            name: Name {
                                data: "so",
                                node_id: Span {
                                    start: <stdin>:88:28,
                                    end: <stdin>:88:30,
                                },
                            },
                            state_machine: Unqualified {
                                name: Ident {
                                    data: "SO",
                                    node_id: Span {
                                        start: <stdin>:88:32,
                                        end: <stdin>:88:34,
                                    },
                                },
                                is_absolute: false,
                                node_id: Span {
                                    start: <stdin>:88:32,
                                    end: <stdin>:88:34,
                                },
                            },
                            priority: None,
                            queue_full: None,
                            node_id: Span {
                                start: <stdin>:88:5,
                                end: <stdin>:88:34,
                            },
                            pre_annotation: [
                                "State machine for outside definition",
                            ],
                            post_annotation: [
                                "State machine for outside definition",
                            ],
                        },
                        SpecGeneralPortInstance {
                            kind: Output,
                            name: Name {
                                data: "p2",
                                node_id: Span {
                                    start: <stdin>:91:17,
                                    end: <stdin>:91:19,
                                },
                            },
                            size: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "10",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:91:22,
                                        end: <stdin>:91:24,
                                    },
                                },
                            ),
                            port: Some(
                                Unqualified {
                                    name: Ident {
                                        data: "P",
                                        node_id: Span {
                                            start: <stdin>:91:26,
                                            end: <stdin>:91:27,
                                        },
                                    },
                                    is_absolute: false,
                                    node_id: Span {
                                        start: <stdin>:91:26,
                                        end: <stdin>:91:27,
                                    },
                                },
                            ),
                            priority: None,
                            queue_full: None,
                            node_id: Span {
                                start: <stdin>:91:5,
                                end: <stdin>:91:27,
                            },
                        },
                        SpecPortMatching {
                            port1: Ident {
                                data: "p1",
                                node_id: Span {
                                    start: <stdin>:93:11,
                                    end: <stdin>:93:13,
                                },
                            },
                            port2: Ident {
                                data: "p2",
                                node_id: Span {
                                    start: <stdin>:93:19,
                                    end: <stdin>:93:21,
                                },
                            },
                            node_id: Span {
                                start: <stdin>:93:5,
                                end: <stdin>:93:21,
                            },
                            pre_annotation: [
                                "Port matching specifier",
                            ],
                            post_annotation: [
                                "Port matching specifier",
                            ],
                        },
                        SpecTlmChannel {
                            name: Name {
                                data: "T",
                                node_id: Span {
                                    start: <stdin>:97:15,
                                    end: <stdin>:97:16,
                                },
                            },
                            type_name: TypeName {
                                kind: Integer(
                                    U32,
                                ),
                                node_id: Span {
                                    start: <stdin>:97:18,
                                    end: <stdin>:97:21,
                                },
                            },
                            id: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "0x00",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:97:25,
                                        end: <stdin>:97:29,
                                    },
                                },
                            ),
                            update: Some(
                                OnChange,
                            ),
                            format: Some(
                                LitString {
                                    data: "{} s",
                                    inner_span: Span {
                                        start: <stdin>:97:55,
                                        end: <stdin>:97:59,
                                    },
                                    node_id: Span {
                                        start: <stdin>:97:54,
                                        end: <stdin>:97:60,
                                    },
                                },
                            ),
                            low: [
                                TlmChannelLimit {
                                    kind: Red,
                                    value: Expr {
                                        kind: LiteralInt(
                                            "0",
                                        ),
                                        node_id: Span {
                                            start: <stdin>:98:17,
                                            end: <stdin>:98:18,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:98:13,
                                        end: <stdin>:98:18,
                                    },
                                },
                                TlmChannelLimit {
                                    kind: Orange,
                                    value: Expr {
                                        kind: LiteralInt(
                                            "1",
                                        ),
                                        node_id: Span {
                                            start: <stdin>:98:27,
                                            end: <stdin>:98:28,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:98:20,
                                        end: <stdin>:98:28,
                                    },
                                },
                                TlmChannelLimit {
                                    kind: Yellow,
                                    value: Expr {
                                        kind: LiteralInt(
                                            "2",
                                        ),
                                        node_id: Span {
                                            start: <stdin>:98:37,
                                            end: <stdin>:98:38,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:98:30,
                                        end: <stdin>:98:38,
                                    },
                                },
                            ],
                            high: [
                                TlmChannelLimit {
                                    kind: Yellow,
                                    value: Expr {
                                        kind: LiteralInt(
                                            "10",
                                        ),
                                        node_id: Span {
                                            start: <stdin>:99:21,
                                            end: <stdin>:99:23,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:99:14,
                                        end: <stdin>:99:23,
                                    },
                                },
                                TlmChannelLimit {
                                    kind: Orange,
                                    value: Expr {
                                        kind: LiteralInt(
                                            "11",
                                        ),
                                        node_id: Span {
                                            start: <stdin>:99:32,
                                            end: <stdin>:99:34,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:99:25,
                                        end: <stdin>:99:34,
                                    },
                                },
                                TlmChannelLimit {
                                    kind: Red,
                                    value: Expr {
                                        kind: LiteralInt(
                                            "12",
                                        ),
                                        node_id: Span {
                                            start: <stdin>:99:40,
                                            end: <stdin>:99:42,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:99:36,
                                        end: <stdin>:99:42,
                                    },
                                },
                            ],
                            node_id: Span {
                                start: <stdin>:97:5,
                                end: <stdin>:99:44,
                            },
                            pre_annotation: [
                                "Telemetry channel specifier",
                            ],
                            post_annotation: [
                                "Telemetry channel specifier",
                            ],
                        },
                        SpecEvent {
                            name: Name {
                                data: "E",
                                node_id: Span {
                                    start: <stdin>:103:11,
                                    end: <stdin>:103:12,
                                },
                            },
                            params: [
                                FormalParam {
                                    kind: Value,
                                    name: Name {
                                        data: "a",
                                        node_id: Span {
                                            start: <stdin>:103:13,
                                            end: <stdin>:103:14,
                                        },
                                    },
                                    type_name: TypeName {
                                        kind: Integer(
                                            U32,
                                        ),
                                        node_id: Span {
                                            start: <stdin>:103:16,
                                            end: <stdin>:103:19,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:103:13,
                                        end: <stdin>:103:19,
                                    },
                                },
                                FormalParam {
                                    kind: Value,
                                    name: Name {
                                        data: "b",
                                        node_id: Span {
                                            start: <stdin>:103:21,
                                            end: <stdin>:103:22,
                                        },
                                    },
                                    type_name: TypeName {
                                        kind: Floating(
                                            F32,
                                        ),
                                        node_id: Span {
                                            start: <stdin>:103:24,
                                            end: <stdin>:103:27,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:103:21,
                                        end: <stdin>:103:27,
                                    },
                                },
                            ],
                            severity: ActivityLow,
                            id: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "0x00",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:103:54,
                                        end: <stdin>:103:58,
                                    },
                                },
                            ),
                            format: LitString {
                                data: "{} counts",
                                inner_span: Span {
                                    start: <stdin>:103:67,
                                    end: <stdin>:103:76,
                                },
                                node_id: Span {
                                    start: <stdin>:103:66,
                                    end: <stdin>:103:77,
                                },
                            },
                            throttle: Some(
                                EventThrottle {
                                    count: Expr {
                                        kind: LiteralInt(
                                            "10",
                                        ),
                                        node_id: Span {
                                            start: <stdin>:103:87,
                                            end: <stdin>:103:89,
                                        },
                                    },
                                    every: None,
                                    node_id: Span {
                                        start: <stdin>:103:78,
                                        end: <stdin>:103:89,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:103:5,
                                end: <stdin>:103:89,
                            },
                            pre_annotation: [
                                "Event specifier",
                            ],
                            post_annotation: [
                                "Event specifier",
                            ],
                        },
                        SpecEvent {
                            name: Name {
                                data: "ET",
                                node_id: Span {
                                    start: <stdin>:107:11,
                                    end: <stdin>:107:13,
                                },
                            },
                            params: [
                                FormalParam {
                                    kind: Value,
                                    name: Name {
                                        data: "a",
                                        node_id: Span {
                                            start: <stdin>:107:14,
                                            end: <stdin>:107:15,
                                        },
                                    },
                                    type_name: TypeName {
                                        kind: Integer(
                                            U32,
                                        ),
                                        node_id: Span {
                                            start: <stdin>:107:17,
                                            end: <stdin>:107:20,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:107:14,
                                        end: <stdin>:107:20,
                                    },
                                },
                                FormalParam {
                                    kind: Value,
                                    name: Name {
                                        data: "b",
                                        node_id: Span {
                                            start: <stdin>:107:22,
                                            end: <stdin>:107:23,
                                        },
                                    },
                                    type_name: TypeName {
                                        kind: Floating(
                                            F32,
                                        ),
                                        node_id: Span {
                                            start: <stdin>:107:25,
                                            end: <stdin>:107:28,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:107:22,
                                        end: <stdin>:107:28,
                                    },
                                },
                            ],
                            severity: ActivityHigh,
                            id: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "0x00",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:107:56,
                                        end: <stdin>:107:60,
                                    },
                                },
                            ),
                            format: LitString {
                                data: "{} counts",
                                inner_span: Span {
                                    start: <stdin>:107:69,
                                    end: <stdin>:107:78,
                                },
                                node_id: Span {
                                    start: <stdin>:107:68,
                                    end: <stdin>:107:79,
                                },
                            },
                            throttle: Some(
                                EventThrottle {
                                    count: Expr {
                                        kind: LiteralInt(
                                            "10",
                                        ),
                                        node_id: Span {
                                            start: <stdin>:107:89,
                                            end: <stdin>:107:91,
                                        },
                                    },
                                    every: Some(
                                        Expr {
                                            kind: Struct(
                                                [
                                                    StructExprMember {
                                                        name: Name {
                                                            data: "seconds",
                                                            node_id: Span {
                                                                start: <stdin>:107:99,
                                                                end: <stdin>:107:106,
                                                            },
                                                        },
                                                        value: Expr {
                                                            kind: LiteralInt(
                                                                "10",
                                                            ),
                                                            node_id: Span {
                                                                start: <stdin>:107:107,
                                                                end: <stdin>:107:109,
                                                            },
                                                        },
                                                        node_id: Span {
                                                            start: <stdin>:107:99,
                                                            end: <stdin>:107:109,
                                                        },
                                                    },
                                                ],
                                            ),
                                            node_id: Span {
                                                start: <stdin>:107:98,
                                                end: <stdin>:107:110,
                                            },
                                        },
                                    ),
                                    node_id: Span {
                                        start: <stdin>:107:80,
                                        end: <stdin>:107:110,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:107:5,
                                end: <stdin>:107:110,
                            },
                            pre_annotation: [
                                "Event specifier with throttle timeout",
                            ],
                            post_annotation: [
                                "Event specifier",
                            ],
                        },
                        SpecInternalPort {
                            name: Name {
                                data: "I",
                                node_id: Span {
                                    start: <stdin>:111:19,
                                    end: <stdin>:111:20,
                                },
                            },
                            params: [
                                FormalParam {
                                    kind: Value,
                                    name: Name {
                                        data: "a",
                                        node_id: Span {
                                            start: <stdin>:111:21,
                                            end: <stdin>:111:22,
                                        },
                                    },
                                    type_name: TypeName {
                                        kind: Integer(
                                            U32,
                                        ),
                                        node_id: Span {
                                            start: <stdin>:111:24,
                                            end: <stdin>:111:27,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:111:21,
                                        end: <stdin>:111:27,
                                    },
                                },
                                FormalParam {
                                    kind: Value,
                                    name: Name {
                                        data: "b",
                                        node_id: Span {
                                            start: <stdin>:111:29,
                                            end: <stdin>:111:30,
                                        },
                                    },
                                    type_name: TypeName {
                                        kind: Floating(
                                            F32,
                                        ),
                                        node_id: Span {
                                            start: <stdin>:111:32,
                                            end: <stdin>:111:35,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:111:29,
                                        end: <stdin>:111:35,
                                    },
                                },
                            ],
                            priority: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "10",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:111:46,
                                        end: <stdin>:111:48,
                                    },
                                },
                            ),
                            queue_full: Some(
                                Assert,
                            ),
                            node_id: Span {
                                start: <stdin>:111:5,
                                end: <stdin>:111:55,
                            },
                            pre_annotation: [
                                "Internal port specifier",
                            ],
                            post_annotation: [
                                "Internal port specifier",
                            ],
                        },
                        SpecInterfaceImport {
                            interface: Unqualified {
                                name: Ident {
                                    data: "I",
                                    node_id: Span {
                                        start: <stdin>:115:12,
                                        end: <stdin>:115:13,
                                    },
                                },
                                is_absolute: false,
                                node_id: Span {
                                    start: <stdin>:115:12,
                                    end: <stdin>:115:13,
                                },
                            },
                            node_id: Span {
                                start: <stdin>:115:5,
                                end: <stdin>:115:13,
                            },
                            pre_annotation: [
                                "Interface import specifier",
                            ],
                            post_annotation: [
                                "Interface import specifier",
                            ],
                        },
                    ],
                    node_id: Span {
                        start: <stdin>:40:3,
                        end: <stdin>:117:4,
                    },
                    pre_annotation: [
                        "Component definition",
                    ],
                    post_annotation: [
                        "Component definition",
                    ],
                },
                DefComponentInstance {
                    name: Name {
                        data: "c1",
                        node_id: Span {
                            start: <stdin>:121:12,
                            end: <stdin>:121:14,
                        },
                    },
                    component: Unqualified {
                        name: Ident {
                            data: "C1",
                            node_id: Span {
                                start: <stdin>:121:16,
                                end: <stdin>:121:18,
                            },
                        },
                        is_absolute: false,
                        node_id: Span {
                            start: <stdin>:121:16,
                            end: <stdin>:121:18,
                        },
                    },
                    base_id: Expr {
                        kind: LiteralInt(
                            "0x100",
                        ),
                        node_id: Span {
                            start: <stdin>:121:27,
                            end: <stdin>:121:32,
                        },
                    },
                    impl_type: None,
                    file: None,
                    queue_size: None,
                    stack_size: None,
                    priority: None,
                    cpu: None,
                    init_specs: [],
                    node_id: Span {
                        start: <stdin>:121:3,
                        end: <stdin>:121:32,
                    },
                    pre_annotation: [
                        "Simple component instance definition",
                    ],
                    post_annotation: [
                        "Simple component instance definition",
                    ],
                },
                DefComponentInstance {
                    name: Name {
                        data: "c2",
                        node_id: Span {
                            start: <stdin>:125:12,
                            end: <stdin>:125:14,
                        },
                    },
                    component: Unqualified {
                        name: Ident {
                            data: "C2",
                            node_id: Span {
                                start: <stdin>:125:16,
                                end: <stdin>:125:18,
                            },
                        },
                        is_absolute: false,
                        node_id: Span {
                            start: <stdin>:125:16,
                            end: <stdin>:125:18,
                        },
                    },
                    base_id: Expr {
                        kind: LiteralInt(
                            "0x200",
                        ),
                        node_id: Span {
                            start: <stdin>:125:27,
                            end: <stdin>:125:32,
                        },
                    },
                    impl_type: Some(
                        LitString {
                            data: "T",
                            inner_span: Span {
                                start: <stdin>:125:39,
                                end: <stdin>:125:40,
                            },
                            node_id: Span {
                                start: <stdin>:125:38,
                                end: <stdin>:125:41,
                            },
                        },
                    ),
                    file: Some(
                        LitString {
                            data: "C2.hpp",
                            inner_span: Span {
                                start: <stdin>:125:46,
                                end: <stdin>:125:52,
                            },
                            node_id: Span {
                                start: <stdin>:125:45,
                                end: <stdin>:125:53,
                            },
                        },
                    ),
                    queue_size: Some(
                        Expr {
                            kind: LiteralInt(
                                "100",
                            ),
                            node_id: Span {
                                start: <stdin>:125:65,
                                end: <stdin>:125:68,
                            },
                        },
                    ),
                    stack_size: Some(
                        Expr {
                            kind: LiteralInt(
                                "1024",
                            ),
                            node_id: Span {
                                start: <stdin>:125:80,
                                end: <stdin>:125:84,
                            },
                        },
                    ),
                    priority: Some(
                        Expr {
                            kind: LiteralInt(
                                "10",
                            ),
                            node_id: Span {
                                start: <stdin>:125:94,
                                end: <stdin>:125:96,
                            },
                        },
                    ),
                    cpu: Some(
                        Expr {
                            kind: LiteralInt(
                                "0",
                            ),
                            node_id: Span {
                                start: <stdin>:125:101,
                                end: <stdin>:125:102,
                            },
                        },
                    ),
                    init_specs: [
                        SpecInit {
                            phase: Expr {
                                kind: Ident {
                                    value: "CONSTRUCTION",
                                    is_absolute: false,
                                },
                                node_id: Span {
                                    start: <stdin>:127:11,
                                    end: <stdin>:127:23,
                                },
                            },
                            code: LitString {
                                data: "line 1\n  line 2\nline 3\n",
                                inner_span: Span {
                                    start: <stdin>:127:27,
                                    end: <stdin>:131:5,
                                },
                                node_id: Span {
                                    start: <stdin>:127:24,
                                    end: <stdin>:131:8,
                                },
                            },
                            node_id: Span {
                                start: <stdin>:127:5,
                                end: <stdin>:131:8,
                            },
                            pre_annotation: [
                                "Init specifier",
                            ],
                            post_annotation: [
                                "Init specifier",
                            ],
                        },
                    ],
                    node_id: Span {
                        start: <stdin>:125:3,
                        end: <stdin>:133:4,
                    },
                    pre_annotation: [
                        "Component instance definition",
                    ],
                    post_annotation: [
                        "Component instance definition",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "x",
                        node_id: Span {
                            start: <stdin>:137:12,
                            end: <stdin>:137:13,
                        },
                    },
                    value: Expr {
                        kind: LiteralInt(
                            "0",
                        ),
                        node_id: Span {
                            start: <stdin>:137:16,
                            end: <stdin>:137:17,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:137:3,
                        end: <stdin>:137:17,
                    },
                    pre_annotation: [
                        "Constant definition",
                    ],
                    post_annotation: [
                        "Constant definition",
                    ],
                },
                DefEnum {
                    name: Name {
                        data: "E",
                        node_id: Span {
                            start: <stdin>:141:8,
                            end: <stdin>:141:9,
                        },
                    },
                    type_name: Some(
                        TypeName {
                            kind: Integer(
                                I32,
                            ),
                            node_id: Span {
                                start: <stdin>:141:12,
                                end: <stdin>:141:15,
                            },
                        },
                    ),
                    constants: [
                        DefEnumConstant {
                            name: Name {
                                data: "X",
                                node_id: Span {
                                    start: <stdin>:143:5,
                                    end: <stdin>:143:6,
                                },
                            },
                            value: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "1",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:143:9,
                                        end: <stdin>:143:10,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:143:5,
                                end: <stdin>:143:10,
                            },
                            pre_annotation: [
                                "X",
                            ],
                            post_annotation: [
                                "X",
                            ],
                        },
                        DefEnumConstant {
                            name: Name {
                                data: "Y",
                                node_id: Span {
                                    start: <stdin>:146:5,
                                    end: <stdin>:146:6,
                                },
                            },
                            value: Some(
                                Expr {
                                    kind: LiteralInt(
                                        "2",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:146:9,
                                        end: <stdin>:146:10,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:146:5,
                                end: <stdin>:146:10,
                            },
                            pre_annotation: [
                                "Y",
                            ],
                            post_annotation: [
                                "Y",
                            ],
                        },
                    ],
                    default: None,
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:141:3,
                        end: <stdin>:148:4,
                    },
                    pre_annotation: [
                        "Enum definition",
                    ],
                    post_annotation: [
                        "Enum definition",
                    ],
                },
                DefModule {
                    name: Name {
                        data: "M",
                        node_id: Span {
                            start: <stdin>:152:10,
                            end: <stdin>:152:11,
                        },
                    },
                    members: [
                        DefConstant {
                            name: Name {
                                data: "x",
                                node_id: Span {
                                    start: <stdin>:154:14,
                                    end: <stdin>:154:15,
                                },
                            },
                            value: Expr {
                                kind: LiteralInt(
                                    "0",
                                ),
                                node_id: Span {
                                    start: <stdin>:154:18,
                                    end: <stdin>:154:19,
                                },
                            },
                            is_dictionary_def: false,
                            node_id: Span {
                                start: <stdin>:154:5,
                                end: <stdin>:154:19,
                            },
                        },
                    ],
                    node_id: Span {
                        start: <stdin>:152:3,
                        end: <stdin>:156:4,
                    },
                    pre_annotation: [
                        "Module definition",
                    ],
                    post_annotation: [
                        "Module definition",
                    ],
                },
                DefModule {
                    name: Name {
                        data: "Constants",
                        node_id: Span {
                            start: <stdin>:159:10,
                            end: <stdin>:159:19,
                        },
                    },
                    members: [
                        DefConstant {
                            name: Name {
                                data: "x",
                                node_id: Span {
                                    start: [ local path prefix ]/constant.fppi:2:10,
                                    end: [ local path prefix ]/constant.fppi:2:11,
                                },
                            },
                            value: Expr {
                                kind: LiteralInt(
                                    "0",
                                ),
                                node_id: Span {
                                    start: [ local path prefix ]/constant.fppi:2:14,
                                    end: [ local path prefix ]/constant.fppi:2:15,
                                },
                            },
                            is_dictionary_def: false,
                            node_id: Span {
                                start: [ local path prefix ]/constant.fppi:2:1,
                                end: [ local path prefix ]/constant.fppi:2:15,
                            },
                            pre_annotation: [
                                "Included constant",
                            ],
                            post_annotation: [
                                "Included constant",
                            ],
                        },
                    ],
                    node_id: Span {
                        start: <stdin>:159:3,
                        end: <stdin>:163:4,
                    },
                },
                DefModuleTemplate {
                    name: Name {
                        data: "MT",
                        node_id: Span {
                            start: <stdin>:166:19,
                            end: <stdin>:166:21,
                        },
                    },
                    params: [
                        TemplateParamConstant {
                            name: Name {
                                data: "c",
                                node_id: Span {
                                    start: <stdin>:168:14,
                                    end: <stdin>:168:15,
                                },
                            },
                            type_name: TypeName {
                                kind: Integer(
                                    U32,
                                ),
                                node_id: Span {
                                    start: <stdin>:168:17,
                                    end: <stdin>:168:20,
                                },
                            },
                            node_id: Span {
                                start: <stdin>:168:5,
                                end: <stdin>:168:20,
                            },
                            pre_annotation: [
                                "Constant template parameter",
                            ],
                            post_annotation: [
                                "Constant template parameter",
                            ],
                        },
                        TemplateParamType {
                            name: Name {
                                data: "Ty",
                                node_id: Span {
                                    start: <stdin>:171:10,
                                    end: <stdin>:171:12,
                                },
                            },
                            node_id: Span {
                                start: <stdin>:171:5,
                                end: <stdin>:171:12,
                            },
                            pre_annotation: [
                                "Type template parameter",
                            ],
                            post_annotation: [
                                "Type template parameter",
                            ],
                        },
                        TemplateParamInterface {
                            name: Name {
                                data: "i",
                                node_id: Span {
                                    start: <stdin>:174:14,
                                    end: <stdin>:174:15,
                                },
                            },
                            interface: Unqualified {
                                name: Ident {
                                    data: "I",
                                    node_id: Span {
                                        start: <stdin>:174:17,
                                        end: <stdin>:174:18,
                                    },
                                },
                                is_absolute: false,
                                node_id: Span {
                                    start: <stdin>:174:17,
                                    end: <stdin>:174:18,
                                },
                            },
                            node_id: Span {
                                start: <stdin>:174:5,
                                end: <stdin>:174:18,
                            },
                            pre_annotation: [
                                "Interface instance template parameter",
                            ],
                            post_annotation: [
                                "Interface instance template parameter",
                            ],
                        },
                    ],
                    members: [
                        DefConstant {
                            name: Name {
                                data: "a",
                                node_id: Span {
                                    start: <stdin>:178:14,
                                    end: <stdin>:178:15,
                                },
                            },
                            value: Expr {
                                kind: Ident {
                                    value: "c",
                                    is_absolute: false,
                                },
                                node_id: Span {
                                    start: <stdin>:178:18,
                                    end: <stdin>:178:19,
                                },
                            },
                            is_dictionary_def: false,
                            node_id: Span {
                                start: <stdin>:178:5,
                                end: <stdin>:178:19,
                            },
                        },
                    ],
                    node_id: Span {
                        start: <stdin>:166:3,
                        end: <stdin>:180:4,
                    },
                    pre_annotation: [
                        "Module template definition",
                    ],
                    post_annotation: [
                        "Module template definition",
                    ],
                },
                SpecTemplateExpand {
                    template: Unqualified {
                        name: Ident {
                            data: "MT",
                            node_id: Span {
                                start: <stdin>:184:10,
                                end: <stdin>:184:12,
                            },
                        },
                        is_absolute: false,
                        node_id: Span {
                            start: <stdin>:184:10,
                            end: <stdin>:184:12,
                        },
                    },
                    args: [
                        TemplateArg {
                            kind: Constant(
                                Expr {
                                    kind: LiteralInt(
                                        "0",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:184:22,
                                        end: <stdin>:184:23,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:184:13,
                                end: <stdin>:184:23,
                            },
                        },
                        TemplateArg {
                            kind: Type(
                                TypeName {
                                    kind: Integer(
                                        U32,
                                    ),
                                    node_id: Span {
                                        start: <stdin>:184:30,
                                        end: <stdin>:184:33,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:184:25,
                                end: <stdin>:184:33,
                            },
                        },
                        TemplateArg {
                            kind: Interface(
                                Unqualified {
                                    name: Ident {
                                        data: "i1",
                                        node_id: Span {
                                            start: <stdin>:184:44,
                                            end: <stdin>:184:46,
                                        },
                                    },
                                    is_absolute: false,
                                    node_id: Span {
                                        start: <stdin>:184:44,
                                        end: <stdin>:184:46,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:184:35,
                                end: <stdin>:184:46,
                            },
                        },
                    ],
                    members: None,
                    node_id: Span {
                        start: <stdin>:184:3,
                        end: <stdin>:184:47,
                    },
                    pre_annotation: [
                        "Unexpanded template expansion specifier",
                    ],
                    post_annotation: [
                        "Unexpanded template expansion specifier",
                    ],
                },
                SpecTemplateExpand {
                    template: Unqualified {
                        name: Ident {
                            data: "MT",
                            node_id: Span {
                                start: <stdin>:188:10,
                                end: <stdin>:188:12,
                            },
                        },
                        is_absolute: false,
                        node_id: Span {
                            start: <stdin>:188:10,
                            end: <stdin>:188:12,
                        },
                    },
                    args: [
                        TemplateArg {
                            kind: Constant(
                                Expr {
                                    kind: LiteralInt(
                                        "0",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:188:22,
                                        end: <stdin>:188:23,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:188:13,
                                end: <stdin>:188:23,
                            },
                        },
                        TemplateArg {
                            kind: Type(
                                TypeName {
                                    kind: Integer(
                                        U32,
                                    ),
                                    node_id: Span {
                                        start: <stdin>:188:30,
                                        end: <stdin>:188:33,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:188:25,
                                end: <stdin>:188:33,
                            },
                        },
                        TemplateArg {
                            kind: Interface(
                                Unqualified {
                                    name: Ident {
                                        data: "i1",
                                        node_id: Span {
                                            start: <stdin>:188:44,
                                            end: <stdin>:188:46,
                                        },
                                    },
                                    is_absolute: false,
                                    node_id: Span {
                                        start: <stdin>:188:44,
                                        end: <stdin>:188:46,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:188:35,
                                end: <stdin>:188:46,
                            },
                        },
                    ],
                    members: Some(
                        [
                            DefConstant {
                                name: Name {
                                    data: "b",
                                    node_id: Span {
                                        start: <stdin>:190:14,
                                        end: <stdin>:190:15,
                                    },
                                },
                                value: Expr {
                                    kind: LiteralInt(
                                        "0",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:190:18,
                                        end: <stdin>:190:19,
                                    },
                                },
                                is_dictionary_def: false,
                                node_id: Span {
                                    start: <stdin>:190:5,
                                    end: <stdin>:190:19,
                                },
                            },
                        ],
                    ),
                    node_id: Span {
                        start: <stdin>:188:3,
                        end: <stdin>:192:4,
                    },
                    pre_annotation: [
                        "Expanded template expansion specifier",
                    ],
                    post_annotation: [
                        "Expanded template expansion specifier",
                    ],
                },
                DefPort {
                    name: Name {
                        data: "P",
                        node_id: Span {
                            start: <stdin>:196:8,
                            end: <stdin>:196:9,
                        },
                    },
                    params: [
                        FormalParam {
                            kind: Value,
                            name: Name {
                                data: "a",
                                node_id: Span {
                                    start: <stdin>:196:10,
                                    end: <stdin>:196:11,
                                },
                            },
                            type_name: TypeName {
                                kind: Integer(
                                    U32,
                                ),
                                node_id: Span {
                                    start: <stdin>:196:13,
                                    end: <stdin>:196:16,
                                },
                            },
                            node_id: Span {
                                start: <stdin>:196:10,
                                end: <stdin>:196:16,
                            },
                        },
                        FormalParam {
                            kind: Value,
                            name: Name {
                                data: "b",
                                node_id: Span {
                                    start: <stdin>:196:18,
                                    end: <stdin>:196:19,
                                },
                            },
                            type_name: TypeName {
                                kind: Floating(
                                    F32,
                                ),
                                node_id: Span {
                                    start: <stdin>:196:21,
                                    end: <stdin>:196:24,
                                },
                            },
                            node_id: Span {
                                start: <stdin>:196:18,
                                end: <stdin>:196:24,
                            },
                        },
                    ],
                    return_type: Some(
                        TypeName {
                            kind: Integer(
                                U32,
                            ),
                            node_id: Span {
                                start: <stdin>:196:29,
                                end: <stdin>:196:32,
                            },
                        },
                    ),
                    node_id: Span {
                        start: <stdin>:196:3,
                        end: <stdin>:196:32,
                    },
                    pre_annotation: [
                        "Port definition",
                    ],
                    post_annotation: [
                        "Port definition",
                    ],
                },
                DefStruct {
                    name: Name {
                        data: "S",
                        node_id: Span {
                            start: <stdin>:200:10,
                            end: <stdin>:200:11,
                        },
                    },
                    members: [
                        StructTypeMember {
                            name: Name {
                                data: "x",
                                node_id: Span {
                                    start: <stdin>:202:5,
                                    end: <stdin>:202:6,
                                },
                            },
                            size: None,
                            type_name: TypeName {
                                kind: Integer(
                                    U32,
                                ),
                                node_id: Span {
                                    start: <stdin>:202:8,
                                    end: <stdin>:202:11,
                                },
                            },
                            format: Some(
                                LitString {
                                    data: "{} s",
                                    inner_span: Span {
                                        start: <stdin>:202:20,
                                        end: <stdin>:202:24,
                                    },
                                    node_id: Span {
                                        start: <stdin>:202:19,
                                        end: <stdin>:202:25,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:202:5,
                                end: <stdin>:202:25,
                            },
                            pre_annotation: [
                                "x",
                            ],
                            post_annotation: [
                                "x",
                            ],
                        },
                        StructTypeMember {
                            name: Name {
                                data: "y",
                                node_id: Span {
                                    start: <stdin>:205:5,
                                    end: <stdin>:205:6,
                                },
                            },
                            size: None,
                            type_name: TypeName {
                                kind: Floating(
                                    F32,
                                ),
                                node_id: Span {
                                    start: <stdin>:205:8,
                                    end: <stdin>:205:11,
                                },
                            },
                            format: Some(
                                LitString {
                                    data: "{} m/s",
                                    inner_span: Span {
                                        start: <stdin>:205:20,
                                        end: <stdin>:205:26,
                                    },
                                    node_id: Span {
                                        start: <stdin>:205:19,
                                        end: <stdin>:205:27,
                                    },
                                },
                            ),
                            node_id: Span {
                                start: <stdin>:205:5,
                                end: <stdin>:205:27,
                            },
                            pre_annotation: [
                                "y",
                            ],
                            post_annotation: [
                                "y",
                            ],
                        },
                    ],
                    default: None,
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:200:3,
                        end: <stdin>:207:4,
                    },
                    pre_annotation: [
                        "Struct definition",
                    ],
                    post_annotation: [
                        "Struct definition",
                    ],
                },
                DefTopology {
                    is_deployment: false,
                    name: Name {
                        data: "T",
                        node_id: Span {
                            start: <stdin>:211:12,
                            end: <stdin>:211:13,
                        },
                    },
                    members: [
                        SpecInstance {
                            instance: Unqualified {
                                name: Ident {
                                    data: "i1",
                                    node_id: Span {
                                        start: <stdin>:214:14,
                                        end: <stdin>:214:16,
                                    },
                                },
                                is_absolute: false,
                                node_id: Span {
                                    start: <stdin>:214:14,
                                    end: <stdin>:214:16,
                                },
                            },
                            node_id: Span {
                                start: <stdin>:214:5,
                                end: <stdin>:214:16,
                            },
                            pre_annotation: [
                                "Public instance specifier",
                            ],
                            post_annotation: [
                                "Public instance specifier",
                            ],
                        },
                        SpecInstance {
                            instance: Unqualified {
                                name: Ident {
                                    data: "i1Abs",
                                    node_id: Span {
                                        start: <stdin>:218:15,
                                        end: <stdin>:218:20,
                                    },
                                },
                                is_absolute: true,
                                node_id: Span {
                                    start: <stdin>:218:14,
                                    end: <stdin>:218:20,
                                },
                            },
                            node_id: Span {
                                start: <stdin>:218:5,
                                end: <stdin>:218:20,
                            },
                            pre_annotation: [
                                "Public instance specifier with absolute qualified identifier",
                            ],
                            post_annotation: [
                                "Public instance specifier with absolute qualified identifier",
                            ],
                        },
                        SpecDirectConnectionGraph {
                            name: Name {
                                data: "C",
                                node_id: Span {
                                    start: <stdin>:222:17,
                                    end: <stdin>:222:18,
                                },
                            },
                            connections: [
                                Connection {
                                    is_unmatched: false,
                                    from_port: PortInstanceIdentifier {
                                        interface_instance: Unqualified {
                                            name: Ident {
                                                data: "i1",
                                                node_id: Span {
                                                    start: <stdin>:223:7,
                                                    end: <stdin>:223:9,
                                                },
                                            },
                                            is_absolute: false,
                                            node_id: Span {
                                                start: <stdin>:223:7,
                                                end: <stdin>:223:9,
                                            },
                                        },
                                        port_name: Ident {
                                            data: "p",
                                            node_id: Span {
                                                start: <stdin>:223:10,
                                                end: <stdin>:223:11,
                                            },
                                        },
                                        node_id: Span {
                                            start: <stdin>:223:7,
                                            end: <stdin>:223:11,
                                        },
                                    },
                                    from_index: Some(
                                        Expr {
                                            kind: LiteralInt(
                                                "0",
                                            ),
                                            node_id: Span {
                                                start: <stdin>:223:12,
                                                end: <stdin>:223:13,
                                            },
                                        },
                                    ),
                                    to_port: PortInstanceIdentifier {
                                        interface_instance: Unqualified {
                                            name: Ident {
                                                data: "i2",
                                                node_id: Span {
                                                    start: <stdin>:223:18,
                                                    end: <stdin>:223:20,
                                                },
                                            },
                                            is_absolute: false,
                                            node_id: Span {
                                                start: <stdin>:223:18,
                                                end: <stdin>:223:20,
                                            },
                                        },
                                        port_name: Ident {
                                            data: "p",
                                            node_id: Span {
                                                start: <stdin>:223:21,
                                                end: <stdin>:223:22,
                                            },
                                        },
                                        node_id: Span {
                                            start: <stdin>:223:18,
                                            end: <stdin>:223:22,
                                        },
                                    },
                                    to_index: Some(
                                        Expr {
                                            kind: LiteralInt(
                                                "1",
                                            ),
                                            node_id: Span {
                                                start: <stdin>:223:23,
                                                end: <stdin>:223:24,
                                            },
                                        },
                                    ),
                                    node_id: Span {
                                        start: <stdin>:223:7,
                                        end: <stdin>:223:25,
                                    },
                                },
                                Connection {
                                    is_unmatched: true,
                                    from_port: PortInstanceIdentifier {
                                        interface_instance: Unqualified {
                                            name: Ident {
                                                data: "i1",
                                                node_id: Span {
                                                    start: <stdin>:224:17,
                                                    end: <stdin>:224:19,
                                                },
                                            },
                                            is_absolute: false,
                                            node_id: Span {
                                                start: <stdin>:224:17,
                                                end: <stdin>:224:19,
                                            },
                                        },
                                        port_name: Ident {
                                            data: "p1",
                                            node_id: Span {
                                                start: <stdin>:224:20,
                                                end: <stdin>:224:22,
                                            },
                                        },
                                        node_id: Span {
                                            start: <stdin>:224:17,
                                            end: <stdin>:224:22,
                                        },
                                    },
                                    from_index: Some(
                                        Expr {
                                            kind: LiteralInt(
                                                "0",
                                            ),
                                            node_id: Span {
                                                start: <stdin>:224:23,
                                                end: <stdin>:224:24,
                                            },
                                        },
                                    ),
                                    to_port: PortInstanceIdentifier {
                                        interface_instance: Unqualified {
                                            name: Ident {
                                                data: "i2",
                                                node_id: Span {
                                                    start: <stdin>:224:29,
                                                    end: <stdin>:224:31,
                                                },
                                            },
                                            is_absolute: false,
                                            node_id: Span {
                                                start: <stdin>:224:29,
                                                end: <stdin>:224:31,
                                            },
                                        },
                                        port_name: Ident {
                                            data: "p2",
                                            node_id: Span {
                                                start: <stdin>:224:32,
                                                end: <stdin>:224:34,
                                            },
                                        },
                                        node_id: Span {
                                            start: <stdin>:224:29,
                                            end: <stdin>:224:34,
                                        },
                                    },
                                    to_index: Some(
                                        Expr {
                                            kind: LiteralInt(
                                                "0",
                                            ),
                                            node_id: Span {
                                                start: <stdin>:224:35,
                                                end: <stdin>:224:36,
                                            },
                                        },
                                    ),
                                    node_id: Span {
                                        start: <stdin>:224:7,
                                        end: <stdin>:224:37,
                                    },
                                },
                                Connection {
                                    is_unmatched: true,
                                    from_port: PortInstanceIdentifier {
                                        interface_instance: Unqualified {
                                            name: Ident {
                                                data: "i1",
                                                node_id: Span {
                                                    start: <stdin>:225:17,
                                                    end: <stdin>:225:19,
                                                },
                                            },
                                            is_absolute: false,
                                            node_id: Span {
                                                start: <stdin>:225:17,
                                                end: <stdin>:225:19,
                                            },
                                        },
                                        port_name: Ident {
                                            data: "p1",
                                            node_id: Span {
                                                start: <stdin>:225:20,
                                                end: <stdin>:225:22,
                                            },
                                        },
                                        node_id: Span {
                                            start: <stdin>:225:17,
                                            end: <stdin>:225:22,
                                        },
                                    },
                                    from_index: None,
                                    to_port: PortInstanceIdentifier {
                                        interface_instance: Unqualified {
                                            name: Ident {
                                                data: "i2",
                                                node_id: Span {
                                                    start: <stdin>:225:26,
                                                    end: <stdin>:225:28,
                                                },
                                            },
                                            is_absolute: false,
                                            node_id: Span {
                                                start: <stdin>:225:26,
                                                end: <stdin>:225:28,
                                            },
                                        },
                                        port_name: Ident {
                                            data: "p2",
                                            node_id: Span {
                                                start: <stdin>:225:29,
                                                end: <stdin>:225:31,
                                            },
                                        },
                                        node_id: Span {
                                            start: <stdin>:225:26,
                                            end: <stdin>:225:31,
                                        },
                                    },
                                    to_index: None,
                                    node_id: Span {
                                        start: <stdin>:225:7,
                                        end: <stdin>:225:31,
                                    },
                                },
                                Connection {
                                    is_unmatched: false,
                                    from_port: PortInstanceIdentifier {
                                        interface_instance: Unqualified {
                                            name: Ident {
                                                data: "i1",
                                                node_id: Span {
                                                    start: <stdin>:226:8,
                                                    end: <stdin>:226:10,
                                                },
                                            },
                                            is_absolute: true,
                                            node_id: Span {
                                                start: <stdin>:226:8,
                                                end: <stdin>:226:10,
                                            },
                                        },
                                        port_name: Ident {
                                            data: "p3",
                                            node_id: Span {
                                                start: <stdin>:226:11,
                                                end: <stdin>:226:13,
                                            },
                                        },
                                        node_id: Span {
                                            start: <stdin>:226:7,
                                            end: <stdin>:226:13,
                                        },
                                    },
                                    from_index: None,
                                    to_port: PortInstanceIdentifier {
                                        interface_instance: Unqualified {
                                            name: Ident {
                                                data: "i2",
                                                node_id: Span {
                                                    start: <stdin>:226:18,
                                                    end: <stdin>:226:20,
                                                },
                                            },
                                            is_absolute: true,
                                            node_id: Span {
                                                start: <stdin>:226:18,
                                                end: <stdin>:226:20,
                                            },
                                        },
                                        port_name: Ident {
                                            data: "p3",
                                            node_id: Span {
                                                start: <stdin>:226:21,
                                                end: <stdin>:226:23,
                                            },
                                        },
                                        node_id: Span {
                                            start: <stdin>:226:17,
                                            end: <stdin>:226:23,
                                        },
                                    },
                                    to_index: None,
                                    node_id: Span {
                                        start: <stdin>:226:7,
                                        end: <stdin>:226:23,
                                    },
                                },
                            ],
                            node_id: Span {
                                start: <stdin>:222:5,
                                end: <stdin>:227:6,
                            },
                            pre_annotation: [
                                "Direct connection graph specifier",
                            ],
                            post_annotation: [
                                "Direct connection graph specifier",
                            ],
                        },
                        SpecPatternConnectionGraph {
                            kind: Command,
                            source: Unqualified {
                                name: Ident {
                                    data: "i1",
                                    node_id: Span {
                                        start: <stdin>:231:34,
                                        end: <stdin>:231:36,
                                    },
                                },
                                is_absolute: false,
                                node_id: Span {
                                    start: <stdin>:231:34,
                                    end: <stdin>:231:36,
                                },
                            },
                            targets: [
                                Unqualified {
                                    name: Ident {
                                        data: "i2",
                                        node_id: Span {
                                            start: <stdin>:231:39,
                                            end: <stdin>:231:41,
                                        },
                                    },
                                    is_absolute: false,
                                    node_id: Span {
                                        start: <stdin>:231:39,
                                        end: <stdin>:231:41,
                                    },
                                },
                                Unqualified {
                                    name: Ident {
                                        data: "i3",
                                        node_id: Span {
                                            start: <stdin>:231:43,
                                            end: <stdin>:231:45,
                                        },
                                    },
                                    is_absolute: false,
                                    node_id: Span {
                                        start: <stdin>:231:43,
                                        end: <stdin>:231:45,
                                    },
                                },
                                Unqualified {
                                    name: Ident {
                                        data: "i4",
                                        node_id: Span {
                                            start: <stdin>:231:47,
                                            end: <stdin>:231:49,
                                        },
                                    },
                                    is_absolute: false,
                                    node_id: Span {
                                        start: <stdin>:231:47,
                                        end: <stdin>:231:49,
                                    },
                                },
                            ],
                            node_id: Span {
                                start: <stdin>:231:5,
                                end: <stdin>:231:51,
                            },
                            pre_annotation: [
                                "Graph pattern specifier",
                            ],
                            post_annotation: [
                                "Graph pattern specifier",
                            ],
                        },
                        SpecInstance {
                            instance: Unqualified {
                                name: Ident {
                                    data: "T1",
                                    node_id: Span {
                                        start: <stdin>:235:12,
                                        end: <stdin>:235:14,
                                    },
                                },
                                is_absolute: false,
                                node_id: Span {
                                    start: <stdin>:235:12,
                                    end: <stdin>:235:14,
                                },
                            },
                            node_id: Span {
                                start: <stdin>:235:5,
                                end: <stdin>:235:14,
                            },
                            pre_annotation: [
                                "Topology instance specifier",
                            ],
                            post_annotation: [
                                "Topology instance specifier",
                            ],
                        },
                        SpecTlmPacketSet {
                            name: Name {
                                data: "P",
                                node_id: Span {
                                    start: <stdin>:239:23,
                                    end: <stdin>:239:24,
                                },
                            },
                            members: [
                                SpecTlmPacket {
                                    name: Name {
                                        data: "P1",
                                        node_id: Span {
                                            start: <stdin>:242:14,
                                            end: <stdin>:242:16,
                                        },
                                    },
                                    id: Some(
                                        Expr {
                                            kind: LiteralInt(
                                                "0",
                                            ),
                                            node_id: Span {
                                                start: <stdin>:242:20,
                                                end: <stdin>:242:21,
                                            },
                                        },
                                    ),
                                    group: Expr {
                                        kind: LiteralInt(
                                            "0",
                                        ),
                                        node_id: Span {
                                            start: <stdin>:242:28,
                                            end: <stdin>:242:29,
                                        },
                                    },
                                    members: [
                                        TlmChannelIdentifier {
                                            component_instance: Unqualified {
                                                name: Ident {
                                                    data: "i1",
                                                    node_id: Span {
                                                        start: <stdin>:243:9,
                                                        end: <stdin>:243:11,
                                                    },
                                                },
                                                is_absolute: false,
                                                node_id: Span {
                                                    start: <stdin>:243:9,
                                                    end: <stdin>:243:11,
                                                },
                                            },
                                            channel_name: Ident {
                                                data: "c1",
                                                node_id: Span {
                                                    start: <stdin>:243:12,
                                                    end: <stdin>:243:14,
                                                },
                                            },
                                            node_id: Span {
                                                start: <stdin>:243:9,
                                                end: <stdin>:243:14,
                                            },
                                        },
                                        TlmChannelIdentifier {
                                            component_instance: Unqualified {
                                                name: Ident {
                                                    data: "i2",
                                                    node_id: Span {
                                                        start: <stdin>:244:9,
                                                        end: <stdin>:244:11,
                                                    },
                                                },
                                                is_absolute: false,
                                                node_id: Span {
                                                    start: <stdin>:244:9,
                                                    end: <stdin>:244:11,
                                                },
                                            },
                                            channel_name: Ident {
                                                data: "c2",
                                                node_id: Span {
                                                    start: <stdin>:244:12,
                                                    end: <stdin>:244:14,
                                                },
                                            },
                                            node_id: Span {
                                                start: <stdin>:244:9,
                                                end: <stdin>:244:14,
                                            },
                                        },
                                        TlmChannelIdentifier {
                                            component_instance: Unqualified {
                                                name: Ident {
                                                    data: "i1",
                                                    node_id: Span {
                                                        start: <stdin>:245:10,
                                                        end: <stdin>:245:12,
                                                    },
                                                },
                                                is_absolute: true,
                                                node_id: Span {
                                                    start: <stdin>:245:10,
                                                    end: <stdin>:245:12,
                                                },
                                            },
                                            channel_name: Ident {
                                                data: "c3",
                                                node_id: Span {
                                                    start: <stdin>:245:13,
                                                    end: <stdin>:245:15,
                                                },
                                            },
                                            node_id: Span {
                                                start: <stdin>:245:9,
                                                end: <stdin>:245:15,
                                            },
                                        },
                                    ],
                                    node_id: Span {
                                        start: <stdin>:242:7,
                                        end: <stdin>:246:8,
                                    },
                                    pre_annotation: [
                                        "Telemetry packet",
                                    ],
                                    post_annotation: [
                                        "Telemetry packet",
                                    ],
                                },
                                SpecTlmPacket {
                                    name: Name {
                                        data: "P2",
                                        node_id: Span {
                                            start: [ local path prefix ]/packet.fppi:2:8,
                                            end: [ local path prefix ]/packet.fppi:2:10,
                                        },
                                    },
                                    id: Some(
                                        Expr {
                                            kind: LiteralInt(
                                                "1",
                                            ),
                                            node_id: Span {
                                                start: [ local path prefix ]/packet.fppi:2:14,
                                                end: [ local path prefix ]/packet.fppi:2:15,
                                            },
                                        },
                                    ),
                                    group: Expr {
                                        kind: LiteralInt(
                                            "1",
                                        ),
                                        node_id: Span {
                                            start: [ local path prefix ]/packet.fppi:2:22,
                                            end: [ local path prefix ]/packet.fppi:2:23,
                                        },
                                    },
                                    members: [
                                        TlmChannelIdentifier {
                                            component_instance: Unqualified {
                                                name: Ident {
                                                    data: "i4",
                                                    node_id: Span {
                                                        start: [ local path prefix ]/packet.fppi:3:3,
                                                        end: [ local path prefix ]/packet.fppi:3:5,
                                                    },
                                                },
                                                is_absolute: false,
                                                node_id: Span {
                                                    start: [ local path prefix ]/packet.fppi:3:3,
                                                    end: [ local path prefix ]/packet.fppi:3:5,
                                                },
                                            },
                                            channel_name: Ident {
                                                data: "c4",
                                                node_id: Span {
                                                    start: [ local path prefix ]/packet.fppi:3:6,
                                                    end: [ local path prefix ]/packet.fppi:3:8,
                                                },
                                            },
                                            node_id: Span {
                                                start: [ local path prefix ]/packet.fppi:3:3,
                                                end: [ local path prefix ]/packet.fppi:3:8,
                                            },
                                        },
                                        TlmChannelIdentifier {
                                            component_instance: Unqualified {
                                                name: Ident {
                                                    data: "i5",
                                                    node_id: Span {
                                                        start: [ local path prefix ]/channel.fppi:1:1,
                                                        end: [ local path prefix ]/channel.fppi:1:3,
                                                    },
                                                },
                                                is_absolute: false,
                                                node_id: Span {
                                                    start: [ local path prefix ]/channel.fppi:1:1,
                                                    end: [ local path prefix ]/channel.fppi:1:3,
                                                },
                                            },
                                            channel_name: Ident {
                                                data: "c5",
                                                node_id: Span {
                                                    start: [ local path prefix ]/channel.fppi:1:4,
                                                    end: [ local path prefix ]/channel.fppi:1:6,
                                                },
                                            },
                                            node_id: Span {
                                                start: [ local path prefix ]/channel.fppi:1:1,
                                                end: [ local path prefix ]/channel.fppi:1:6,
                                            },
                                        },
                                    ],
                                    node_id: Span {
                                        start: [ local path prefix ]/packet.fppi:2:1,
                                        end: [ local path prefix ]/packet.fppi:5:2,
                                    },
                                    pre_annotation: [
                                        "Included packet",
                                    ],
                                    post_annotation: [
                                        "Included packet",
                                    ],
                                },
                            ],
                            omitted: [
                                TlmChannelIdentifier {
                                    component_instance: Unqualified {
                                        name: Ident {
                                            data: "i3",
                                            node_id: Span {
                                                start: <stdin>:254:7,
                                                end: <stdin>:254:9,
                                            },
                                        },
                                        is_absolute: false,
                                        node_id: Span {
                                            start: <stdin>:254:7,
                                            end: <stdin>:254:9,
                                        },
                                    },
                                    channel_name: Ident {
                                        data: "c3",
                                        node_id: Span {
                                            start: <stdin>:254:10,
                                            end: <stdin>:254:12,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:254:7,
                                        end: <stdin>:254:12,
                                    },
                                },
                                TlmChannelIdentifier {
                                    component_instance: Unqualified {
                                        name: Ident {
                                            data: "i3",
                                            node_id: Span {
                                                start: <stdin>:255:8,
                                                end: <stdin>:255:10,
                                            },
                                        },
                                        is_absolute: true,
                                        node_id: Span {
                                            start: <stdin>:255:8,
                                            end: <stdin>:255:10,
                                        },
                                    },
                                    channel_name: Ident {
                                        data: "c4",
                                        node_id: Span {
                                            start: <stdin>:255:11,
                                            end: <stdin>:255:13,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:255:7,
                                        end: <stdin>:255:13,
                                    },
                                },
                            ],
                            node_id: Span {
                                start: <stdin>:239:5,
                                end: <stdin>:256:6,
                            },
                            pre_annotation: [
                                "Telemetry packet group",
                            ],
                            post_annotation: [
                                "Telemetry packet group",
                            ],
                        },
                        SpecTopPort {
                            name: Name {
                                data: "a",
                                node_id: Span {
                                    start: <stdin>:260:10,
                                    end: <stdin>:260:11,
                                },
                            },
                            underlying_port: PortInstanceIdentifier {
                                interface_instance: Unqualified {
                                    name: Ident {
                                        data: "b",
                                        node_id: Span {
                                            start: <stdin>:260:14,
                                            end: <stdin>:260:15,
                                        },
                                    },
                                    is_absolute: false,
                                    node_id: Span {
                                        start: <stdin>:260:14,
                                        end: <stdin>:260:15,
                                    },
                                },
                                port_name: Ident {
                                    data: "a",
                                    node_id: Span {
                                        start: <stdin>:260:16,
                                        end: <stdin>:260:17,
                                    },
                                },
                                node_id: Span {
                                    start: <stdin>:260:14,
                                    end: <stdin>:260:17,
                                },
                            },
                            node_id: Span {
                                start: <stdin>:260:5,
                                end: <stdin>:260:17,
                            },
                            pre_annotation: [
                                "Topology port specifier",
                            ],
                            post_annotation: [
                                "Topology port specifier",
                            ],
                        },
                        SpecTopPort {
                            name: Name {
                                data: "aAbs",
                                node_id: Span {
                                    start: <stdin>:264:10,
                                    end: <stdin>:264:14,
                                },
                            },
                            underlying_port: PortInstanceIdentifier {
                                interface_instance: Unqualified {
                                    name: Ident {
                                        data: "b",
                                        node_id: Span {
                                            start: <stdin>:264:18,
                                            end: <stdin>:264:19,
                                        },
                                    },
                                    is_absolute: true,
                                    node_id: Span {
                                        start: <stdin>:264:18,
                                        end: <stdin>:264:19,
                                    },
                                },
                                port_name: Ident {
                                    data: "a",
                                    node_id: Span {
                                        start: <stdin>:264:20,
                                        end: <stdin>:264:21,
                                    },
                                },
                                node_id: Span {
                                    start: <stdin>:264:17,
                                    end: <stdin>:264:21,
                                },
                            },
                            node_id: Span {
                                start: <stdin>:264:5,
                                end: <stdin>:264:21,
                            },
                            pre_annotation: [
                                "Topology port specifier with absolute qualified identifier",
                            ],
                            post_annotation: [
                                "Topology port specifier with absolute qualified identifier",
                            ],
                        },
                    ],
                    implements: [],
                    node_id: Span {
                        start: <stdin>:211:3,
                        end: <stdin>:266:4,
                    },
                    pre_annotation: [
                        "Topology definition",
                    ],
                    post_annotation: [
                        "Topology definition",
                    ],
                },
                DefTopology {
                    is_deployment: true,
                    name: Name {
                        data: "T1",
                        node_id: Span {
                            start: <stdin>:270:23,
                            end: <stdin>:270:25,
                        },
                    },
                    members: [],
                    implements: [],
                    node_id: Span {
                        start: <stdin>:270:3,
                        end: <stdin>:270:28,
                    },
                    pre_annotation: [
                        "Deployment topology",
                    ],
                    post_annotation: [
                        "Deployment topology",
                    ],
                },
                DefTopology {
                    is_deployment: false,
                    name: Name {
                        data: "T2",
                        node_id: Span {
                            start: <stdin>:274:12,
                            end: <stdin>:274:14,
                        },
                    },
                    members: [],
                    implements: [
                        Unqualified {
                            name: Ident {
                                data: "I",
                                node_id: Span {
                                    start: <stdin>:274:26,
                                    end: <stdin>:274:27,
                                },
                            },
                            is_absolute: false,
                            node_id: Span {
                                start: <stdin>:274:26,
                                end: <stdin>:274:27,
                            },
                        },
                    ],
                    node_id: Span {
                        start: <stdin>:274:3,
                        end: <stdin>:274:30,
                    },
                    pre_annotation: [
                        "Topology definition with one implements",
                    ],
                    post_annotation: [
                        "Topology definition with one implements",
                    ],
                },
                DefTopology {
                    is_deployment: false,
                    name: Name {
                        data: "T3",
                        node_id: Span {
                            start: <stdin>:278:12,
                            end: <stdin>:278:14,
                        },
                    },
                    members: [],
                    implements: [
                        Unqualified {
                            name: Ident {
                                data: "I",
                                node_id: Span {
                                    start: <stdin>:278:26,
                                    end: <stdin>:278:27,
                                },
                            },
                            is_absolute: false,
                            node_id: Span {
                                start: <stdin>:278:26,
                                end: <stdin>:278:27,
                            },
                        },
                        Unqualified {
                            name: Ident {
                                data: "I",
                                node_id: Span {
                                    start: <stdin>:278:29,
                                    end: <stdin>:278:30,
                                },
                            },
                            is_absolute: false,
                            node_id: Span {
                                start: <stdin>:278:29,
                                end: <stdin>:278:30,
                            },
                        },
                    ],
                    node_id: Span {
                        start: <stdin>:278:3,
                        end: <stdin>:278:33,
                    },
                    pre_annotation: [
                        "Topology definition with two implements",
                    ],
                    post_annotation: [
                        "Topology definition with two implements",
                    ],
                },
                DefSystem {
                    name: Name {
                        data: "S",
                        node_id: Span {
                            start: <stdin>:282:10,
                            end: <stdin>:282:11,
                        },
                    },
                    topology: Qualified {
                        qualifier: Unqualified {
                            name: Ident {
                                data: "M",
                                node_id: Span {
                                    start: <stdin>:282:13,
                                    end: <stdin>:282:14,
                                },
                            },
                            is_absolute: false,
                            node_id: Span {
                                start: <stdin>:282:13,
                                end: <stdin>:282:14,
                            },
                        },
                        name: Ident {
                            data: "T",
                            node_id: Span {
                                start: <stdin>:282:15,
                                end: <stdin>:282:16,
                            },
                        },
                        node_id: Span {
                            start: <stdin>:282:13,
                            end: <stdin>:282:16,
                        },
                    },
                    node_id: Span {
                        start: <stdin>:282:3,
                        end: <stdin>:282:16,
                    },
                    pre_annotation: [
                        "System definition",
                    ],
                    post_annotation: [
                        "System definition",
                    ],
                },
                DefSystem {
                    name: Name {
                        data: "SAbs",
                        node_id: Span {
                            start: <stdin>:286:10,
                            end: <stdin>:286:14,
                        },
                    },
                    topology: Qualified {
                        qualifier: Unqualified {
                            name: Ident {
                                data: "M",
                                node_id: Span {
                                    start: <stdin>:286:17,
                                    end: <stdin>:286:18,
                                },
                            },
                            is_absolute: true,
                            node_id: Span {
                                start: <stdin>:286:17,
                                end: <stdin>:286:18,
                            },
                        },
                        name: Ident {
                            data: "T",
                            node_id: Span {
                                start: <stdin>:286:19,
                                end: <stdin>:286:20,
                            },
                        },
                        node_id: Span {
                            start: <stdin>:286:16,
                            end: <stdin>:286:20,
                        },
                    },
                    node_id: Span {
                        start: <stdin>:286:3,
                        end: <stdin>:286:20,
                    },
                    pre_annotation: [
                        "System definition with absolute qualified identifier",
                    ],
                    post_annotation: [
                        "System definition with absolute qualified identifier",
                    ],
                },
                SpecLoc {
                    kind: Instance,
                    symbol: Unqualified {
                        name: Ident {
                            data: "i",
                            node_id: Span {
                                start: <stdin>:290:19,
                                end: <stdin>:290:20,
                            },
                        },
                        is_absolute: false,
                        node_id: Span {
                            start: <stdin>:290:19,
                            end: <stdin>:290:20,
                        },
                    },
                    file: LitString {
                        data: "instances.fpp",
                        inner_span: Span {
                            start: <stdin>:290:25,
                            end: <stdin>:290:38,
                        },
                        node_id: Span {
                            start: <stdin>:290:24,
                            end: <stdin>:290:39,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:290:3,
                        end: <stdin>:290:39,
                    },
                    pre_annotation: [
                        "Location specifier",
                    ],
                    post_annotation: [
                        "Location specifier",
                    ],
                },
                SpecLoc {
                    kind: Instance,
                    symbol: Unqualified {
                        name: Ident {
                            data: "i",
                            node_id: Span {
                                start: <stdin>:294:20,
                                end: <stdin>:294:21,
                            },
                        },
                        is_absolute: true,
                        node_id: Span {
                            start: <stdin>:294:19,
                            end: <stdin>:294:21,
                        },
                    },
                    file: LitString {
                        data: "instances.fpp",
                        inner_span: Span {
                            start: <stdin>:294:26,
                            end: <stdin>:294:39,
                        },
                        node_id: Span {
                            start: <stdin>:294:25,
                            end: <stdin>:294:40,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:294:3,
                        end: <stdin>:294:40,
                    },
                    pre_annotation: [
                        "Location specifier with absolute qualified identifier",
                    ],
                    post_annotation: [
                        "Location specifier with absolute qualified identifier",
                    ],
                },
                SpecLoc {
                    kind: System,
                    symbol: Unqualified {
                        name: Ident {
                            data: "S",
                            node_id: Span {
                                start: <stdin>:298:17,
                                end: <stdin>:298:18,
                            },
                        },
                        is_absolute: false,
                        node_id: Span {
                            start: <stdin>:298:17,
                            end: <stdin>:298:18,
                        },
                    },
                    file: LitString {
                        data: "system.fpp",
                        inner_span: Span {
                            start: <stdin>:298:23,
                            end: <stdin>:298:33,
                        },
                        node_id: Span {
                            start: <stdin>:298:22,
                            end: <stdin>:298:34,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:298:3,
                        end: <stdin>:298:34,
                    },
                    pre_annotation: [
                        "System location specifier",
                    ],
                    post_annotation: [
                        "System location specifier",
                    ],
                },
                SpecLoc {
                    kind: Template,
                    symbol: Unqualified {
                        name: Ident {
                            data: "MT",
                            node_id: Span {
                                start: <stdin>:302:19,
                                end: <stdin>:302:21,
                            },
                        },
                        is_absolute: false,
                        node_id: Span {
                            start: <stdin>:302:19,
                            end: <stdin>:302:21,
                        },
                    },
                    file: LitString {
                        data: "template.fpp",
                        inner_span: Span {
                            start: <stdin>:302:26,
                            end: <stdin>:302:38,
                        },
                        node_id: Span {
                            start: <stdin>:302:25,
                            end: <stdin>:302:39,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:302:3,
                        end: <stdin>:302:39,
                    },
                    pre_annotation: [
                        "Template location specifier",
                    ],
                    post_annotation: [
                        "Template location specifier",
                    ],
                },
            ],
            node_id: Span {
                start: <stdin>:2:1,
                end: <stdin>:305:2,
            },
            pre_annotation: [
                "Definitions and specifiers",
            ],
            post_annotation: [
                "Definitions and specifiers",
            ],
        },
        DefModule {
            name: Name {
                data: "TypeNames",
                node_id: Span {
                    start: <stdin>:309:8,
                    end: <stdin>:309:17,
                },
            },
            members: [
                DefArray {
                    name: Name {
                        data: "typeNameU32",
                        node_id: Span {
                            start: <stdin>:311:9,
                            end: <stdin>:311:20,
                        },
                    },
                    size: Expr {
                        kind: LiteralInt(
                            "10",
                        ),
                        node_id: Span {
                            start: <stdin>:311:24,
                            end: <stdin>:311:26,
                        },
                    },
                    elt_type: TypeName {
                        kind: Integer(
                            U32,
                        ),
                        node_id: Span {
                            start: <stdin>:311:28,
                            end: <stdin>:311:31,
                        },
                    },
                    default: None,
                    format: None,
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:311:3,
                        end: <stdin>:311:31,
                    },
                },
                DefArray {
                    name: Name {
                        data: "typeNameF32",
                        node_id: Span {
                            start: <stdin>:312:9,
                            end: <stdin>:312:20,
                        },
                    },
                    size: Expr {
                        kind: LiteralInt(
                            "10",
                        ),
                        node_id: Span {
                            start: <stdin>:312:24,
                            end: <stdin>:312:26,
                        },
                    },
                    elt_type: TypeName {
                        kind: Floating(
                            F32,
                        ),
                        node_id: Span {
                            start: <stdin>:312:28,
                            end: <stdin>:312:31,
                        },
                    },
                    default: None,
                    format: None,
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:312:3,
                        end: <stdin>:312:31,
                    },
                },
                DefArray {
                    name: Name {
                        data: "typeNameBool",
                        node_id: Span {
                            start: <stdin>:313:9,
                            end: <stdin>:313:21,
                        },
                    },
                    size: Expr {
                        kind: LiteralInt(
                            "10",
                        ),
                        node_id: Span {
                            start: <stdin>:313:25,
                            end: <stdin>:313:27,
                        },
                    },
                    elt_type: TypeName {
                        kind: Bool,
                        node_id: Span {
                            start: <stdin>:313:29,
                            end: <stdin>:313:33,
                        },
                    },
                    default: None,
                    format: None,
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:313:3,
                        end: <stdin>:313:33,
                    },
                },
                DefArray {
                    name: Name {
                        data: "typeNameString",
                        node_id: Span {
                            start: <stdin>:314:9,
                            end: <stdin>:314:23,
                        },
                    },
                    size: Expr {
                        kind: LiteralInt(
                            "10",
                        ),
                        node_id: Span {
                            start: <stdin>:314:27,
                            end: <stdin>:314:29,
                        },
                    },
                    elt_type: TypeName {
                        kind: String(
                            Some(
                                Expr {
                                    kind: LiteralInt(
                                        "256",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:314:43,
                                        end: <stdin>:314:46,
                                    },
                                },
                            ),
                        ),
                        node_id: Span {
                            start: <stdin>:314:31,
                            end: <stdin>:314:46,
                        },
                    },
                    default: None,
                    format: None,
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:314:3,
                        end: <stdin>:314:46,
                    },
                },
                DefArray {
                    name: Name {
                        data: "typeNameQID",
                        node_id: Span {
                            start: <stdin>:315:9,
                            end: <stdin>:315:20,
                        },
                    },
                    size: Expr {
                        kind: LiteralInt(
                            "10",
                        ),
                        node_id: Span {
                            start: <stdin>:315:24,
                            end: <stdin>:315:26,
                        },
                    },
                    elt_type: TypeName {
                        kind: QualIdent(
                            Qualified {
                                qualifier: Qualified {
                                    qualifier: Unqualified {
                                        name: Ident {
                                            data: "a",
                                            node_id: Span {
                                                start: <stdin>:315:28,
                                                end: <stdin>:315:29,
                                            },
                                        },
                                        is_absolute: false,
                                        node_id: Span {
                                            start: <stdin>:315:28,
                                            end: <stdin>:315:29,
                                        },
                                    },
                                    name: Ident {
                                        data: "b",
                                        node_id: Span {
                                            start: <stdin>:315:30,
                                            end: <stdin>:315:31,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:315:28,
                                        end: <stdin>:315:31,
                                    },
                                },
                                name: Ident {
                                    data: "c",
                                    node_id: Span {
                                        start: <stdin>:315:32,
                                        end: <stdin>:315:33,
                                    },
                                },
                                node_id: Span {
                                    start: <stdin>:315:28,
                                    end: <stdin>:315:33,
                                },
                            },
                        ),
                        node_id: Span {
                            start: <stdin>:315:28,
                            end: <stdin>:315:33,
                        },
                    },
                    default: None,
                    format: None,
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:315:3,
                        end: <stdin>:315:33,
                    },
                },
                DefArray {
                    name: Name {
                        data: "typeNameAbsoluteQID",
                        node_id: Span {
                            start: <stdin>:316:9,
                            end: <stdin>:316:28,
                        },
                    },
                    size: Expr {
                        kind: LiteralInt(
                            "10",
                        ),
                        node_id: Span {
                            start: <stdin>:316:32,
                            end: <stdin>:316:34,
                        },
                    },
                    elt_type: TypeName {
                        kind: QualIdent(
                            Qualified {
                                qualifier: Qualified {
                                    qualifier: Unqualified {
                                        name: Ident {
                                            data: "a",
                                            node_id: Span {
                                                start: <stdin>:316:37,
                                                end: <stdin>:316:38,
                                            },
                                        },
                                        is_absolute: true,
                                        node_id: Span {
                                            start: <stdin>:316:37,
                                            end: <stdin>:316:38,
                                        },
                                    },
                                    name: Ident {
                                        data: "b",
                                        node_id: Span {
                                            start: <stdin>:316:39,
                                            end: <stdin>:316:40,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:316:37,
                                        end: <stdin>:316:40,
                                    },
                                },
                                name: Ident {
                                    data: "c",
                                    node_id: Span {
                                        start: <stdin>:316:41,
                                        end: <stdin>:316:42,
                                    },
                                },
                                node_id: Span {
                                    start: <stdin>:316:36,
                                    end: <stdin>:316:42,
                                },
                            },
                        ),
                        node_id: Span {
                            start: <stdin>:316:36,
                            end: <stdin>:316:42,
                        },
                    },
                    default: None,
                    format: None,
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:316:3,
                        end: <stdin>:316:42,
                    },
                },
            ],
            node_id: Span {
                start: <stdin>:309:1,
                end: <stdin>:318:2,
            },
            pre_annotation: [
                "Type names",
            ],
            post_annotation: [
                "Type names",
            ],
        },
        DefModule {
            name: Name {
                data: "Expressions",
                node_id: Span {
                    start: <stdin>:322:8,
                    end: <stdin>:322:19,
                },
            },
            members: [
                DefConstant {
                    name: Name {
                        data: "arithExp",
                        node_id: Span {
                            start: <stdin>:325:12,
                            end: <stdin>:325:20,
                        },
                    },
                    value: Expr {
                        kind: Binop {
                            left: Expr {
                                kind: Binop {
                                    left: Expr {
                                        kind: Binop {
                                            left: Expr {
                                                kind: LiteralInt(
                                                    "1",
                                                ),
                                                node_id: Span {
                                                    start: <stdin>:325:23,
                                                    end: <stdin>:325:24,
                                                },
                                            },
                                            op: Add,
                                            right: Expr {
                                                kind: Binop {
                                                    left: Expr {
                                                        kind: LiteralInt(
                                                            "2",
                                                        ),
                                                        node_id: Span {
                                                            start: <stdin>:325:27,
                                                            end: <stdin>:325:28,
                                                        },
                                                    },
                                                    op: Mul,
                                                    right: Expr {
                                                        kind: LiteralInt(
                                                            "3",
                                                        ),
                                                        node_id: Span {
                                                            start: <stdin>:325:31,
                                                            end: <stdin>:325:32,
                                                        },
                                                    },
                                                },
                                                node_id: Span {
                                                    start: <stdin>:325:29,
                                                    end: <stdin>:325:32,
                                                },
                                            },
                                        },
                                        node_id: Span {
                                            start: <stdin>:325:25,
                                            end: <stdin>:325:32,
                                        },
                                    },
                                    op: Sub,
                                    right: Expr {
                                        kind: Binop {
                                            left: Expr {
                                                kind: Unop {
                                                    op: Minus,
                                                    e: Expr {
                                                        kind: LiteralInt(
                                                            "4",
                                                        ),
                                                        node_id: Span {
                                                            start: <stdin>:325:36,
                                                            end: <stdin>:325:37,
                                                        },
                                                    },
                                                },
                                                node_id: Span {
                                                    start: <stdin>:325:35,
                                                    end: <stdin>:325:37,
                                                },
                                            },
                                            op: Mul,
                                            right: Expr {
                                                kind: LiteralInt(
                                                    "5",
                                                ),
                                                node_id: Span {
                                                    start: <stdin>:325:40,
                                                    end: <stdin>:325:41,
                                                },
                                            },
                                        },
                                        node_id: Span {
                                            start: <stdin>:325:38,
                                            end: <stdin>:325:41,
                                        },
                                    },
                                },
                                node_id: Span {
                                    start: <stdin>:325:33,
                                    end: <stdin>:325:41,
                                },
                            },
                            op: Add,
                            right: Expr {
                                kind: LiteralInt(
                                    "6",
                                ),
                                node_id: Span {
                                    start: <stdin>:325:44,
                                    end: <stdin>:325:45,
                                },
                            },
                        },
                        node_id: Span {
                            start: <stdin>:325:42,
                            end: <stdin>:325:45,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:325:3,
                        end: <stdin>:325:45,
                    },
                    pre_annotation: [
                        "Arithmetic",
                    ],
                    post_annotation: [
                        "Arithmetic",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "shiftExp",
                        node_id: Span {
                            start: <stdin>:329:12,
                            end: <stdin>:329:20,
                        },
                    },
                    value: Expr {
                        kind: Binop {
                            left: Expr {
                                kind: Binop {
                                    left: Expr {
                                        kind: Binop {
                                            left: Expr {
                                                kind: LiteralInt(
                                                    "1",
                                                ),
                                                node_id: Span {
                                                    start: <stdin>:329:23,
                                                    end: <stdin>:329:24,
                                                },
                                            },
                                            op: Add,
                                            right: Expr {
                                                kind: LiteralInt(
                                                    "2",
                                                ),
                                                node_id: Span {
                                                    start: <stdin>:329:27,
                                                    end: <stdin>:329:28,
                                                },
                                            },
                                        },
                                        node_id: Span {
                                            start: <stdin>:329:25,
                                            end: <stdin>:329:28,
                                        },
                                    },
                                    op: LShift,
                                    right: Expr {
                                        kind: LiteralInt(
                                            "3",
                                        ),
                                        node_id: Span {
                                            start: <stdin>:329:32,
                                            end: <stdin>:329:33,
                                        },
                                    },
                                },
                                node_id: Span {
                                    start: <stdin>:329:29,
                                    end: <stdin>:329:33,
                                },
                            },
                            op: RShift,
                            right: Expr {
                                kind: LiteralInt(
                                    "1",
                                ),
                                node_id: Span {
                                    start: <stdin>:329:37,
                                    end: <stdin>:329:38,
                                },
                            },
                        },
                        node_id: Span {
                            start: <stdin>:329:34,
                            end: <stdin>:329:38,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:329:3,
                        end: <stdin>:329:38,
                    },
                    pre_annotation: [
                        "Shift",
                    ],
                    post_annotation: [
                        "Shift",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "arrayExp",
                        node_id: Span {
                            start: <stdin>:333:12,
                            end: <stdin>:333:20,
                        },
                    },
                    value: Expr {
                        kind: Array(
                            [
                                Expr {
                                    kind: LiteralInt(
                                        "1",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:333:25,
                                        end: <stdin>:333:26,
                                    },
                                },
                                Expr {
                                    kind: LiteralInt(
                                        "2",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:333:28,
                                        end: <stdin>:333:29,
                                    },
                                },
                                Expr {
                                    kind: LiteralInt(
                                        "3",
                                    ),
                                    node_id: Span {
                                        start: <stdin>:333:31,
                                        end: <stdin>:333:32,
                                    },
                                },
                            ],
                        ),
                        node_id: Span {
                            start: <stdin>:333:23,
                            end: <stdin>:333:34,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:333:3,
                        end: <stdin>:333:34,
                    },
                    pre_annotation: [
                        "Array",
                    ],
                    post_annotation: [
                        "Array",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "arraySubExp1",
                        node_id: Span {
                            start: <stdin>:337:12,
                            end: <stdin>:337:24,
                        },
                    },
                    value: Expr {
                        kind: ArraySubscript {
                            e1: Expr {
                                kind: Array(
                                    [
                                        Expr {
                                            kind: LiteralInt(
                                                "1",
                                            ),
                                            node_id: Span {
                                                start: <stdin>:337:29,
                                                end: <stdin>:337:30,
                                            },
                                        },
                                        Expr {
                                            kind: LiteralInt(
                                                "2",
                                            ),
                                            node_id: Span {
                                                start: <stdin>:337:32,
                                                end: <stdin>:337:33,
                                            },
                                        },
                                        Expr {
                                            kind: LiteralInt(
                                                "3",
                                            ),
                                            node_id: Span {
                                                start: <stdin>:337:35,
                                                end: <stdin>:337:36,
                                            },
                                        },
                                    ],
                                ),
                                node_id: Span {
                                    start: <stdin>:337:27,
                                    end: <stdin>:337:38,
                                },
                            },
                            e2: Expr {
                                kind: LiteralInt(
                                    "1",
                                ),
                                node_id: Span {
                                    start: <stdin>:337:39,
                                    end: <stdin>:337:40,
                                },
                            },
                        },
                        node_id: Span {
                            start: <stdin>:337:27,
                            end: <stdin>:337:41,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:337:3,
                        end: <stdin>:337:41,
                    },
                    pre_annotation: [
                        "Array Subscript",
                    ],
                    post_annotation: [
                        "Array Subscript",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "arraySubExp2",
                        node_id: Span {
                            start: <stdin>:341:12,
                            end: <stdin>:341:24,
                        },
                    },
                    value: Expr {
                        kind: ArraySubscript {
                            e1: Expr {
                                kind: Dot {
                                    e: Expr {
                                        kind: Dot {
                                            e: Expr {
                                                kind: Ident {
                                                    value: "a",
                                                    is_absolute: false,
                                                },
                                                node_id: Span {
                                                    start: <stdin>:341:27,
                                                    end: <stdin>:341:28,
                                                },
                                            },
                                            id: Ident {
                                                data: "b",
                                                node_id: Span {
                                                    start: <stdin>:341:29,
                                                    end: <stdin>:341:30,
                                                },
                                            },
                                        },
                                        node_id: Span {
                                            start: <stdin>:341:27,
                                            end: <stdin>:341:30,
                                        },
                                    },
                                    id: Ident {
                                        data: "c",
                                        node_id: Span {
                                            start: <stdin>:341:31,
                                            end: <stdin>:341:32,
                                        },
                                    },
                                },
                                node_id: Span {
                                    start: <stdin>:341:27,
                                    end: <stdin>:341:32,
                                },
                            },
                            e2: Expr {
                                kind: LiteralInt(
                                    "1",
                                ),
                                node_id: Span {
                                    start: <stdin>:341:33,
                                    end: <stdin>:341:34,
                                },
                            },
                        },
                        node_id: Span {
                            start: <stdin>:341:27,
                            end: <stdin>:341:35,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:341:3,
                        end: <stdin>:341:35,
                    },
                    pre_annotation: [
                        "Array Subscript",
                    ],
                    post_annotation: [
                        "Array Subscript",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "arraySubExp3",
                        node_id: Span {
                            start: <stdin>:345:12,
                            end: <stdin>:345:24,
                        },
                    },
                    value: Expr {
                        kind: ArraySubscript {
                            e1: Expr {
                                kind: Dot {
                                    e: Expr {
                                        kind: ArraySubscript {
                                            e1: Expr {
                                                kind: ArraySubscript {
                                                    e1: Expr {
                                                        kind: Dot {
                                                            e: Expr {
                                                                kind: Dot {
                                                                    e: Expr {
                                                                        kind: Ident {
                                                                            value: "a",
                                                                            is_absolute: false,
                                                                        },
                                                                        node_id: Span {
                                                                            start: <stdin>:345:27,
                                                                            end: <stdin>:345:28,
                                                                        },
                                                                    },
                                                                    id: Ident {
                                                                        data: "b",
                                                                        node_id: Span {
                                                                            start: <stdin>:345:29,
                                                                            end: <stdin>:345:30,
                                                                        },
                                                                    },
                                                                },
                                                                node_id: Span {
                                                                    start: <stdin>:345:27,
                                                                    end: <stdin>:345:30,
                                                                },
                                                            },
                                                            id: Ident {
                                                                data: "c",
                                                                node_id: Span {
                                                                    start: <stdin>:345:31,
                                                                    end: <stdin>:345:32,
                                                                },
                                                            },
                                                        },
                                                        node_id: Span {
                                                            start: <stdin>:345:27,
                                                            end: <stdin>:345:32,
                                                        },
                                                    },
                                                    e2: Expr {
                                                        kind: LiteralInt(
                                                            "1",
                                                        ),
                                                        node_id: Span {
                                                            start: <stdin>:345:33,
                                                            end: <stdin>:345:34,
                                                        },
                                                    },
                                                },
                                                node_id: Span {
                                                    start: <stdin>:345:27,
                                                    end: <stdin>:345:35,
                                                },
                                            },
                                            e2: Expr {
                                                kind: LiteralInt(
                                                    "2",
                                                ),
                                                node_id: Span {
                                                    start: <stdin>:345:36,
                                                    end: <stdin>:345:37,
                                                },
                                            },
                                        },
                                        node_id: Span {
                                            start: <stdin>:345:27,
                                            end: <stdin>:345:38,
                                        },
                                    },
                                    id: Ident {
                                        data: "s",
                                        node_id: Span {
                                            start: <stdin>:345:39,
                                            end: <stdin>:345:40,
                                        },
                                    },
                                },
                                node_id: Span {
                                    start: <stdin>:345:27,
                                    end: <stdin>:345:40,
                                },
                            },
                            e2: Expr {
                                kind: LiteralInt(
                                    "12",
                                ),
                                node_id: Span {
                                    start: <stdin>:345:41,
                                    end: <stdin>:345:43,
                                },
                            },
                        },
                        node_id: Span {
                            start: <stdin>:345:27,
                            end: <stdin>:345:44,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:345:3,
                        end: <stdin>:345:44,
                    },
                    pre_annotation: [
                        "Array Subscript with member selection",
                    ],
                    post_annotation: [
                        "Array Subscript",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "booleanLiteralExp",
                        node_id: Span {
                            start: <stdin>:349:12,
                            end: <stdin>:349:29,
                        },
                    },
                    value: Expr {
                        kind: LiteralBool(
                            true,
                        ),
                        node_id: Span {
                            start: <stdin>:349:32,
                            end: <stdin>:349:36,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:349:3,
                        end: <stdin>:349:36,
                    },
                    pre_annotation: [
                        "Boolean literal",
                    ],
                    post_annotation: [
                        "Boolean literal",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "dotExp",
                        node_id: Span {
                            start: <stdin>:353:12,
                            end: <stdin>:353:18,
                        },
                    },
                    value: Expr {
                        kind: Dot {
                            e: Expr {
                                kind: Dot {
                                    e: Expr {
                                        kind: Ident {
                                            value: "a",
                                            is_absolute: false,
                                        },
                                        node_id: Span {
                                            start: <stdin>:353:21,
                                            end: <stdin>:353:22,
                                        },
                                    },
                                    id: Ident {
                                        data: "b",
                                        node_id: Span {
                                            start: <stdin>:353:23,
                                            end: <stdin>:353:24,
                                        },
                                    },
                                },
                                node_id: Span {
                                    start: <stdin>:353:21,
                                    end: <stdin>:353:24,
                                },
                            },
                            id: Ident {
                                data: "c",
                                node_id: Span {
                                    start: <stdin>:353:25,
                                    end: <stdin>:353:26,
                                },
                            },
                        },
                        node_id: Span {
                            start: <stdin>:353:21,
                            end: <stdin>:353:26,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:353:3,
                        end: <stdin>:353:26,
                    },
                    pre_annotation: [
                        "Dot",
                    ],
                    post_annotation: [
                        "Dot",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "dotAbsoluteExp",
                        node_id: Span {
                            start: <stdin>:357:12,
                            end: <stdin>:357:26,
                        },
                    },
                    value: Expr {
                        kind: Dot {
                            e: Expr {
                                kind: Dot {
                                    e: Expr {
                                        kind: Ident {
                                            value: "a",
                                            is_absolute: true,
                                        },
                                        node_id: Span {
                                            start: <stdin>:357:29,
                                            end: <stdin>:357:31,
                                        },
                                    },
                                    id: Ident {
                                        data: "b",
                                        node_id: Span {
                                            start: <stdin>:357:32,
                                            end: <stdin>:357:33,
                                        },
                                    },
                                },
                                node_id: Span {
                                    start: <stdin>:357:29,
                                    end: <stdin>:357:33,
                                },
                            },
                            id: Ident {
                                data: "c",
                                node_id: Span {
                                    start: <stdin>:357:34,
                                    end: <stdin>:357:35,
                                },
                            },
                        },
                        node_id: Span {
                            start: <stdin>:357:29,
                            end: <stdin>:357:35,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:357:3,
                        end: <stdin>:357:35,
                    },
                    pre_annotation: [
                        "Dot with absolute qualified identifier",
                    ],
                    post_annotation: [
                        "Dot with absolute qualified identifier",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "fpLiteralExp",
                        node_id: Span {
                            start: <stdin>:361:12,
                            end: <stdin>:361:24,
                        },
                    },
                    value: Expr {
                        kind: LiteralFloat(
                            "0.1234",
                        ),
                        node_id: Span {
                            start: <stdin>:361:27,
                            end: <stdin>:361:33,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:361:3,
                        end: <stdin>:361:33,
                    },
                    pre_annotation: [
                        "FP literal",
                    ],
                    post_annotation: [
                        "FP literal",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "identExp",
                        node_id: Span {
                            start: <stdin>:365:12,
                            end: <stdin>:365:20,
                        },
                    },
                    value: Expr {
                        kind: Ident {
                            value: "x",
                            is_absolute: false,
                        },
                        node_id: Span {
                            start: <stdin>:365:23,
                            end: <stdin>:365:24,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:365:3,
                        end: <stdin>:365:24,
                    },
                    pre_annotation: [
                        "Identifier",
                    ],
                    post_annotation: [
                        "Identifier",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "identAbsoluteExp",
                        node_id: Span {
                            start: <stdin>:369:12,
                            end: <stdin>:369:28,
                        },
                    },
                    value: Expr {
                        kind: Ident {
                            value: "x",
                            is_absolute: true,
                        },
                        node_id: Span {
                            start: <stdin>:369:31,
                            end: <stdin>:369:33,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:369:3,
                        end: <stdin>:369:33,
                    },
                    pre_annotation: [
                        "Identifier with absolute qualified identifier",
                    ],
                    post_annotation: [
                        "Identifier with absolute qualified identifier",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "intLiteralExp",
                        node_id: Span {
                            start: <stdin>:373:12,
                            end: <stdin>:373:25,
                        },
                    },
                    value: Expr {
                        kind: LiteralInt(
                            "1234",
                        ),
                        node_id: Span {
                            start: <stdin>:373:28,
                            end: <stdin>:373:32,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:373:3,
                        end: <stdin>:373:32,
                    },
                    pre_annotation: [
                        "Int literal",
                    ],
                    post_annotation: [
                        "Int literal",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "parenExp",
                        node_id: Span {
                            start: <stdin>:377:12,
                            end: <stdin>:377:20,
                        },
                    },
                    value: Expr {
                        kind: Binop {
                            left: Expr {
                                kind: Paren(
                                    Expr {
                                        kind: Binop {
                                            left: Expr {
                                                kind: LiteralInt(
                                                    "1",
                                                ),
                                                node_id: Span {
                                                    start: <stdin>:377:24,
                                                    end: <stdin>:377:25,
                                                },
                                            },
                                            op: Add,
                                            right: Expr {
                                                kind: LiteralInt(
                                                    "2",
                                                ),
                                                node_id: Span {
                                                    start: <stdin>:377:28,
                                                    end: <stdin>:377:29,
                                                },
                                            },
                                        },
                                        node_id: Span {
                                            start: <stdin>:377:26,
                                            end: <stdin>:377:29,
                                        },
                                    },
                                ),
                                node_id: Span {
                                    start: <stdin>:377:23,
                                    end: <stdin>:377:30,
                                },
                            },
                            op: Mul,
                            right: Expr {
                                kind: LiteralInt(
                                    "3",
                                ),
                                node_id: Span {
                                    start: <stdin>:377:33,
                                    end: <stdin>:377:34,
                                },
                            },
                        },
                        node_id: Span {
                            start: <stdin>:377:31,
                            end: <stdin>:377:34,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:377:3,
                        end: <stdin>:377:34,
                    },
                    pre_annotation: [
                        "Paren",
                    ],
                    post_annotation: [
                        "Paren",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "stringLiteralSingleExp",
                        node_id: Span {
                            start: <stdin>:381:12,
                            end: <stdin>:381:34,
                        },
                    },
                    value: Expr {
                        kind: LiteralString(
                            "This is a string.",
                        ),
                        node_id: Span {
                            start: <stdin>:381:37,
                            end: <stdin>:381:56,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:381:3,
                        end: <stdin>:381:56,
                    },
                    pre_annotation: [
                        "String literal single",
                    ],
                    post_annotation: [
                        "String literal single",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "stringLiteralMultExp",
                        node_id: Span {
                            start: <stdin>:385:12,
                            end: <stdin>:385:32,
                        },
                    },
                    value: Expr {
                        kind: LiteralString(
                            "line 1\nline 2\nline 3\n",
                        ),
                        node_id: Span {
                            start: <stdin>:385:35,
                            end: <stdin>:389:38,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:385:3,
                        end: <stdin>:389:38,
                    },
                    pre_annotation: [
                        "String literal multi",
                    ],
                    post_annotation: [
                        "String literal multi",
                    ],
                },
                DefConstant {
                    name: Name {
                        data: "structExp",
                        node_id: Span {
                            start: <stdin>:393:12,
                            end: <stdin>:393:21,
                        },
                    },
                    value: Expr {
                        kind: Struct(
                            [
                                StructExprMember {
                                    name: Name {
                                        data: "a",
                                        node_id: Span {
                                            start: <stdin>:393:26,
                                            end: <stdin>:393:27,
                                        },
                                    },
                                    value: Expr {
                                        kind: LiteralInt(
                                            "1",
                                        ),
                                        node_id: Span {
                                            start: <stdin>:393:30,
                                            end: <stdin>:393:31,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:393:26,
                                        end: <stdin>:393:31,
                                    },
                                },
                                StructExprMember {
                                    name: Name {
                                        data: "b",
                                        node_id: Span {
                                            start: <stdin>:393:33,
                                            end: <stdin>:393:34,
                                        },
                                    },
                                    value: Expr {
                                        kind: LiteralInt(
                                            "2",
                                        ),
                                        node_id: Span {
                                            start: <stdin>:393:37,
                                            end: <stdin>:393:38,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:393:33,
                                        end: <stdin>:393:38,
                                    },
                                },
                                StructExprMember {
                                    name: Name {
                                        data: "c",
                                        node_id: Span {
                                            start: <stdin>:393:40,
                                            end: <stdin>:393:41,
                                        },
                                    },
                                    value: Expr {
                                        kind: LiteralInt(
                                            "3",
                                        ),
                                        node_id: Span {
                                            start: <stdin>:393:44,
                                            end: <stdin>:393:45,
                                        },
                                    },
                                    node_id: Span {
                                        start: <stdin>:393:40,
                                        end: <stdin>:393:45,
                                    },
                                },
                            ],
                        ),
                        node_id: Span {
                            start: <stdin>:393:24,
                            end: <stdin>:393:47,
                        },
                    },
                    is_dictionary_def: false,
                    node_id: Span {
                        start: <stdin>:393:3,
                        end: <stdin>:393:47,
                    },
                    pre_annotation: [
                        "Struct",
                    ],
                    post_annotation: [
                        "Struct",
                    ],
                },
                DefModule {
                    name: Name {
                        data: "SizeOf",
                        node_id: Span {
                            start: <stdin>:397:10,
                            end: <stdin>:397:16,
                        },
                    },
                    members: [
                        DefConstant {
                            name: Name {
                                data: "typeFloat",
                                node_id: Span {
                                    start: <stdin>:398:14,
                                    end: <stdin>:398:23,
                                },
                            },
                            value: Expr {
                                kind: SizeOf(
                                    TypeName {
                                        kind: Floating(
                                            F64,
                                        ),
                                        node_id: Span {
                                            start: <stdin>:398:33,
                                            end: <stdin>:398:36,
                                        },
                                    },
                                ),
                                node_id: Span {
                                    start: <stdin>:398:26,
                                    end: <stdin>:398:37,
                                },
                            },
                            is_dictionary_def: false,
                            node_id: Span {
                                start: <stdin>:398:5,
                                end: <stdin>:398:37,
                            },
                        },
                        DefConstant {
                            name: Name {
                                data: "typeQualId",
                                node_id: Span {
                                    start: <stdin>:399:14,
                                    end: <stdin>:399:24,
                                },
                            },
                            value: Expr {
                                kind: SizeOf(
                                    TypeName {
                                        kind: QualIdent(
                                            Qualified {
                                                qualifier: Unqualified {
                                                    name: Ident {
                                                        data: "TypeNames",
                                                        node_id: Span {
                                                            start: <stdin>:399:34,
                                                            end: <stdin>:399:43,
                                                        },
                                                    },
                                                    is_absolute: false,
                                                    node_id: Span {
                                                        start: <stdin>:399:34,
                                                        end: <stdin>:399:43,
                                                    },
                                                },
                                                name: Ident {
                                                    data: "typeNameU32",
                                                    node_id: Span {
                                                        start: <stdin>:399:44,
                                                        end: <stdin>:399:55,
                                                    },
                                                },
                                                node_id: Span {
                                                    start: <stdin>:399:34,
                                                    end: <stdin>:399:55,
                                                },
                                            },
                                        ),
                                        node_id: Span {
                                            start: <stdin>:399:34,
                                            end: <stdin>:399:55,
                                        },
                                    },
                                ),
                                node_id: Span {
                                    start: <stdin>:399:27,
                                    end: <stdin>:399:56,
                                },
                            },
                            is_dictionary_def: false,
                            node_id: Span {
                                start: <stdin>:399:5,
                                end: <stdin>:399:56,
                            },
                        },
                        DefConstant {
                            name: Name {
                                data: "typeString",
                                node_id: Span {
                                    start: <stdin>:400:14,
                                    end: <stdin>:400:24,
                                },
                            },
                            value: Expr {
                                kind: SizeOf(
                                    TypeName {
                                        kind: String(
                                            Some(
                                                Expr {
                                                    kind: LiteralInt(
                                                        "20",
                                                    ),
                                                    node_id: Span {
                                                        start: <stdin>:400:46,
                                                        end: <stdin>:400:48,
                                                    },
                                                },
                                            ),
                                        ),
                                        node_id: Span {
                                            start: <stdin>:400:34,
                                            end: <stdin>:400:48,
                                        },
                                    },
                                ),
                                node_id: Span {
                                    start: <stdin>:400:27,
                                    end: <stdin>:400:49,
                                },
                            },
                            is_dictionary_def: false,
                            node_id: Span {
                                start: <stdin>:400:5,
                                end: <stdin>:400:49,
                            },
                        },
                    ],
                    node_id: Span {
                        start: <stdin>:397:3,
                        end: <stdin>:401:4,
                    },
                    pre_annotation: [
                        "SizeOf",
                    ],
                    post_annotation: [
                        "SizeOf",
                    ],
                },
            ],
            node_id: Span {
                start: <stdin>:322:1,
                end: <stdin>:404:2,
            },
            pre_annotation: [
                "Expressions",
            ],
            post_annotation: [
                "Expressions",
            ],
        },
    ],
)