schema_isa.yaml

###
#Vendor
#------
#
# - **Description**: A string capturing the vendor name.
#
# - **Examples**:
#
#   .. code-block:: yaml
#
#     Vendor: Shakti
#     Vendor: Incoresemi

Vendor: {type: string}

###
#Device
#------
#
# - **Description**: A string capturing the device name.
#
# - **Examples**:
#
#   .. code-block:: yaml
#
#     Device: E-Class
#     Device: C-Class

Device: {type: string}

hart_schema:
  type : dict
  schema: 
    ###
    #ISA
    #---
    #
    # - **Description**: Takes input a string representing the ISA supported by the implementation. All extension names
    #   (other than Zext) should be mentioned in upper-case. Z extensions should begin with an upper-case
    #   'Z' followed by lower-case extension name (without Camel casing)
    # - **Default**:  This is a required field to be set by the user. No defaults exist.
    # - **Constraints**:
    #
    #     - Certain extensions are only valid in certain user-spec version. For, eg. Zifencei is available only in user-spec 2.3 and above.
    #     - The ISA string must be specified as per the convention mentioned in the specifications(like subsequent Z extensions must be separated with an '_')
    #
    # - **Examples**:
    #
    #   .. code-block:: yaml
    #
    #     ISA: RV32IMA
    #     ISA: RV64IMAFDCZifencei

    ISA: { type: string, required: true, check_with: capture_isa_specifics}
    
    ###
    #User_Spec_Version
    #-----------------
    #
    # - **Description**: Version number of User/Non-priveleged ISA specification as string. Please enclose the version in "" to avoid type mismatches.
    # - **Default**: 2.2
    # - **Constraints**: should be a valid version later than 2.2
    # - **Examples**:
    #
    #   .. code-block:: yaml
    #
    #     User_Spec_Version: "2.2"
    #     User_Spec_Version: "2.3"

    User_Spec_Version: {type: string,  default: '2.2', required: true, allowed: ["2.2", "2.3"]}
    ###
    #Privilege_Spec_Version
    #----------------------
    #
    # - **Description**: Version number of Priveleged ISA specification as string. Please enclose the version in "" to avoid type mismatches.
    # - **Default**: "1.10"
    # - **Constraints**: should be a valid version later than 1.10
    # - **Examples**:
    #
    #   .. code-block:: yaml
    #
    #     Privilege_Spec_Version: "1.10"
    #     Privilege_Spec_Version: "1.11"

    Privilege_Spec_Version: { type: string, default: '1.10', required: true, 
                              allowed: ["1.10", "1.11", "0"] }
    ###
    #hw_data_misaligned_support
    #--------------------------
    #
    # - **Description**: A boolean value indicating whether hardware support for misaligned load/store requests exists.
    # - **Default**: False
    # - **Constraints**: None
    # - **Examples**:
    #
    #   .. code-block:: yaml
    #
    #      hw_data_misaligned_support: True
    #      hw_data_misaligned_support: False

    hw_data_misaligned_support: {type: boolean, default: false}
    
    ###
    #supported_xlen
    #--------------
    #
    # - **Description**: list of supported xlen on the target
    # - **Default**:  This is a required field to be set by the user. No defaults exist.
    # - **Constraints**: list should include integers from:  32, 64 and/or 128. XLEN=128 is not fully supported though.
    # - **Examples**:
    #
    #   .. code-block:: yaml
    #
    #     supported_xlen : [32]
    #     supported_xlen : [64, 32]
    #     supported_xlen : [64]

    supported_xlen:
      type: list
      schema: { type: integer, allowed: [ 32, 64, 128] }
      required: true
      check_with: isa_xlen
      
    ###
    #pmp_granularity
    #---------------
    #
    # - **Description**: Granularity of pmps
    # - **Default**: 0
    # - **Constraints**: None
    # - **Examples**:
    #
    #   .. code-block:: yaml
    #
    #     pmp_granularity : 2
    #     pmp_granularity : 4

    pmp_granularity:
      type: integer
      min: 0
      default: 0
      
    ###
    #physical_addr_sz
    #----------------
    #
    # - **Description**: size of the physical address
    # - **Default**:  This is a required field to be set by the user. No defaults exist.
    # - **Constraints**: cannot exceed 56 bits
    # - **Examples**:
    #
    #   .. code-block:: yaml
    #
    #     physical_addr_sz : 32

    physical_addr_sz:
      type: integer
      max: 56
      required: true
      check_with: phy_addr

    ###
    #custom_exceptions
    #-----------------
    #
    # - **Description**: A dictionary of custom exceptions implemented by the device. Each node in the
    #   dictionary contains 3 fields:
    #
    #     - cause_val: and integer indicating the cause value associated with that exception. Cannot
    #       be a reserved cause value.
    #     - cause_name: a string containing the name of the exception
    #     - priv_mode: a string containing one-of M, S or U indicating the privilege mode to which the
    #       exception is associated with.
    # - **Default**: null dictionary indicating no custom exceptions exist.
    # - **Constraints**: Reserved encodings cannot be used in cause_val
    # - **Examples**:
    #
    #   .. code-block:: yaml
    #
    #     custom_exceptions: 
    #       - cause_val: 25
    #         cause_name: mycustom
    #         priv_mode: M
    #       - cause_val: 26
    #         cause_name: mycustom2
    #         priv_mode: M

    custom_exceptions:
      type: list
      schema:
        type: dict
        schema:
          cause_val: {type: integer, min: 24, max: 63, forbidden: [16,17,18,19,20,21,22,23,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47]}
          cause_name: {type: string}
          priv_mode: {type: string, default: 'M', allowed: ['M','S','U']}
        nullable: True
      nullable: True
      default:
    
    ###
    #custom_interrupts
    #-----------------
    #
    # - **Description**: A dictionary of custom interrupts implemented by the device. Each node in the
    #   dictionary contains 4 fields:
    #
    #     - cause_val: and integer indicating the cause value associated with that interrupt. Cannot
    #       be a reserved cause value.
    #     - cause_name: a string containing the name of the interrupt
    #     - priv_mode: a string containing one-of M, S or U indicating the privilege mode to which the
    #       exception is associated with.
    #     - on_reset_enable: an integer which be 0 or 1, indicating the whether the interrupt is
    #       enable on reset or not.
    # - **Default**: null dictionary indicating no custom exceptions exist.
    # - **Constraints**: Reserved encodings cannot be used in cause_val
    # - **Examples**:
    #
    #   .. code-block:: yaml
    #
    #     custom_interrupts: 
    #       - cause_val: 25
    #         cause_name: mycustom
    #         priv_mode: M
    #         on_reset_enable: 1    
    #       - cause_val: 26
    #         cause_name: mycustom2
    #         priv_mode: S
    #         on_reset_enable: 0

    custom_interrupts:
      type: list
      schema:
        type: dict
        schema:
          cause_val: {type: integer, min: 16}
          cause_name: {type: string}
          on_reset_enable: {type: integer, min: 0, max: 1, default: 0}
          priv_mode: {type: string, default: 'M', allowed: ['M','S','U']}
        nullable: True
      nullable: True
      default:

    ###
    #pte_ad_hw_update
    #-----------------
    #
    # - **Description**: This is a boolean field indicating that when a virtual page is accessed 
    #   and the A bit is clear, or is written and the D bit is clear, the implementation sets 
    #   the corresponding bit(s) in the PTE in the hardware itself and does not raise an exception
    #   for this particular scenario. When set to False, a corresponding page-fault exception needs
    #   to be raised.
    # - **Default**: False
    # - **Constraints**: Can be set to True only if 'S' mode is implemented in the ISA and if
    #   stap.mode can be set to one of the virtualization modes.
    # - **Examples**:
    #   
    #   .. code-block:: yaml
    #
    #     pte_ad_hw_update: False
    #     pte_ad_hw_update: True

    pte_ad_hw_update: {type: boolean,  default: False, check_with: s_exists}

    ###
    #mtval_update
    #------------
    #
    # - **Description**: This field a basically a bitmap. If bit `n` is set, it indicates
    #   that the device will update the mtval CSR with a non-zero value when an exception corresponding to
    #   cause `n` occurs. A value of zero will indicate that the exception `n` will update the mtval
    #   with value 0.
    # - **Default**: 255 (set for exception cause values 0-7)
    # - **Constraints**: 
    #
    #   - reserved bits [10, 11, 16-23, 32-47, >=64] must be zeros always
    #   - bits corresponding to page-faults can only be set if 'S' mode is implemented
    #   - bits corresponding to guest-page faults can only be set if 'H' mode is implemented
    #
    # - **Examples**:
    #
    #   .. code-block:: yaml
    #     
    #     mtval_update: 0b1110

    mtval_update: {type: integer, default: 0b11111111, check_with: mtval_update}


    schema_node:
      type: dict
      allow_unknown: false
      noneof:
      - schema:
          warl: &ref_warl
            type: dict
            schema:
              dependency_fields:
                type: list
                empty: true
                schema:
                  type: string
                  nullable: true
              legal:
                type: list
                schema:
                  type: string
              wr_illegal:
                type: list
                schema:
                  type: string
      - 
        schema:
          wlrl: &ref_wlrl
            type: list
            schema:
              type: string
              regex: (^0x[012456789abcdef]+:0x[0123456789abcdef]+$)|(^[0-9]+:[0-9]+$)|(^[0-9]+$)|(^0x[012456789abcdef]+$)
    gen_flatschema_machine:
      schema:  &gen_flatschema_machine
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              - schema: { warl: *ref_warl }
              - schema: { wlrl: *ref_wlrl }
              default:
                ro_constant: 0
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max: 0xFFFFFFFFFFFFFFFF}}
              - schema: { warl: *ref_warl }
              - schema: { wlrl: *ref_wlrl }
              default:
                ro_constant: 0
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: False}
    gen_flatschema_machine32:
      schema:  &gen_flatschema_machine32
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          default: 0
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF }}
              - schema: { warl: *ref_warl }
              default:
                ro_constant: 0
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible:
              default: False
          default: {accessible: False}
    misa:
      type: dict
      schema:
        description: {type: string,  default: misa is a read-write register reporting the ISA supported by the hart.}
        address: { type: integer, default: 769, allowed: [769] }
        priv_mode: { type: string, allowed: [M], default: M }
        reset-val: { type: integer, default: 0, check_with: [max_length, reset_ext] }
        rv32:
          type: dict
          schema:
            fields: { type: list, default: [] }
            mxl:
              type: dict
              schema:
                description: {type: string,  default: Encodes the native base integer ISA width.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: { type: integer, default: 31, allowed: [31] }
                lsb: { type: integer, default: 30, allowed: [30] }
                implemented: { type: boolean, default: false }
                type:
                  type: dict
                  oneof:
                    - schema: {ro_constant: {type: integer, max: 0x3, min: 0x1}}
                    - schema: {ro_variable: {type: boolean}}
                    - schema: { warl: *ref_warl }
                  default:
                     warl:
                       dependency_fields: []
                       legal:
                         - mxl[1:0] in [0x1]
                       wr_illegal:
                         - unchanged
              default: {implemented: true}
            extensions:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the presence of the standard extensions, with a single
                    bit per letter of the alphabet.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 25, allowed: [25]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: false}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  0x3ffffff}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - extensions[25:0] bitmask [0x3FFFFFFF, 0x00000000]
                      wr_illegal:
                        - unchanged
                  
              default: {implemented: true}
            accessible:
              type: boolean
              default: true
              check_with: [rv32_check, cannot_be_false_rv32]
          default: {accessible: false}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            mxl:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the native base integer ISA width.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 62, allowed: [62]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  3, min: 1}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - mxl[1:0] in [0x2]
                      wr_illegal:
                        - unchanged
              default: {implemented: true}
            extensions:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the presence of the standard extensions, with a single
                    bit per letter of the alphabet.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 25, allowed: [25]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  0x3ffffff}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - extensions[25:0] bitmask [0x3FFFFFFF, 0x00000000]
                      wr_illegal:
                        - unchanged
              default: {implemented: true}
            accessible:
              type: boolean
              default: true
              check_with: [rv64_check, cannot_be_false_rv64]
          default: {accessible: false}
    mstatus:
      type: dict
      schema:
        description:
          type: string
          default: The mstatus register keeps track of and controls the hart’s current
            operating state.
        address: {type: integer, default: 768, allowed: [768]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            uie:
              type: dict
              schema:
                description: {type: string,  default: Stores the state of the user mode interrupts.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    wlrl: 
                    - 0:1
              default: {implemented: false}
              check_with: n_check
            sie:
              type: dict
              schema:
                description: { type: string, default: Stores the state of the supervisor mode interrupts.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    wlrl: 
                    - 0:1
              default: {implemented: false}
              check_with: s_check
            mie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the machine mode interrupts.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 3, allowed: [3]}
                lsb: {type: integer, default: 3, allowed: [3]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default: { wlrl: [0:1] }
              default: {implemented: true}
            upie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the user mode interrupts prior to the trap.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    wlrl: 
                    - 0:1
              default: {implemented: false}
              check_with: n_check
            spie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the supervisor mode interrupts prior to
                    the trap.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    wlrl: 
                    - 0:1
              default: {implemented: false}
              check_with: s_check
            mpie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the machine mode interrupts prior to the
                    trap.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default: { wlrl: [0:1]}
              default: {implemented: true}
            spp:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the previous priority mode for supervisor.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
              check_with: s_check
            mpp:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the previous priority mode for machine.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 12, allowed: [12]}
                lsb: {type: integer, default: 11, allowed: [11]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: true}
            fs:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the status of the floating-point unit, including the
                    CSR fcsr and floating-point data registers.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 14, allowed: [14]}
                lsb: {type: integer, default: 13, allowed: [13]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                       dependency_fields: []
                       legal:
                         - fs[1:0] in [0x0:0x3]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
              check_with: fs_check
            xs:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the status of additional user-mode extensions and associated
                    state.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 16, allowed: [16]}
                lsb: {type: integer, default: 15, allowed: [15]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: { warl: *ref_warl }
                  - schema: {ro_variable: {type: boolean}}
                  default: {ro_constant: 0}
              default: {implemented: false}
            mprv:
              type: dict
              schema:
                description:
                  type: string
                  default: Modifies the privilege level at which loads and stores execute
                    in all privilege modes.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 17, allowed: [17]}
                lsb: {type: integer, default: 17, allowed: [17]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    warl:
                       dependency_fields: []
                       legal:
                         - mprv[0] in [0x0, 0x1]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
              check_with: u_check
            sum:
              type: dict
              schema:
                description:
                  type: string
                  default: Modifies the privilege with which S-mode loads and stores access
                    virtual memory.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 18, allowed: [18]}
                lsb: {type: integer, default: 18, allowed: [18]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    warl:
                       dependency_fields: []
                       legal:
                         - sum[0] in [0x0]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
              check_with: s_check
            mxr:
              type: dict
              schema:
                description:
                  type: string
                  default: Modifies the privilege with which loads access virtual memory.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 19, allowed: [19]}
                lsb: {type: integer, default: 19, allowed: [19]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                       dependency_fields: []
                       legal:
                         - mxr[0] in [0x0]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
              check_with: s_check
            tvm:
              type: dict
              schema:
                description:
                  type: string
                  default: Supports intercepting supervisor virtual-memory management
                    operations.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 20, allowed: [20]}
                lsb: {type: integer, default: 20, allowed: [20]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                       dependency_fields: []
                       legal:
                         - tvm[0] in [0x0]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
              check_with: s_check
            tw:
              type: dict
              schema:
                description:
                  type: string
                  default: Supports intercepting the WFI instruction.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 21, allowed: [21]}
                lsb: {type: integer, default: 21, allowed: [21]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default: {ro_constant: 0}
              default: {implemented: false}
              check_with: su_check
            tsr:
              type: dict
              schema:
                description:
                  type: string
                  default: Supports intercepting the supervisor exception return instruction.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 22, allowed: [22]}
                lsb: {type: integer, default: 22, allowed: [22]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                       dependency_fields: []
                       legal:
                         - tsr[0] in [0x0]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
              check_with: s_check
            spelp:
              type: dict
              schema:
                description:
                  type: string
                  default: Supervisor mode previous expected-landing-pad (ELP) state.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 23, allowed: [23]}
                lsb: {type: integer, default: 23, allowed: [23]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                       dependency_fields: []
                       legal:
                         - spelp[0] in [0x0]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
              check_with: s_check
            sd:
              type: dict
              schema:
                description:
                  type: string
                  default: Read-only bit that summarizes whether either the FS field or
                    XS field signals the presence of some dirty state.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 31, allowed: [31]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    wlrl: 
                     - 0:1
              default: {implemented: true}
              check_with: fs_check
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            uie:
              type: dict
              schema:
                description: {type: string,  default: Stores the state of the user mode interrupts.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  default: 
                    wlrl: 
                    - 0:1
              default: {implemented: false}
              check_with: n_check
            sie:
              type: dict
              schema:
                description: { type: string, default: Stores the state of the supervisor mode interrupts.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  default: 
                    wlrl: 
                    - 0:1
              default: {implemented: false}
              check_with: s_check
            mie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the machine mode interrupts.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 3, allowed: [3]}
                lsb: {type: integer, default: 3, allowed: [3]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default: { wlrl: [0:1] }
              default: {implemented: true}
            upie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the user mode interrupts prior to the trap.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  default: 
                    wlrl: 
                    - 0:1
              default: {implemented: false}
              check_with: n_check
            spie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the supervisor mode interrupts prior to
                    the trap.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  default:
                    wlrl: 
                    - 0:1
              default: {implemented: false}
              check_with: s_check
            mpie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the machine mode interrupts prior to the
                    trap.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default: { wlrl: [0:1]}
              default: {implemented: true}
            spp:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the previous priority mode for supervisor.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  default: {ro_constant: 0}
              default: {implemented: false}
              check_with: s_check
            mpp:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the previous priority mode for machine.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 12, allowed: [12]}
                lsb: {type: integer, default: 11, allowed: [11]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: true}
            fs:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the status of the floating-point unit, including the
                    CSR fcsr and floating-point data registers.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 14, allowed: [14]}
                lsb: {type: integer, default: 13, allowed: [13]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    warl:
                       dependency_fields: []
                       legal:
                         - fs[1:0] in [0x0:0x3]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
              check_with: fs_check
            xs:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the status of additional user-mode extensions and associated
                    state.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 16, allowed: [16]}
                lsb: {type: integer, default: 15, allowed: [15]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
            mprv:
              type: dict
              schema:
                description:
                  type: string
                  default: Modifies the privilege level at which loads and stores execute
                    in all privilege modes.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 17, allowed: [17]}
                lsb: {type: integer, default: 17, allowed: [17]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    warl:
                       dependency_fields: []
                       legal:
                         - mprv[0] in [0x0, 0x1]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
              check_with: u_check
            sum:
              type: dict
              schema:
                description:
                  type: string
                  default: Modifies the privilege with which S-mode loads and stores access
                    virtual memory.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 18, allowed: [18]}
                lsb: {type: integer, default: 18, allowed: [18]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    warl:
                       dependency_fields: []
                       legal:
                         - sum[0] in [0x0]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
              check_with: s_check
            mxr:
              type: dict
              schema:
                description:
                  type: string
                  default: Modifies the privilege with which loads access virtual memory.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 19, allowed: [19]}
                lsb: {type: integer, default: 19, allowed: [19]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    warl:
                       dependency_fields: []
                       legal:
                         - mxr[0] in [0x0]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
              check_with: s_check
            tvm:
              type: dict
              schema:
                description:
                  type: string
                  default: Supports intercepting supervisor virtual-memory management
                    operations.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 20, allowed: [20]}
                lsb: {type: integer, default: 20, allowed: [20]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    warl:
                       dependency_fields: []
                       legal:
                         - tvm[0] in [0x0]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
              check_with: s_check
            tw:
              type: dict
              schema:
                description:
                  type: string
                  default: Supports intercepting the WFI instruction.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 21, allowed: [21]}
                lsb: {type: integer, default: 21, allowed: [21]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
              check_with: su_check
            tsr:
              type: dict
              schema:
                description:
                  type: string
                  default: Supports intercepting the supervisor exception return instruction.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 22, allowed: [22]}
                lsb: {type: integer, default: 22, allowed: [22]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    warl:
                       dependency_fields: []
                       legal:
                         - tsr[0] in [0x0]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
              check_with: s_check
            spelp:
              type: dict
              schema:
                description:
                  type: string
                  default: Supervisor mode previous expected-landing-pad (ELP) state.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 23, allowed: [23]}
                lsb: {type: integer, default: 23, allowed: [23]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                       dependency_fields: []
                       legal:
                         - spelp[0] in [0x0]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
              check_with: s_check
            sxl:
              type: dict
              schema:
                description:
                  type: string
                  default: Controls the value of xlen for Supervisor mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 35, allowed: [35]}
                lsb: {type: integer, default: 34, allowed: [34]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 2, min: 1}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 2}
              default: {implemented: true}
              check_with: s_check
            uxl:
              type: dict
              schema:
                description: {type: string, default: Controls the xlen for User mode.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 33, allowed: [33]}
                lsb: {type: integer, default: 32, allowed: [32]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  2, min: 1}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 2}
              default: {implemented: true}
              check_with: u_check
            gva:                
              type: dict
              schema:
                description:
                  type: string
                  default: For any trap (access fault, page fault, or guest-page fault) that writes a guest virtual address to mtval, GVA is set to 1.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 38, allowed: [38]}
                lsb: {type: integer, default: 38, allowed: [38]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: False} 
              check_with: h_check            
            mpv:
              type: dict
              schema:
                description:
                  type: string
                  default: Machine Previous Virtualization Mode is written by the implementation whenever a trap is taken into M-mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 39, allowed: [39]}
                lsb: {type: integer, default: 39, allowed: [39]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: False} 
              check_with: h_check
            mpelp:
              type: dict
              schema:
                description:
                  type: string
                  default: Machine mode previous expected-landing-pad (ELP) state.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 41, allowed: [41]}
                lsb: {type: integer, default: 41, allowed: [41]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                       dependency_fields: []
                       legal:
                         - mpelp[0] in [0x0]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
            sd:
              type: dict
              schema:
                description:
                  type: string
                  default: Read-only bit that summarizes whether either the FS field or
                    XS field signals the presence of some dirty state.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 63, allowed: [63]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    wlrl: 
                     - 0:1
              default: {implemented: true}
              check_with: fs_check
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
          default: {accessible: true}
    mstatush:
      type: dict
      schema:
        description:
          type: string
          default: The mstatush register keeps track of and controls the hart’s current
            operating state.
        address: {type: integer, default: 768, allowed: [768]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            mpv:
              type: dict
              schema:
                description: {type: string,  default: Stores the state of the user mode interrupts.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
              check_with: h_check
            gva:
              type: dict
              schema:
                description: { type: string, default: Stores the state of the supervisor mode interrupts.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
              check_with: h_check
            mbe:
              type: dict
              schema:
                description: { type: string, default: control the endianness of memory accesses other than instruction fetches for machine mode}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
            sbe:
              type: dict
              schema:
                description: { type: string, default: control the endianness of memory accesses other than instruction fetches for supervisor mode}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
            mpelp:
              type: dict
              schema:
                description: { type: string, default: Machine mode previous expected-landing-pad (ELP) state.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 9, allowed: [9]}
                lsb: {type: integer, default: 9, allowed: [9]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
            type: dict
            schema: {accessible: {type: boolean, default: False, allowed: [False]}}
            default: {accessible: False}      
        
    mvendorid:
      type: dict
      schema:
        description:
          type: string
          default: 32-bit read-only register providing the JEDEC manufacturer ID of the
            provider of the core.
        address: {type: integer, default: 3857, allowed: [3857]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          default: 0
          check_with:
          - max_length32
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              default:
                ro_constant: 0
            accessible:
              type: boolean
              default: true
              check_with:
              - rv32_check
              - cannot_be_false_rv32
          default: {accessible: false}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              default:
                ro_constant: 0
            accessible:
              default: true
              check_with:
              - rv64_check
              - cannot_be_false_rv64
          default: {accessible: false}
    marchid:
      type: dict
      schema:
        description:
          type: string
          default: MXLEN-bit read-only register encoding the base microarchitecture of
            the hart.
        address: {type: integer, default: 3858, allowed: [3858]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              default:
                ro_constant: 0
            accessible:
              type: boolean
              default: true
              check_with:
              - rv32_check
              - cannot_be_false_rv32
          default: {accessible: false}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: {ro_constant: {type: integer, max:  18446744073709551615}}
              default:
                ro_constant: 0
            accessible:
              type: boolean
              default: true
              check_with:
              - rv64_check
              - cannot_be_false_rv64
          default: {accessible: false}
    mimpid:
      type: dict
      schema:
        description:
          type: string
          default: Provides a unique encoding of the version of the processor implementation.
        address: {type: integer, default: 3859, allowed: [3859]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: {ro_constant: {type: integer, max:  0xFFFFFFFFFFFFFFFF}}
              default:
                ro_constant: 0
            accessible:
              type: boolean
              default: true
              check_with:
              - rv32_check
              - cannot_be_false_rv32
          default: {accessible: false}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: {ro_constant: {type: integer, max:  18446744073709551615}}
              default:
                ro_constant: 0
            accessible:
              type: boolean
              default: true
              check_with:
              - rv64_check
              - cannot_be_false_rv64
          default: {accessible: false}
    mhartid:
      type: dict
      schema:
        description:
          type: string
          default: MXLEN-bit read-only register containing the integer ID of the hardware
            thread running the code.
        address: {type: integer, default: 3860, allowed: [3860]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              default:
                ro_constant: 0
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: {ro_constant: {type: integer, max:  0xFFFFFFFFFFFFFFFF}}
              default:
                ro_constant: 0
            accessible:
              type: boolean
              default: true
              check_with: rv64_check
          default: {accessible: false}
    mtvec:
      type: dict
      schema:
        description:
          type: string
          default: MXLEN-bit read/write register that holds trap vector configuration.
        address: {type: integer, default: 773, allowed: [773]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          check_with:
          - max_length
          default: 0
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            base:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector base address.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  1073741823}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                     warl:
                       dependency_fields: []
                       legal:
                         - "base[29:0] bitmask [0x3FFFFFFF, 0x00000000]"
                       wr_illegal:
                         - "Unchanged"
              default: {implemented: true}
            mode:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  1}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                      dependency_fields: []
                      legal:
                        - "mode[1:0] in [0x0,0x1]"
                      wr_illegal:
                        - "Unchanged"
              default: {implemented: true}
            accessible:
              type: boolean
              check_with:
              - rv32_check
              - cannot_be_false_rv32
          default: {accessible: false}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            base:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector base address.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  4611686018427387903}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                        dependency_fields: []
                        legal:
                          - "base[61:0] bitmask [0x3FFFFFFFFFFFFFFF, 0x0000000000000000]"
                        wr_illegal:
                          - "Unchanged"
              default: {implemented: true}
            mode:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  1}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                        dependency_fields: []
                        legal:
                          - 'mode[1:0] in [0x0:0x1]'
                        wr_illegal:
                          - Unchanged
              default: {implemented: true}
            accessible:
              type: boolean
              check_with:
              - rv64_check
              - cannot_be_false_rv64
          default: {accessible: false}
    mideleg:
      type: dict
      schema:
        description:
          type: string
          default: Machine Interrupt delegation Register.
        address: {type: integer, default: 771, allowed: [771]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: sn_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                    - mideleg[31:0] bitmask [0x0000F7FF,0x00000000]
                  wr_illegal:
                    - Unchanged
            accessible:
              type: boolean
              default: true
              check_with:
              - rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: sn_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                    - mideleg[63:0] bitmask [0x000000000000F7FF,0x0000000000000000]
                  wr_illegal:
                    - Unchanged
            accessible:
              type: boolean
              default: true
              check_with:
              - rv64_check
          default: {accessible: false}
      check_with: mdeleg_checks
    medeleg:
      type: dict
      schema:
        description:
          type: string
          default: Machine Exception delegation Register.
        address: {type: integer, default: 770, allowed: [770]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          default: 0
          check_with:
          - max_length
          - medeleg_reset
        rv32:
          type: dict
          check_with: sn_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                    - medeleg[31:0] bitmask [0x0000F7FF,0x00000000]
                  wr_illegal:
                    - Unchanged'
            accessible:
              type: boolean
              default: true
              check_with:
              - rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: sn_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                    - medeleg[63:0] bitmask [0x000000000000F7FF,0x0000000000000000]
                  wr_illegal:
                    - Unchanged
            accessible:
              type: boolean
              default: true
              check_with:
              - rv64_check
          default: {accessible: false}
      check_with: mdeleg_checks
    
    mip:
      type: dict
      schema:
        description:
          type: string
          default: The mip register is an MXLEN-bit read/write register containing information on pending interrupts.
        address: {type: integer, default: 836, allowed: [836]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            usip:
              type: dict
              check_with: n_check
              schema:
                description:
                  type: string
                  default: User Software Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl: 
                    - 0:1
              default: {implemented: False}
            ssip:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: Supervisor Software Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl: 
                    - 0:1
              default: {implemented: False}
            vssip:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: VS-level Software Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vssip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            msip:
              type: dict
              schema:
                description:
                  type: string
                  default: Machine Software Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 3, allowed: [3]}
                lsb: {type: integer, default: 3, allowed: [3]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: {ro_variable: {type: boolean, allowed: [true]}}
                  readonly: true
                  default: {ro_variable: true}
              default: {implemented: true}
            utip:
              type: dict
              check_with: n_check
              schema:
                description:
                  type: string
                  default: User Timer Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl: 
                    - 0:1
              default: {implemented: False}
            stip:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: Supervisor Timer Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl: 
                    - 0:1
              default: {implemented: False}
            vstip:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: VS-level Timer Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vstip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            mtip:
              type: dict
              schema:
                description:
                  type: string
                  default: Machine Timer Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: {ro_variable: {type: boolean, allowed: [True]}}
                  readonly: true
                  default: {ro_variable: True}
              default: {implemented: true}
            ueip:
              type: dict
              check_with: n_check
              schema:
                description:
                  type: string
                  default: User External Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl: 
                    - 0:1
              default: {implemented: False}
            seip:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: Supervisor External Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 9, allowed: [9]}
                lsb: {type: integer, default: 9, allowed: [9]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl: 
                    - 0:1
              default: {implemented: False}
            vseip:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: VS-level External Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 10, allowed: [10]}
                lsb: {type: integer, default: 10, allowed: [10]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vseip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged              
              default: {implemented: False}
            meip:
              type: dict
              schema:
                description:
                  type: string
                  default: Machine External Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 11, allowed: [11]}
                lsb: {type: integer, default: 11, allowed: [11]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: {ro_variable: {type: boolean, allowed: [True]}}
                  readonly: true
                  default: {ro_variable: True}
              default: {implemented: true}
            sgeip:
              type: dict
              check_with: h_check
              schema:
                description:
                  type: string
                  default: HS-level External Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 12, allowed: [12]}
                lsb: {type: integer, default: 12, allowed: [12]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default: 
                   warl:
                      dependency_fields: []
                      legal:
                        - sgeip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            usip:
              type: dict
              check_with: n_check
              schema:
                description:
                  type: string
                  default: User Software Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl: 
                    - 0:1
              default: {implemented: False}
            ssip:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: Supervisor Software Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl: 
                    - 0:1
              default: {implemented: False}
            vssip:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: VS-level Software Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vssip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            msip:
              type: dict
              schema:
                description:
                  type: string
                  default: Machine Software Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 3, allowed: [3]}
                lsb: {type: integer, default: 3, allowed: [3]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: {ro_variable: {type: boolean, allowed: [true]}}
                  readonly: true
                  default: {ro_variable: true}
              default: {implemented: true}
            utip:
              type: dict
              check_with: n_check
              schema:
                description:
                  type: string
                  default: User Timer Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl: 
                    - 0:1
              default: {implemented: False}
            stip:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: Supervisor Timer Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl: 
                    - 0:1
              default: {implemented: False}
            vstip:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: VS-level Timer Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vstip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            mtip:
              type: dict
              schema:
                description:
                  type: string
                  default: Machine Timer Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: {ro_variable: {type: boolean, allowed: [True]}}
                  readonly: true
                  default: {ro_variable: True}
              default: {implemented: true}
            ueip:
              type: dict
              check_with: n_check
              schema:
                description:
                  type: string
                  default: User External Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl: 
                    - 0:1
              default: {implemented: False}
            seip:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: Supervisor External Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 9, allowed: [9]}
                lsb: {type: integer, default: 9, allowed: [9]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl: 
                    - 0:1
              default: {implemented: False}
            vseip:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: VS-level External Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 10, allowed: [10]}
                lsb: {type: integer, default: 10, allowed: [10]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vseip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            meip:
              type: dict
              schema:
                description:
                  type: string
                  default: Machine External Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 11, allowed: [11]}
                lsb: {type: integer, default: 11, allowed: [11]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: {ro_variable: {type: boolean, allowed: [True]}}
                  readonly: true
                  default: {ro_variable: True}
              default: {implemented: true}
            sgeip:
              type: dict
              check_with: h_check
              schema:
                description:
                  type: string
                  default: HS-level External Interrupt Pending.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 12, allowed: [12]}
                lsb: {type: integer, default: 12, allowed: [12]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                      dependency_fields: []
                      legal:
                        - sgeip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: false}
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
            
    hie:
      type: dict
      schema:
        description:
          type: string
          default: The hie register is an HSXLEN-bit read/write register containing interrupt
            enable bits.
        address: {type: integer, default: 0x604, allowed: [0x604]}
        priv_mode: {type: string, default: H, allowed: [H]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            vssie:
              type: dict
              schema:
                description: {type: string, default: VS-level Software Interrupt enable.}
                shadow: {type: string, default: mie.vssie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vssie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            vstie:
              type: dict
              schema:
                description: {type: string, default: VS-level Timer Interrupt enable.}
                shadow: {type: string, default: mie.vstie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vstie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            vseie:
              type: dict
              schema:
                description: { type: string, default: VS-level External Interrupt enable.}
                shadow: {type: string, default: mie.vseie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 10, allowed: [10]}
                lsb: {type: integer, default: 10, allowed: [10]}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vseie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            sgeie:
              type: dict
              check_with: h_check
              schema:
                description: { type: string, default: HS-level External Interrupt enable.}
                shadow: {type: string, default: mie.sgeie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 12, allowed: [12]}
                lsb: {type: integer, default: 12, allowed: [12]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - sgeie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            vssie:
              type: dict
              schema:
                description: {type: string, default: VS-level Software Interrupt enable.}
                shadow: {type: string, default: mie.vssie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vssie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            vstie:
              type: dict
              schema:
                description: {type: string, default: VS-level Timer Interrupt enable.}
                shadow: {type: string, default: mie.vstie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vstie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            vseie:
              type: dict
              schema:
                description: { type: string, default: VS-level External Interrupt enable.}
                shadow: {type: string, default: mie.vseie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 10, allowed: [10]}
                lsb: {type: integer, default: 10, allowed: [10]}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vseie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            sgeie:
              type: dict
              check_with: h_check
              schema:
                description: { type: string, default: HS-level External Interrupt enable.}
                shadow: {type: string, default: mie.sgeie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 12, allowed: [12]}
                lsb: {type: integer, default: 12, allowed: [12]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - sgeie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
    mie:
      type: dict
      schema:
        description:
          type: string
          default: The mie register is an MXLEN-bit read/write register containing interrupt
            enable bits.
        address: {type: integer, default: 772, allowed: [772]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            usie:
              type: dict
              check_with: n_check
              schema:
                description:
                  type: string
                  default: User Software Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: False}
            ssie:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: Supervisor Software Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: False}
            vssie:
              type: dict
              check_with: s_check
              schema:
                description: {type: string, default: VS-level Software Interrupt enable.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: True}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vssie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}        
            msie:
              type: dict
              schema:
                description:
                  type: string
                  default: Machine Software Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 3, allowed: [3]}
                lsb: {type: integer, default: 3, allowed: [3]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl: 
                    - 0x0:0x1
                  readonly: true
              default: {implemented: True}
            utie:
              type: dict
              check_with: n_check
              schema:
                description:
                  type: string
                  default: User Timer Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: False}
            stie:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: Supervisor Timer Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: False}
            vstie:
              type: dict
              check_with: s_check
              schema:
                description: {type: string, default: VS-level Timer Interrupt enable.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vstie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            mtie:
              type: dict
              schema:
                description:
                  type: string
                  default: Machine Timer Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default: 
                    wlrl: 
                    - 0:1
              default: {implemented: true}
            ueie:
              type: dict
              check_with: n_check
              schema:
                description:
                  type: string
                  default: User External Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl:
                     - 0:1
              default: {implemented: False}
            seie:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: Supervisor External Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 9, allowed: [9]}
                lsb: {type: integer, default: 9, allowed: [9]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: False}
            vseie:
              type: dict
              check_with: s_check
              schema:
                description: { type: string, default: VS-level External Interrupt enable.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 10, allowed: [10]}
                lsb: {type: integer, default: 10, allowed: [10]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vseie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            meie:
              type: dict
              schema:
                description:
                  type: string
                  default: Machine External Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 11, allowed: [11]}
                lsb: {type: integer, default: 11, allowed: [11]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default: 
                    wlrl: [0:1]
              default: {implemented: true}
            sgeie:
              type: dict
              check_with: h_check
              schema:
                description: { type: string, default: HS-level External Interrupt enable.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 12, allowed: [12]}
                lsb: {type: integer, default: 12, allowed: [12]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - sgeie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            usie:
              type: dict
              check_with: n_check
              schema:
                description:
                  type: string
                  default: User Software Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: False}
            ssie:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: Supervisor Software Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: False}
            vssie:
              type: dict
              check_with: s_check
              schema:
                description: {type: string, default: VS-level Software Interrupt enable.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vssie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}        
            msie:
              type: dict
              schema:
                description:
                  type: string
                  default: Machine Software Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 3, allowed: [3]}
                lsb: {type: integer, default: 3, allowed: [3]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl: 
                    - 0x0:0x1
                  readonly: true
              default: {implemented: True}
            utie:
              type: dict
              check_with: n_check
              schema:
                description:
                  type: string
                  default: User Timer Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: False}
            stie:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: Supervisor Timer Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: False}
            vstie:
              type: dict
              check_with: s_check
              schema:
                description: {type: string, default: VS-level Timer Interrupt enable.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vstie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            mtie:
              type: dict
              schema:
                description:
                  type: string
                  default: Machine Timer Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default: 
                    wlrl: 
                    - 0:1
              default: {implemented: true}
            ueie:
              type: dict
              check_with: n_check
              schema:
                description:
                  type: string
                  default: User External Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl:
                     - 0:1
              default: {implemented: False}
            seie:
              type: dict
              check_with: s_check
              schema:
                description:
                  type: string
                  default: Supervisor External Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 9, allowed: [9]}
                lsb: {type: integer, default: 9, allowed: [9]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: False}
            vseie:
              type: dict
              check_with: s_check
              schema:
                description: { type: string, default: VS-level External Interrupt enable.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 10, allowed: [10]}
                lsb: {type: integer, default: 10, allowed: [10]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vseie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            meie:
              type: dict
              schema:
                description:
                  type: string
                  default: Machine External Interrupt enable.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 11, allowed: [11]}
                lsb: {type: integer, default: 11, allowed: [11]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default: 
                    wlrl: [0:1]
              default: {implemented: true}
            sgeie:
              type: dict
              check_with: h_check
              schema:
                description: { type: string, default: HS-level External Interrupt enable.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 12, allowed: [12]}
                lsb: {type: integer, default: 12, allowed: [12]}
                implemented: {type: boolean}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - sgeie[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
    mscratch:
      type: dict
      schema:
        description:
          type: string
          default: The mscratch register is an MXLEN-bit read/write register dedicated
            for use by machine mode.
        address: {type: integer, default: 832, allowed: [832]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              - schema: {ro_variable: {type: boolean}}
              - schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - mscratch[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFFFFFFFFFF}}
              - schema: {ro_variable: {type: boolean}}
              - schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - mscratch[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: false}
    mepc:
      type: dict
      schema:
        description:
          type: string
          default: The mepc is a warl register that must be able to hold all valid physical
            and virtual addresses.
        address: {type: integer, default: 0x341, allowed: [0x341]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - mepc[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - mepc[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              type: boolean
              default: true
              check_with: rv64_check
          default: {accessible: false}
    mtval:
      type: dict
      schema:
        description:
          type: string
          default: The mtval is a warl register that holds the address of the instruction
            which caused the exception.
        address: {type: integer, default: 835, allowed: [835]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - mtval[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - mtval[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: false}
    mcause:
      type: dict
      schema:
        description:
          type: string
          default: The mcause register stores the information regarding the trap.
        address: {type: integer, default: 834, allowed: [834]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            interrupt:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether the trap was due to an interrupt.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 31, allowed: [31]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl: 
                    - 0x0:0x1
                  readonly: True
              default: {implemented: true}
            exception_code:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the exception code.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 30, allowed: [30]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl: 
                    - 0:15
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            interrupt:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether the trap was due to an interrupt.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 63, allowed: [63]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: true}
            exception_code:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the exception code.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 62, allowed: [62]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0:15
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
          default: {accessible: false}
    menvcfg:
      type: dict
      schema:
        description:
          type: string
          default: The menvcfg register stores the information regarding machine environment configuration.
        address: {type: integer, default: 0x30A, allowed: [0x30A]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            cbze:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Zero instruction is enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            cbcfe:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Clean and Flush instructions are enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            cbie:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Invalidate instruction is enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                       dependency_fields: []
                       legal:
                         - cbie[1:0] in [0x0, 0x1, 0x3]
                       wr_illegal:
                         - unchanged
              default: {implemented: true}
            sse:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Zicfiss extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 3, allowed: [3]}
                lsb: {type: integer, default: 3, allowed: [3]}
                implemented: {type: boolean, default: false, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            lpe:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Zicfilp extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: false, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            stce:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Sstc extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 63, allowed: [63]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            pbmte:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Svpbmt extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 62, allowed: [62]}
                lsb: {type: integer, default: 62, allowed: [62]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            adue:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables H/W updating of PTE A/D bits for single-stage address translation.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 61, allowed: [61]}
                lsb: {type: integer, default: 61, allowed: [61]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            cbze:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Zero instruction is enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            cbcfe:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Clean and Flush instructions are enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            cbie:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Invalidate instruction is enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                       dependency_fields: []
                       legal:
                         - cbie[1:0] in [0x0, 0x1, 0x3]
                       wr_illegal:
                         - unchanged
              default: {implemented: true}
            sse:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Zicfiss extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 3, allowed: [3]}
                lsb: {type: integer, default: 3, allowed: [3]}
                implemented: {type: boolean, default: false, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            lpe:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Zicfilp extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: false, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
          default: {accessible: false}
    menvcfgh:
      type: dict
      schema:
        description:
          type: string
          default: The menvcfgh register stores the information regarding machine environment configuration.
        address: {type: integer, default: 0x31A, allowed: [0x31A]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            stce:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Sstc extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 31, allowed: [31]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            pbmte:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Svpbmt extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 30, allowed: [30]}
                lsb: {type: integer, default: 30, allowed: [30]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            adue:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables H/W updating of PTE A/D bits for single-stage address translation.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 29, allowed: [29]}
                lsb: {type: integer, default: 29, allowed: [29]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          schema: {accessible: {type: boolean, default: False, allowed: [False]}}
          default: {accessible: False}
    pmpcfg0:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3A0, allowed: [0x3A0]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp0cfg: &pmp0
              type: dict
              schema:
                description: {type: string, default: pmp configuration bits}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: false}
                type: 
                  type: dict
                  oneof:
                    - schema: {ro_constant: {type: integer, max:  0xFF}}
                    - schema: { warl: *ref_warl }
                  default:
                    ro_constant: 0
              default: {implemented: True}
            pmp1cfg: &pmp1
              type: dict
              schema:
                description: {type: string, default: pmp configuration bits}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 15, allowed: [15]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: false}
                type: 
                  type: dict
                  oneof:
                    - schema: {ro_constant: {type: integer, max:  0xFF}}
                    - schema: { warl: *ref_warl }
                  default:
                    ro_constant: 0
              default: {implemented: True}
            pmp2cfg: &pmp2
              type: dict
              schema:
                description: {type: string, default: pmp configuration bits}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 23, allowed: [23]}
                lsb: {type: integer, default: 16, allowed: [16]}
                implemented: {type: boolean, default: false}
                type: 
                  type: dict
                  oneof:
                    - schema: {ro_constant: {type: integer, max:  0xFF}}
                    - schema: { warl: *ref_warl }
                  default:
                    ro_constant: 0
              default: {implemented: True}
            pmp3cfg: &pmp3
              type: dict
              schema:
                description: {type: string, default: pmp configuration bits}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 24, allowed: [24]}
                implemented: {type: boolean, default: false}
                type: 
                  type: dict
                  oneof:
                    - schema: {ro_constant: {type: integer, max:  0xFF}}
                    - schema: { warl: *ref_warl }
                  default:
                    ro_constant: 0
              default: {implemented: True}
        rv64:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv64_check}
            fields: {type: list, default: []}
            pmp0cfg: 
              <<: *pmp0
            pmp1cfg: 
              <<: *pmp1
            pmp2cfg: 
              <<: *pmp2
            pmp3cfg: 
              <<: *pmp3
            pmp4cfg: &pmp4
              type: dict
              schema:
                description: {type: string, default: pmp configuration bits}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 39, allowed: [39]}
                lsb: {type: integer, default: 32, allowed: [32]}
                implemented: {type: boolean, default: false}
                type: 
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  0xFF}}
                  - schema: { warl: *ref_warl }
                  default:
                    ro_constant: 0
              default: {implemented: True}
            pmp5cfg: &pmp5
              type: dict
              schema:
                description: {type: string, default: pmp configuration bits}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 47, allowed: [47]}
                lsb: {type: integer, default: 40, allowed: [40]}
                implemented: {type: boolean, default: false}
                type: 
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  0xFF}}
                  - schema: { warl: *ref_warl }
                  default:
                    ro_constant: 0
              default: {implemented: True}
            pmp6cfg: &pmp6
              type: dict
              schema:
                description: {type: string, default: pmp configuration bits}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 55, allowed: [55]}
                lsb: {type: integer, default: 48, allowed: [48]}
                implemented: {type: boolean, default: false}
                type: 
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  0xFF}}
                  - schema: { warl: *ref_warl }
                  default:
                    ro_constant: 0
              default: {implemented: True}
            pmp7cfg: &pmp7
              type: dict
              schema:
                description: {type: string, default: pmp configuration bits}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 56, allowed: [56]}
                implemented: {type: boolean, default: false}
                type: 
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  0xFF}}
                  - schema: { warl: *ref_warl }
                  default:
                    ro_constant: 0
              default: {implemented: True}
                  
    pmpcfg1:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3A1, allowed: [0x3A1]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp4cfg: 
              <<: *pmp0
            pmp5cfg: 
              <<: *pmp1
            pmp6cfg: 
              <<: *pmp2
            pmp7cfg: 
              <<: *pmp3
        rv64:
          type: dict
          schema:
            accessible:
              type: boolean
              default: False
          default: {accessible: False}
    pmpcfg2:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3A2, allowed: [0x3A2]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp8cfg: 
              <<: *pmp0
            pmp9cfg: 
              <<: *pmp1
            pmp10cfg: 
              <<: *pmp2
            pmp11cfg: 
              <<: *pmp3
        rv64:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv64_check}
            fields: {type: list, default: []}
            pmp8cfg: 
              <<: *pmp0
            pmp9cfg: 
              <<: *pmp1
            pmp10cfg: 
              <<: *pmp2
            pmp11cfg: 
              <<: *pmp3
            pmp12cfg: 
              <<: *pmp4
            pmp13cfg: 
              <<: *pmp5
            pmp14cfg: 
              <<: *pmp6
            pmp15cfg: 
              <<: *pmp7
    pmpcfg3:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3A3, allowed: [0x3A3]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp12cfg: 
              <<: *pmp0
            pmp13cfg: 
              <<: *pmp1
            pmp14cfg: 
              <<: *pmp2
            pmp15cfg: 
              <<: *pmp3
        rv64:
          type: dict
          schema:
            accessible:
              default: False
          default: {accessible: False}
    pmpcfg4:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3A4, allowed: [0x3A4]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp16cfg: 
              <<: *pmp0
            pmp17cfg: 
              <<: *pmp1
            pmp18cfg: 
              <<: *pmp2
            pmp19cfg: 
              <<: *pmp3
        rv64:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv64_check}
            fields: {type: list, default: []}
            pmp16cfg: 
              <<: *pmp0
            pmp17cfg: 
              <<: *pmp1
            pmp18cfg: 
              <<: *pmp2
            pmp19cfg: 
              <<: *pmp3
            pmp20cfg: 
              <<: *pmp4
            pmp21cfg: 
              <<: *pmp5
            pmp22cfg: 
              <<: *pmp6
            pmp23cfg: 
              <<: *pmp7
    pmpcfg5:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3A5, allowed: [0x3A5]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp20cfg: 
              <<: *pmp0
            pmp21cfg: 
              <<: *pmp1
            pmp22cfg: 
              <<: *pmp2
            pmp23cfg: 
              <<: *pmp3
        rv64:
          type: dict
          schema:
            accessible:
              default: False
          default: {accessible: False}
    pmpcfg6:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3A6, allowed: [0x3A6]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp24cfg: 
              <<: *pmp0
            pmp25cfg: 
              <<: *pmp1
            pmp26cfg: 
              <<: *pmp2
            pmp27cfg: 
              <<: *pmp3
        rv64:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv64_check}
            fields: {type: list, default: []}
            pmp24cfg: 
              <<: *pmp0
            pmp25cfg: 
              <<: *pmp1
            pmp26cfg: 
              <<: *pmp2
            pmp27cfg: 
              <<: *pmp3
            pmp28cfg: 
              <<: *pmp4
            pmp29cfg: 
              <<: *pmp5
            pmp30cfg: 
              <<: *pmp6
            pmp31cfg: 
              <<: *pmp7
    pmpcfg7:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3A7, allowed: [0x3A7]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp28cfg: 
              <<: *pmp0
            pmp29cfg: 
              <<: *pmp1
            pmp30cfg: 
              <<: *pmp2
            pmp31cfg: 
              <<: *pmp3
        rv64:
          type: dict
          schema:
            accessible:
              default: False
          default: {accessible: False}
    pmpcfg8:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3A8, allowed: [0x3A8]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp32cfg: 
              <<: *pmp0
            pmp33cfg: 
              <<: *pmp1
            pmp34cfg: 
              <<: *pmp2
            pmp35cfg: 
              <<: *pmp3
        rv64:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv64_check}
            fields: {type: list, default: []}
            pmp32cfg: 
              <<: *pmp0
            pmp33cfg: 
              <<: *pmp1
            pmp34cfg: 
              <<: *pmp2
            pmp35cfg: 
              <<: *pmp3
            pmp36cfg: 
              <<: *pmp4
            pmp37cfg: 
              <<: *pmp5
            pmp38cfg: 
              <<: *pmp6
            pmp39cfg: 
              <<: *pmp7
    pmpcfg9:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3A9, allowed: [0x3A9]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp36cfg: 
              <<: *pmp0
            pmp37cfg: 
              <<: *pmp1
            pmp38cfg: 
              <<: *pmp2
            pmp39cfg: 
              <<: *pmp3
        rv64:
          type: dict
          schema:
            accessible:
              default: False
          default: {accessible: False}
    pmpcfg10:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3AA, allowed: [0x3AA]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp40cfg: 
              <<: *pmp0
            pmp41cfg: 
              <<: *pmp1
            pmp42cfg: 
              <<: *pmp2
            pmp43cfg: 
              <<: *pmp3
        rv64:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv64_check}
            fields: {type: list, default: []}
            pmp40cfg: 
              <<: *pmp0
            pmp41cfg: 
              <<: *pmp1
            pmp42cfg: 
              <<: *pmp2
            pmp43cfg: 
              <<: *pmp3
            pmp44cfg: 
              <<: *pmp4
            pmp45cfg: 
              <<: *pmp5
            pmp46cfg: 
              <<: *pmp6
            pmp47cfg: 
              <<: *pmp7
    pmpcfg11:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3AB, allowed: [0x3AB]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp44cfg: 
              <<: *pmp0
            pmp45cfg: 
              <<: *pmp1
            pmp46cfg: 
              <<: *pmp2
            pmp47cfg: 
              <<: *pmp3
        rv64:
          type: dict
          schema:
            accessible:
              default: False
          default: {accessible: False}
    pmpcfg12:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3AC, allowed: [0x3AC]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp48cfg: 
              <<: *pmp0
            pmp49cfg: 
              <<: *pmp1
            pmp50cfg: 
              <<: *pmp2
            pmp51cfg: 
              <<: *pmp3
        rv64:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv64_check}
            fields: {type: list, default: []}
            pmp48cfg: 
              <<: *pmp0
            pmp49cfg: 
              <<: *pmp1
            pmp50cfg: 
              <<: *pmp2
            pmp51cfg: 
              <<: *pmp3
            pmp52cfg: 
              <<: *pmp4
            pmp53cfg: 
              <<: *pmp5
            pmp54cfg: 
              <<: *pmp6
            pmp55cfg: 
              <<: *pmp7
    pmpcfg13:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3AD, allowed: [0x3AD]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp52cfg: 
              <<: *pmp0
            pmp53cfg: 
              <<: *pmp1
            pmp54cfg: 
              <<: *pmp2
            pmp55cfg: 
              <<: *pmp3
        rv64:
          type: dict
          schema:
            accessible:
              default: False
          default: {accessible: False}
    pmpcfg14:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3AE, allowed: [0x3AE]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp56cfg: 
              <<: *pmp0
            pmp57cfg: 
              <<: *pmp1
            pmp58cfg: 
              <<: *pmp2
            pmp59cfg: 
              <<: *pmp3
        rv64:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv64_check}
            fields: {type: list, default: []}
            pmp56cfg: 
              <<: *pmp0
            pmp57cfg: 
              <<: *pmp1
            pmp58cfg: 
              <<: *pmp2
            pmp59cfg: 
              <<: *pmp3
            pmp60cfg: 
              <<: *pmp4
            pmp61cfg: 
              <<: *pmp5
            pmp62cfg: 
              <<: *pmp6
            pmp63cfg: 
              <<: *pmp7
    pmpcfg15:
      type: dict
      schema:
        description: {type: string, default: PMP configuration register}
        address: {type: integer, default: 0x3AF, allowed: [0x3AF]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          default: {accessible: False}
          schema:
            accessible: {type: boolean, default: false, check_with: rv32_check}
            fields: {type: list, default: []}
            pmp60cfg: 
              <<: *pmp0
            pmp61cfg: 
              <<: *pmp1
            pmp62cfg: 
              <<: *pmp2
            pmp63cfg: 
              <<: *pmp3
        rv64:
          type: dict
          schema:
            accessible:
              default: False
          default: {accessible: False}
    pmpaddr0:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3B0, allowed: [0x3B0]}
    pmpaddr1:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3B1, allowed: [0x3B1]}
    pmpaddr2:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3B2, allowed: [0x3B2]}
    pmpaddr3:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3B3, allowed: [0x3B3]}
    pmpaddr4:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3B4, allowed: [0x3B4]}
    pmpaddr5:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3B5, allowed: [0x3B5]}
    pmpaddr6:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3B6, allowed: [0x3B6]}
    pmpaddr7:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3B7, allowed: [0x3B7]}
    pmpaddr8:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3B8, allowed: [0x3B8]}
    pmpaddr9:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3B9, allowed: [0x3B9]}
    pmpaddr10:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3BA, allowed: [0x3BA]}
    pmpaddr11:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3BB, allowed: [0x3BB]}
    pmpaddr12:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3BC, allowed: [0x3BC]}
    pmpaddr13:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3BD, allowed: [0x3BD]}
    pmpaddr14:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3BE, allowed: [0x3BE]}
    pmpaddr15:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3BF, allowed: [0x3BF]}
    pmpaddr16:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3C0, allowed: [0x3C0]}
    pmpaddr17:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3C1, allowed: [0x3C1]}
    pmpaddr18:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3C2, allowed: [0x3C2]}
    pmpaddr19:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3C3, allowed: [0x3C3]}
    pmpaddr20:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3C4, allowed: [0x3C4]}
    pmpaddr21:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3C5, allowed: [0x3C5]}
    pmpaddr22:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3C6, allowed: [0x3C6]}
    pmpaddr23:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3C7, allowed: [0x3C7]}
    pmpaddr24:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3C8, allowed: [0x3C8]}
    pmpaddr25:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3C9, allowed: [0x3C9]}
    pmpaddr26:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3CA, allowed: [0x3CA]}
    pmpaddr27:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3CB, allowed: [0x3CB]}
    pmpaddr28:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3CC, allowed: [0x3CC]}
    pmpaddr29:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3CD, allowed: [0x3CD]}
    pmpaddr30:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3CE, allowed: [0x3CE]}
    pmpaddr31:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3CF, allowed: [0x3CF]}
    pmpaddr32:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3D0, allowed: [0x3D0]}
    pmpaddr33:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3D1, allowed: [0x3D1]}
    pmpaddr34:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3D2, allowed: [0x3D2]}
    pmpaddr35:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3D3, allowed: [0x3D3]}
    pmpaddr36:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3D4, allowed: [0x3D4]}
    pmpaddr37:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3D5, allowed: [0x3D5]}
    pmpaddr38:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3D6, allowed: [0x3D6]}
    pmpaddr39:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3D7, allowed: [0x3D7]}
    pmpaddr40:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3D8, allowed: [0x3D8]}
    pmpaddr41:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3D9, allowed: [0x3D9]}
    pmpaddr42:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3DA, allowed: [0x3DA]}
    pmpaddr43:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3DB, allowed: [0x3DB]}
    pmpaddr44:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3DC, allowed: [0x3DC]}
    pmpaddr45:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3DD, allowed: [0x3DD]}
    pmpaddr46:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3DE, allowed: [0x3DE]}
    pmpaddr47:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3DF, allowed: [0x3DF]}
    pmpaddr48:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3E0, allowed: [0x3E0]}
    pmpaddr49:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3E1, allowed: [0x3E1]}
    pmpaddr50:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3E2, allowed: [0x3E2]}
    pmpaddr51:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3E3, allowed: [0x3E3]}
    pmpaddr52:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3E4, allowed: [0x3E4]}
    pmpaddr53:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3E5, allowed: [0x3E5]}
    pmpaddr54:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3E6, allowed: [0x3E6]}
    pmpaddr55:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3E7, allowed: [0x3E7]}
    pmpaddr56:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3E8, allowed: [0x3E8]}
    pmpaddr57:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3E9, allowed: [0x3E9]}
    pmpaddr58:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3EA, allowed: [0x3EA]}
    pmpaddr59:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3EB, allowed: [0x3EB]}
    pmpaddr60:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3EC, allowed: [0x3EC]}
    pmpaddr61:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3ED, allowed: [0x3ED]}
    pmpaddr62:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3EE, allowed: [0x3EE]}
    pmpaddr63:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: Physical memory protection address register
        address: {type: integer, default: 0x3EF, allowed: [0x3EF]}
    mcounteren:
      type: dict
      schema:
        description:
          type: string
          default: The mcounteren is a 32-bit register that controls the availability
            of the hardware performance-monitoring counters to the next-lowest privileged
            mode.
        address: {type: integer, default: 0x306, allowed: [0x306]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, check_with: max_length32, default: 0}
        rv32:
          type: dict
          check_with: u_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              - schema: { warl: *ref_warl }
              default: 
                 ro_constant: 0
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: u_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              - schema: { warl: *ref_warl }
              default: 
                ro_constant: 0
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: false}
    mcountinhibit:
      type: dict
      schema:
        description:
          type: string
          default: The mcountinhibit is a 32-bit WARL register that controls which of
            the hardware performance-monitoring counters increment.
        address: {type: integer, default: 0x320, allowed: [0x320]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer, default: 0, check_with: max_length32}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              - schema: { warl: *ref_warl }
              default: {ro_constant: 0}
            accessible: { type: boolean, default: true, check_with: rv32_check}
          default: {accessible: false}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              - schema: { warl: *ref_warl }
              default:
                ro_constant: 0
            accessible: { default: true, check_with: rv64_check}
          default: {accessible: false}
    mcycle:
      type: dict
      schema:
        description:
          type: string
          default: Counts the number of clock cycles executed from an arbitrary point in time.
        address: {type: integer, default: 0xB00, allowed: [0xB00]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              - schema: { warl: *ref_warl }
              default:
                warl:
                    dependency_fields: []
                    legal:
                      - mcycle[31:0] in [0x00000000:0xFFFFFFFF]
                    wr_illegal:
                      - unchanged
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max: 0xFFFFFFFFFFFFFFFF}}
              - schema: { warl: *ref_warl }
              default:
                warl:
                    dependency_fields: []
                    legal:
                      - mcycle[63:0] in [0x0000000000000000:0xFFFFFFFFFFFFFFFF]
                    wr_illegal:
                      - Unchanged
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: False}
    mcycleh:
      type: dict
      schema:
        description:
          type: string
          default: upper 32 bits of mcycle 
        address: {type: integer, default: 0xB80, allowed: [0xB80]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          default: 0
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF }}
              - schema: { warl: *ref_warl }
              default:
                warl:
                    dependency_fields: []
                    legal:
                      - mcycleh[31:0] in [0x00000000:0xFFFFFFFF]
                    wr_illegal:
                      - unchanged
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible:
              default: False
          default: {accessible: False}
    minstret: 
      type: dict
      schema:
        description:
          type: string
          default: Counts the number of instructions completed from an arbitrary point in time.
        address: {type: integer, default: 0xB02, allowed: [0xB02]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              - schema: { warl: *ref_warl }
              default:
                warl:
                    dependency_fields: []
                    legal:
                      - minstret[31:0] in [0x00000000:0xFFFFFFFF]
                    wr_illegal:
                      - unchanged
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max: 0xFFFFFFFFFFFFFFFF}}
              - schema: { warl: *ref_warl }
              default:
                warl:
                    dependency_fields: []
                    legal:
                      - minstret[63:0] in [0x0000000000000000:0xFFFFFFFFFFFFFFFF]
                    wr_illegal:
                      - Unchanged
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: False}
    minstreth: 
      type: dict
      schema:
        description:
          type: string
          default: Upper 32 bits of minstret.
        address: {type: integer, default: 0xB82, allowed: [0xB82]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          default: 0
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF }}
              - schema: { warl: *ref_warl }
              default:
                warl:
                    dependency_fields: []
                    legal:
                      - minstreth[31:0] in [0x00000000:0xFFFFFFFF]
                    wr_illegal:
                      - unchanged
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible:
              default: False
          default: {accessible: False}
    mhpmevent3:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent3 is a MXLEN-bit event register which controls mhpmcounter3.
        address: {type: integer, default: 0x323, allowed: [0x323]}
    mhpmcounter3:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter3 is a 64-bit counter. Returns lower 32 bits in RV32I mode.
        address: {type: integer, default: 0xB03, allowed: [0xB03]}
    mhpmcounter3h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter3h returns the upper half word in RV32I systems.
        address: {type: integer, default: 0xB83, allowed: [0xB83]}
    mhpmevent4:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent4 is a MXLEN-bit event register which controls mhpmcounter4.
        address: {type: integer, default: 0x324, allowed: [0x324]}
    mhpmcounter4:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter4 is a 64-bit counter. Returns lower 42 bits in RV42I mode.
        address: {type: integer, default: 0xB04, allowed: [0xB04]}
    mhpmcounter4h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter4h returns the upper half word in RV42I systems.
        address: {type: integer, default: 0xB84, allowed: [0xB84]}
    mhpmevent5:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent5 is a MXLEN-bit event register which controls mhpmcounter5.
        address: {type: integer, default: 0x325, allowed: [0x325]}
    mhpmcounter5:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter5 is a 64-bit counter. Returns lower 52 bits in RV52I mode.
        address: {type: integer, default: 0xB05, allowed: [0xB05]}
    mhpmcounter5h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter5h returns the upper half word in RV52I systems.
        address: {type: integer, default: 0xB85, allowed: [0xB85]}
    mhpmevent6:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent6 is a MXLEN-bit event register which controls mhpmcounter6.
        address: {type: integer, default: 0x326, allowed: [0x326]}
    mhpmcounter6:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter6 is a 64-bit counter. Returns lower 62 bits in RV62I
            mode.
        address: {type: integer, default: 0xB06, allowed: [0xB06]}
    mhpmcounter6h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter6h returns the upper half word in RV62I systems.
        address: {type: integer, default: 0xB86, allowed: [0xB86]}
    mhpmevent7:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent7 is a MXLEN-bit event register which controls mhpmcounter7.
        address: {type: integer, default: 0x327, allowed: [0x327]}
    mhpmcounter7:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter7 is a 64-bit counter. Returns lower 72 bits in RV72I mode.
        address: {type: integer, default: 0xB07, allowed: [0xB07]}
    mhpmcounter7h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter7h returns the upper half word in RV72I systems.
        address: {type: integer, default: 0xB87, allowed: [0xB87]}
    mhpmevent8:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent8 is a MXLEN-bit event register which controls mhpmcounter8.
        address: {type: integer, default: 0x328, allowed: [0x328]}
    mhpmcounter8:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter8 is a 64-bit counter. Returns lower 82 bits in RV82I mode.
        address: {type: integer, default: 0xB08, allowed: [0xB08]}
    mhpmcounter8h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter8h returns the upper half word in RV82I systems.
        address: {type: integer, default: 0xB88, allowed: [0xB88]}
    mhpmevent9:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent9 is a MXLEN-bit event register which controls mhpmcounter9.
        address: {type: integer, default: 0x329, allowed: [0x329]}
    mhpmcounter9:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter9 is a 64-bit counter. Returns lower 32 bits in RV32I mode.
        address: {type: integer, default: 0xB09, allowed: [0xB09]}
    mhpmcounter9h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter9h returns the upper half word in RV32I systems.
        address: {type: integer, default: 0xB89, allowed: [0xB89]}
    mhpmevent10:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent10 is a MXLEN-bit event register which controls mhpmcounter10.
        address: {type: integer, default: 0x32a, allowed: [0x32a]}
    mhpmcounter10:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter10 is a 64-bit counter. Returns lower 102 bits in RV102I mode.
        address: {type: integer, default: 0xB0A, allowed: [0xB0A]}
    mhpmcounter10h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter10h returns the upper half word in RV102I systems.
        address: {type: integer, default: 0xB8A, allowed: [0xB8A]}
    mhpmevent11:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent11 is a MXLEN-bit event register which controls mhpmcounter11.
        address: {type: integer, default: 0x32b, allowed: [0x32b]}
    mhpmcounter11:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter11 is a 64-bit counter. Returns lower 112 bits in RV112I mode.
        address: {type: integer, default: 0xB0B, allowed: [0xB0B]}
    mhpmcounter11h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter11h returns the upper half word in RV112I systems.
        address: {type: integer, default: 0xB8B, allowed: [0xB8B]}
    mhpmevent12:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent12 is a MXLEN-bit event register which controls mhpmcounter12.
        address: {type: integer, default: 0x32c, allowed: [0x32c]}
    mhpmcounter12:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter12 is a 64-bit counter. Returns lower 122 bits in RV122I mode.
        address: {type: integer, default: 0xB0C, allowed: [0xB0C]}
    mhpmcounter12h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter12h returns the upper half word in RV122I systems.
        address: {type: integer, default: 0xB8C, allowed: [0xB8C]}
    mhpmevent13:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent13 is a MXLEN-bit event register which controls mhpmcounter13.
        address: {type: integer, default: 0x32d, allowed: [0x32d]}
    mhpmcounter13:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter13 is a 64-bit counter. Returns lower 132 bits in RV132I mode.
        address: {type: integer, default: 0xB0D, allowed: [0xB0D]}
    mhpmcounter13h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter13h returns the upper half word in RV132I systems.
        address: {type: integer, default: 0xB8D, allowed: [0xB8D]}
    mhpmevent14:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent14 is a MXLEN-bit event register which controls mhpmcounter14.
        address: {type: integer, default: 0x32e, allowed: [0x32e]}
    mhpmcounter14:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter14 is a 64-bit counter. Returns lower 142 bits in RV142I mode.
        address: {type: integer, default: 0xB0E, allowed: [0xB0E]}
    mhpmcounter14h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter14h returns the upper half word in RV142I systems.
        address: {type: integer, default: 0xB8E, allowed: [0xB8E]}
    mhpmevent15:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent15 is a MXLEN-bit event register which controls mhpmcounter15.
        address: {type: integer, default: 0x32f, allowed: [0x32f]}
    mhpmcounter15:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter15 is a 64-bit counter. Returns lower 152 bits in RV152I mode.
        address: {type: integer, default: 0xB0F, allowed: [0xB0F]}
    mhpmcounter15h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter15h returns the upper half word in RV152I systems.
        address: {type: integer, default: 0xB8F, allowed: [0xB8F]}
    mhpmevent16:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent16 is a MXLEN-bit event register which controls mhpmcounter16.
        address: {type: integer, default: 0x330, allowed: [0x330]}
    mhpmcounter16:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter16 is a 64-bit counter. Returns lower 162 bits in RV162I mode.
        address: {type: integer, default: 0xB10, allowed: [0xB10]}
    mhpmcounter16h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter16h returns the upper half word in RV162I systems.
        address: {type: integer, default: 0xB90, allowed: [0xB90]}
    mhpmevent17:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent17 is a MXLEN-bit event register which controls mhpmcounter17.
        address: {type: integer, default: 0x331, allowed: [0x331]}
    mhpmcounter17:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter17 is a 64-bit counter. Returns lower 172 bits in RV172I mode.
        address: {type: integer, default: 0xB11, allowed: [0xB11]}
    mhpmcounter17h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter17h returns the upper half word in RV172I systems.
        address: {type: integer, default: 0xB91, allowed: [0xB91]}
    mhpmevent18:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent18 is a MXLEN-bit event register which controls mhpmcounter18.
        address: {type: integer, default: 0x332, allowed: [0x332]}
    mhpmcounter18:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter18 is a 64-bit counter. Returns lower 182 bits in RV182I mode.
        address: {type: integer, default: 0xB12, allowed: [0xB12]}
    mhpmcounter18h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter18h returns the upper half word in RV182I systems.
        address: {type: integer, default: 0xB92, allowed: [0xB92]}
    mhpmevent19:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent19 is a MXLEN-bit event register which controls mhpmcounter19.
        address: {type: integer, default: 0x333, allowed: [0x333]}
    mhpmcounter19:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter19 is a 64-bit counter. Returns lower 32 bits in RV32I mode.
        address: {type: integer, default: 0xB13, allowed: [0xB13]}
    mhpmcounter19h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter19h returns the upper half word in RV32I systems.
        address: {type: integer, default: 0xB93, allowed: [0xB93]}
    mhpmevent20:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent20 is a MXLEN-bit event register which controls mhpmcounter20.
        address: {type: integer, default: 0x334, allowed: [0x334]}
    mhpmcounter20:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter20 is a 64-bit counter. Returns lower 202 bits in RV202I mode.
        address: {type: integer, default: 0xB14, allowed: [0xB14]}
    mhpmcounter20h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter20h returns the upper half word in RV202I systems.
        address: {type: integer, default: 0xB94, allowed: [0xB94]}
    mhpmevent21:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent21 is a MXLEN-bit event register which controls mhpmcounter21.
        address: {type: integer, default: 0x335, allowed: [0x335]}
    mhpmcounter21:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter21 is a 64-bit counter. Returns lower 212 bits in RV212I mode.
        address: {type: integer, default: 0xB15, allowed: [0xB15]}
    mhpmcounter21h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter21h returns the upper half word in RV212I systems.
        address: {type: integer, default: 0xB95, allowed: [0xB95]}
    mhpmevent22:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent22 is a MXLEN-bit event register which controls mhpmcounter22.
        address: {type: integer, default: 0x336, allowed: [0x336]}
    mhpmcounter22:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter22 is a 64-bit counter. Returns lower 222 bits in RV222I mode.
        address: {type: integer, default: 0xB16, allowed: [0xB16]}
    mhpmcounter22h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter22h returns the upper half word in RV222I systems.
        address: {type: integer, default: 0xB96, allowed: [0xB96]}
    mhpmevent23:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent23 is a MXLEN-bit event register which controls mhpmcounter23.
        address: {type: integer, default: 0x337, allowed: [0x337]}
    mhpmcounter23:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter23 is a 64-bit counter. Returns lower 232 bits in RV232I mode.
        address: {type: integer, default: 0xB17, allowed: [0xB17]}
    mhpmcounter23h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter23h returns the upper half word in RV232I systems.
        address: {type: integer, default: 0xB97, allowed: [0xB97]}
    mhpmevent24:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent24 is a MXLEN-bit event register which controls mhpmcounter24.
        address: {type: integer, default: 0x338, allowed: [0x338]}
    mhpmcounter24:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter24 is a 64-bit counter. Returns lower 242 bits in RV242I mode.
        address: {type: integer, default: 0xB18, allowed: [0xB18]}
    mhpmcounter24h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter24h returns the upper half word in RV242I systems.
        address: {type: integer, default: 0xB98, allowed: [0xB98]}
    mhpmevent25:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent25 is a MXLEN-bit event register which controls mhpmcounter25.
        address: {type: integer, default: 0x339, allowed: [0x339]}
    mhpmcounter25:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter25 is a 64-bit counter. Returns lower 252 bits in RV252I mode.
        address: {type: integer, default: 0xB19, allowed: [0xB19]}
    mhpmcounter25h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter25h returns the upper half word in RV252I systems.
        address: {type: integer, default: 0xB99, allowed: [0xB99]}
    mhpmevent26:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent26 is a MXLEN-bit event register which controls mhpmcounter26.
        address: {type: integer, default: 0x33a, allowed: [0x33a]}
    mhpmcounter26:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter26 is a 64-bit counter. Returns lower 262 bits in RV262I mode.
        address: {type: integer, default: 0xB1A, allowed: [0xB1A]}
    mhpmcounter26h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter26h returns the upper half word in RV262I systems.
        address: {type: integer, default: 0xB9A, allowed: [0xB9A]}
    mhpmevent27:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent27 is a MXLEN-bit event register which controls mhpmcounter27.
        address: {type: integer, default: 0x33b, allowed: [0x33b]}
    mhpmcounter27:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter27 is a 64-bit counter. Returns lower 272 bits in RV272I mode.
        address: {type: integer, default: 0xB1B, allowed: [0xB1B]}
    mhpmcounter27h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter27h returns the upper half word in RV272I systems.
        address: {type: integer, default: 0xB9B, allowed: [0xB9B]}
    mhpmevent28:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent28 is a MXLEN-bit event register which controls mhpmcounter28.
        address: {type: integer, default: 0x33c, allowed: [0x33c]}
    mhpmcounter28:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter28 is a 64-bit counter. Returns lower 282 bits in RV282I mode.
        address: {type: integer, default: 0xB1C, allowed: [0xB1C]}
    mhpmcounter28h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter28h returns the upper half word in RV282I systems.
        address: {type: integer, default: 0xB9C, allowed: [0xB9C]}
    mhpmevent29:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent29 is a MXLEN-bit event register which controls mhpmcounter29.
        address: {type: integer, default: 0x33d, allowed: [0x33d]}
    mhpmcounter29:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter29 is a 64-bit counter. Returns lower 32 bits in RV32I mode.
        address: {type: integer, default: 0xB1D, allowed: [0xB1D]}
    mhpmcounter29h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter29h returns the upper half word in RV32I systems.
        address: {type: integer, default: 0xB9D, allowed: [0xB9D]}
    mhpmevent30:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent30 is a MXLEN-bit event register which controls mhpmcounter30.
        address: {type: integer, default: 0x33e, allowed: [0x33e]}
    mhpmcounter30:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter30 is a 64-bit counter. Returns lower 302 bits in RV302I mode.
        address: {type: integer, default: 0xB1E, allowed: [0xB1E]}
    mhpmcounter30h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter30h returns the upper half word in RV302I systems.
        address: {type: integer, default: 0xB9E, allowed: [0xB9E]}
    mhpmevent31:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmevent31 is a MXLEN-bit event register which controls mhpmcounter31.
        address: {type: integer, default: 0x33f, allowed: [0x33f]}
    mhpmcounter31:
      type: dict
      schema:
        <<: *gen_flatschema_machine
        description:
          type: string
          default: The mhpmcounter31 is a 64-bit counter. Returns lower 312 bits in RV312I mode.
        address: {type: integer, default: 0xB1F, allowed: [0xB1F]}
    mhpmcounter31h:
      type: dict
      schema:
        <<: *gen_flatschema_machine32
        description:
          type: string
          default: The mhpmcounter31h returns the upper half word in RV312I systems.
        address: {type: integer, default: 0xB9F, allowed: [0xB9F]}
    sedeleg:
      type: dict
      schema:
        description:
          type: string
          default: sedeleg
        address: {type: integer, default: 258, allowed: [258]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          check_with:
          - max_length
          - sedeleg_reset
          default: 0
        rv32:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              - schema: {ro_variable: {type: boolean}}
              - schema: { warl: *ref_warl }
              default: {ro_constant : 0}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          default: {accessible: False}
        rv64:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 2, allowed: [2]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  4611686018427387903}}
              - schema: {ro_variable: {type: boolean}}
              - schema: { warl: *ref_warl }
              default: {ro_constant : 0}
            accessible: { type: boolean, default: true, check_with: [rv64_check]}
          default: {accessible: False}
      check_with: ndeleg_checks
    sideleg:
      type: dict
      schema:
        description:
          type: string
          default: sideleg
        priv_mode: {type: string, default: S, allowed: [S]}
        address: {type: integer, default: 259, allowed: [259]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  4611686018427387903}}
              - schema: {ro_variable: {type: boolean}}
              - schema: { warl: *ref_warl }
              default: {ro_constant : 0}
            accessible: { type: boolean, default: true, check_with: [rv32_check]} 
          default: {accessible: False}
        rv64:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 2, allowed: [2]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  4611686018427387903}}
              - schema: {ro_variable: {type: boolean}}
              - schema: { warl: *ref_warl }
              default: {ro_constant : 0}
            accessible:
              type: boolean
              default: true
              check_with: [rv64_check]
          default: {accessible: False}
      check_with: ndeleg_checks
    fflags:
      type: dict
      schema:
        description:
          type: string
          default: 32-bit register to hold floating point accrued exceptions.
        address: {type: integer, default: 001, allowed: [001]}
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val:
          type: integer
          default: 0
          check_with:
          - max_length
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: fcsr.fflags, nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 4, allowed: [4]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [rv32_check,cannot_be_false_rv32f]}
          check_with: f_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: fcsr.fflags, nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 4, allowed: [4]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {default: true, check_with: [rv64_check,cannot_be_false_rv64f]}
          check_with: f_check
          default: {accessible: False}
    frm:
      type: dict
      schema:
        description:
          type: string
          default: 32-bit register to hold Floating-Point Dynamic Rounding Mode.
        address: {type: integer, default: 002, allowed: [002]}
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val:
          type: integer
          default: 0
          check_with:
          - max_length
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: fcsr.frm, nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 2, allowed: [2]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [rv32_check,cannot_be_false_rv32f]}
          check_with: f_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: fcsr.frm, nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 2, allowed: [2]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {default: true, check_with: [rv64_check,cannot_be_false_rv64f]}
          check_with: f_check
          default: {accessible: False}
    fcsr:
      type: dict
      schema:
        description:
          type: string
          default: 32-bit register to hold Floating-Point Control and Status Register.
        address: {type: integer, default: 003, allowed: [003]}
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            frm:
              type: dict
              schema:
                description: {type: string,  default: Stores Floating-Point Dynamic Rounding Mode.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: false}
                type:
                  type: dict
                  oneof:
                    - schema: {ro_constant: {type: integer, max: 0x7}}
                    - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - frm[2:0] in [0x0:0x7]
                      wr_illegal:
                        - Unchanged
              default: {implemented: true}
            fflags:
              type: dict
              schema:
                description: {type: string,  default: Stores floating point accrued exceptions.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: false}
                type:
                  type: dict
                  oneof:
                    - schema: {ro_constant: {type: integer, max: 0x1F}}
                    - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - fflags[4:0] in [0x0:0x1F]
                      wr_illegal:
                        - Unchanged
              default: {implemented: true}
            accessible:
              type: boolean
              default: true
              check_with: [rv32_check, cannot_be_false_rv32f]
          check_with: f_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            frm:
              type: dict
              schema:
                description: {type: string,  default: Stores Floating-Point Dynamic Rounding Mode.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                    - schema: {ro_constant: {type: integer, max: 0x7}}
                    - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - frm[2:0] in [0x0:0x7]
                      wr_illegal:
                        - Unchanged
              default: {implemented: true}
            fflags:
              type: dict
              schema:
                description: {type: string,  default: Stores floating point accrued exceptions.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                    - schema: {ro_constant: {type: integer, max: 0x1F}}
                    - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - fflags[4:0] in [0x0:0x1F]
                      wr_illegal:
                        - Unchanged
              default: {implemented: true}
            accessible:
              default: true
              check_with: [rv64_check,cannot_be_false_rv64f]
          check_with: f_check
          default: {accessible: False}
    ssp:
      type: dict
      schema:
        description: {type: string, default: Shadow stack pointer.}
        priv_mode: {type: string, default: U, allowed: [U]}
        address: {type: integer, default: 0x011, allowed: [0x011]}
        reset-val: {type: integer, default: 0,  check_with: [max_length]}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [rv32_check, zicfiss_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {default: true, check_with: [rv64_check, zicfiss_check]}
          check_with: u_check
          default: {accessible: False}
    cycle:
      type: dict
      schema:
        description: {type: string, default: Captures the number of cycles executed from an arbitrary point in time.}
        priv_mode: {type: string, default: U, allowed: [U]}
        address: {type: integer, default: 0xC00, allowed: [0xC00]}
        reset-val: {type: integer, default: 0,  check_with: [max_length]}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mcycle, nullable: True}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [rv32_check]} 
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mcycle, nullable: True}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {default: true, check_with: [rv64_check]} 
          check_with: u_check
          default: {accessible: False}    
    cycleh:
      type: dict
      schema:
        description:
          type: string
          default: Upper 32-bits of the mcycle counter; only for rv32.
        address: {type: integer, default: 0xC80, allowed: [0xC80]}
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0, check_with: [max_length]}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mcycleh, nullable: True}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean,  default: true,  check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
            type: dict
            schema: {accessible: {default: False}}
            default: {accessible: False}    
    time:
      type: dict
      schema:
        description: {type: string, default: Timer for RDTIME instruction and RTC in the processor.}
        priv_mode: {type: string, default: U, allowed: [U]}
        address: {type: integer, default: 0xC01, allowed: [0xC01]}
        reset-val: {type: integer, default: 0,  check_with: [max_length]}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: {ro_variable: {type: boolean}}
              default: {ro_variable: true}
            accessible: {type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict              
              schema: {ro_variable: {type: boolean}}
              default: {ro_variable: true}
            accessible: {default: true, check_with: [rv64_check]}
          check_with: u_check
          default: {accessible: False}    
    timeh:
      type: dict
      schema:
        description:
          type: string
          default: Upper 32-bits of the Timer for RDTIME instruction and RTC in the processor; only for rv32.
        address: {type: integer, default: 0xC81, allowed: [0xC81]}
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0, check_with: [max_length]}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: {ro_variable: {type: boolean}}
              default: { ro_variable: true}
            accessible: {type: boolean,  default: true,  check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
            type: dict
            schema: {accessible: {default: False}}
            default: {accessible: False}    
    instret:
      type: dict
      schema:
        description: {type: string, default: Captures the number of instructions executed from an arbitrary point in time.}
        priv_mode: {type: string, default: U, allowed: [U]}
        address: {type: integer, default: 0xC02, allowed: [0xC02]}
        reset-val: {type: integer, default: 0,  check_with: [max_length]}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: minstret, nullable: True}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [rv32_check] }
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: minstret, nullable: True}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {default: true, check_with: [rv64_check]} 
          check_with: u_check
          default: {accessible: False}    
    instreth:
      type: dict
      schema:
        description:
          type: string
          default: Upper 32-bits of the minstret counter; only for rv32.
        address: {type: integer, default: 0xC82, allowed: [0xC82]}
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0, check_with: [max_length]}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: minstreth, nullable: True}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean,  default: true,  check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
            type: dict
            schema: {accessible: {default: False}}
            default: {accessible: False}    
    hpmcounter3:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter3, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter3, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter3 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC03, allowed: [0xC03]}    
    hpmcounter4:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter4, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]} 
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter4, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check] }
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter4 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC04, allowed: [0xC04]}    
    hpmcounter5:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter5, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check] }
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter5, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check] }
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter5 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC05, allowed: [0xC05]}    
    hpmcounter6:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter6, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter6, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter6 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC06, allowed: [0xC06]}    
    hpmcounter7:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter7, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter7, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter7 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC07, allowed: [0xC07]}    
    hpmcounter8:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter8, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter8, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter8 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC08, allowed: [0xC08]}    
    hpmcounter9:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter9, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter9, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter9 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC09, allowed: [0xC09]}    
    hpmcounter10:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter10, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter10, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter10 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC0A, allowed: [0xC0A]}    
    hpmcounter11:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter11, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter11, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter11 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC0B, allowed: [0xC0B]}    
    hpmcounter12:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter12, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter12, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter12 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC0C, allowed: [0xC0C]}    
    hpmcounter13:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter13, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter13, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter13 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC0D, allowed: [0xC0D]}    
    hpmcounter14:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter14, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter14, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter14 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC0E, allowed: [0xC0E]}    
    hpmcounter15:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter15, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter15, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter15 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC0F, allowed: [0xC0F]}    
    hpmcounter16:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter16, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter16, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter16 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC10, allowed: [0xC10]}    
    hpmcounter17:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter17, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter17, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter17 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC11, allowed: [0xC11]}    
    hpmcounter18:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter18, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter18, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter18 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC12, allowed: [0xC12]}    
    hpmcounter19:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter19, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter19, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter19 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC13, allowed: [0xC13]}    
    hpmcounter20:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter20, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter20, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter20 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC14, allowed: [0xC14]}    
    hpmcounter21:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter21, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter21, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter21 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC15, allowed: [0xC15]}    
    hpmcounter22:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter22, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter22, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter22 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC16, allowed: [0xC16]}    
    hpmcounter23:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter23, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter23, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter23 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC17, allowed: [0xC17]}    
    hpmcounter24:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter24, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter24, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter24 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC18, allowed: [0xC18]}    
    hpmcounter25:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter25, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter25, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter25 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC19, allowed: [0xC19]}    
    hpmcounter26:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter26, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter26, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter26 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC1A, allowed: [0xC1A]}    
    hpmcounter27:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter27, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter27, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter27 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC1B, allowed: [0xC1B]}    
    hpmcounter28:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter28, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter28, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter28 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC1C, allowed: [0xC1C]}    
    hpmcounter29:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter29, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter29, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter29 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC1D, allowed: [0xC1D]}    
    hpmcounter30:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter30, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter30, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter30 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC1E, allowed: [0xC1E]}    
    hpmcounter31:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer,  default: 0}
        rv32:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter31, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema: 
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter31, nullable: False}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: {type: boolean, default: true, check_with: [ rv64_check]}
          check_with: u_check
          default: {accessible: False}
        description: {type: string, default: The hpmcounter31 is a 64-bit counter. Returns lower 32 bits in RV32UI mode.}
        address: {type: integer, default: 0xC1F, allowed: [0xC1F]}    
    hpmcounter3h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter3h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter3h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC83, allowed: [0xC83]}
    hpmcounter4h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter4h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter4h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC84, allowed: [0xC84]}
    hpmcounter5h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter5h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter5h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC85, allowed: [0xC85]}
    hpmcounter6h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter6h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter6h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC86, allowed: [0xC86]}
    hpmcounter7h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter7h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter7h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC87, allowed: [0xC87]}
    hpmcounter8h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter8h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter8h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC88, allowed: [0xC88]}
    hpmcounter9h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter9h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter9h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC89, allowed: [0xC89]}
    hpmcounter10h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter10h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter10h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC8A, allowed: [0xC8A]}
    hpmcounter11h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter11h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter11h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC8B, allowed: [0xC8B]}
    hpmcounter12h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter12h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter12h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC8C, allowed: [0xC8C]}
    hpmcounter13h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter13h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter13h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC8D, allowed: [0xC8D]}
    hpmcounter14h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter14h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter14h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC8E, allowed: [0xC8E]}
    hpmcounter15h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter15h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter15h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC8F, allowed: [0xC8F]}
    hpmcounter16h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter16h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter16h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC90, allowed: [0xC90]}
    hpmcounter17h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter17h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter17h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC91, allowed: [0xC91]}
    hpmcounter18h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter18h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter18h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC92, allowed: [0xC92]}
    hpmcounter19h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter19h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter19h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC93, allowed: [0xC93]}
    hpmcounter20h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter20h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter20h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC94, allowed: [0xC94]}
    hpmcounter21h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter21h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter21h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC95, allowed: [0xC95]}
    hpmcounter22h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter22h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter22h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC96, allowed: [0xC96]}
    hpmcounter23h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter23h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter23h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC97, allowed: [0xC97]}
    hpmcounter24h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter24h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter24h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC98, allowed: [0xC98]}
    hpmcounter25h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter25h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter25h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC99, allowed: [0xC99]}
    hpmcounter26h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter26h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter26h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC9A, allowed: [0xC9A]}
    hpmcounter27h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter27h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter27h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC9B, allowed: [0xC9B]}
    hpmcounter28h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter28h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter28h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC9C, allowed: [0xC9C]}
    hpmcounter29h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter29h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter29h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC9D, allowed: [0xC9D]}
    hpmcounter30h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter30h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter30h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC9E, allowed: [0xC9E]}
    hpmcounter31h:
      type: dict
      schema:
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val: {type: integer, default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: mhpmcounter31h, nullable: false}
            shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            accessible: { type: boolean, default: true, check_with: [rv32_check]}
          check_with: u_check
          default: {accessible: False}
        rv64:
          type: dict
          schema:
            accessible: {default: False}
          default: {accessible: False}
        description: { type: string, default: The hpmcounter31h returns the upper half word in RV32I systems.}
        address: {type: integer, default: 0xC9F, allowed: [0xC9F]}
    sstatus:
      type: dict
      schema:
        description:
          type: string
          default: The sstatus register keeps track of the processor’s current operating state.
        address: {type: integer, default: 0x100, allowed: [0x100]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            uie:
              type: dict
              schema:
                description: {type: string,  default: Stores the state of the user mode interrupts.}
                shadow: {type: string, default: mstatus.uie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: n_check
            sie:
              type: dict
              schema:
                description: { type: string, default: Stores the state of the supervisor mode interrupts.}
                shadow: {type: string, default: mstatus.sie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            upie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the user mode interrupts prior to the trap.
                shadow: {type: string, default: mstatus.upie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: n_check
            spie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the supervisor mode interrupts prior to
                    the trap.
                shadow: {type: string, default: mstatus.spie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            spp:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the previous priority mode for supervisor.
                shadow: {type: string, default: mstatus.spp, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            fs:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the status of the floating-point unit, including the
                    CSR fcsr and floating-point data registers.
                shadow: {type: string, default: mstatus.fs, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 14, allowed: [14]}
                lsb: {type: integer, default: 13, allowed: [13]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: fs_check              
            xs:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the status of additional user-mode extensions and associated
                    state.
                shadow: {type: string, default: mstatus.xs, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 16, allowed: [16]}
                lsb: {type: integer, default: 15, allowed: [15]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
            sum:
              type: dict
              schema:
                description:
                  type: string
                  default: Modifies the privilege with which S-mode loads and stores access
                    virtual memory.
                shadow: {type: string, default: mstatus.sum, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 18, allowed: [18]}
                lsb: {type: integer, default: 18, allowed: [18]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            mxr:
              type: dict
              schema:
                description:
                  type: string
                  default: Modifies the privilege with which loads access virtual memory.
                shadow: {type: string, default: mstatus.mxr, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 19, allowed: [19]}
                lsb: {type: integer, default: 19, allowed: [19]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            spelp:
              type: dict
              schema:
                description:
                  type: string
                  default: Supervisor mode previous expected-landing-pad (ELP) state.
                shadow: {type: string, default: mstatus.spelp, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 23, allowed: [23]}
                lsb: {type: integer, default: 23, allowed: [23]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            sd:
              type: dict
              schema:
                description:
                  type: string
                  default: Read-only bit that summarizes whether either the FS field or
                    XS field signals the presence of some dirty state.
                shadow: {type: string, default: mstatus.sd, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 31, allowed: [31]}
                implemented: {type: boolean, default: true}
              default: {implemented: true}
              check_with: fs_check
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            uie:
              type: dict
              schema:
                description: {type: string,  default: Stores the state of the user mode interrupts.}
                shadow: {type: string, default: mstatus.uie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: n_check
            sie:
              type: dict
              schema:
                description: { type: string, default: Stores the state of the supervisor mode interrupts.}
                shadow: {type: string, default: mstatus.sie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            upie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the user mode interrupts prior to the trap.
                shadow: {type: string, default: mstatus.upie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: n_check
            spie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the supervisor mode interrupts prior to
                    the trap.
                shadow: {type: string, default: mstatus.spie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            spp:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the previous priority mode for supervisor.
                shadow: {type: string, default: mstatus.spp, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            fs:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the status of the floating-point unit, including the
                    CSR fcsr and floating-point data registers.
                shadow: {type: string, default: mstatus.fs, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 14, allowed: [14]}
                lsb: {type: integer, default: 13, allowed: [13]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: fs_check
            xs:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the status of additional user-mode extensions and associated
                    state.
                shadow: {type: string, default: mstatus.xs, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 16, allowed: [16]}
                lsb: {type: integer, default: 15, allowed: [15]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
            sum:
              type: dict
              schema:
                description:
                  type: string
                  default: Modifies the privilege with which S-mode loads and stores access
                    virtual memory.
                shadow: {type: string, default: mstatus.sum, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 18, allowed: [18]}
                lsb: {type: integer, default: 18, allowed: [18]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            mxr:
              type: dict
              schema:
                description:
                  type: string
                  default: Modifies the privilege with which loads access virtual memory.
                shadow: {type: string, default: mstatus.mxr, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 19, allowed: [19]}
                lsb: {type: integer, default: 19, allowed: [19]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            spelp:
              type: dict
              schema:
                description:
                  type: string
                  default: Supervisor mode previous expected-landing-pad (ELP) state.
                shadow: {type: string, default: mstatus.spelp, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 23, allowed: [23]}
                lsb: {type: integer, default: 23, allowed: [23]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            uxl:
              type: dict
              schema:
                description: {type: string, default: Controls the xlen for User mode.}
                shadow: {type: string, default: mstatus.uxl, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 33, allowed: [33]}
                lsb: {type: integer, default: 32, allowed: [32]}
                implemented: {type: boolean, default: true}
              default: {implemented: true}
              check_with: u_check
            sd:
              type: dict
              schema:
                description:
                  type: string
                  default: Read-only bit that summarizes whether either the FS field or
                    XS field signals the presence of some dirty state.
                shadow: {type: string, default: mstatus.sd, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 63, allowed: [63]}
                implemented: {type: boolean, default: true}
              default: {implemented: true}
              check_with: fs_check
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
          default: {accessible: False}
    sie:
      type: dict
      schema:
        description:
          type: string
          default: The sie register is an SXLEN-bit read/write register containing interrupt
            enable bits.
        address: {type: integer, default: 0x104, allowed: [0x104]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            usie:
              type: dict
              schema:
                description: {type: string, default: User Software Interrupt enable.}
                shadow: {type: string, default: mie.usie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            ssie:
              type: dict
              schema:
                description: {type: string, default: Supervisor Software Interrupt enable.}
                shadow: {type: string, default: mie.ssie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: s_check
            utie:
              type: dict
              schema:
                description: { type: string, default: User Timer Interrupt enable.}
                shadow: {type: string, default: mie.utie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            stie:
              type: dict
              schema:
                description: { type: string, default: Supervisor Timer Interrupt enable.}
                shadow: {type: string, default: mie.stie , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: s_check
            ueie:
              type: dict
              schema:
                description: { type: string, default: User External Interrupt enable.}
                shadow: {type: string, default: mie.ueie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            seie:
              type: dict
              schema:
                description: { type: string, default: Supervisor External Interrupt enable.}
                shadow: {type: string, default: mie.seie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 9, allowed: [9]}
                lsb: {type: integer, default: 9, allowed: [9]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: s_check
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            usie:
              type: dict
              schema:
                description: {type: string, default: User Software Interrupt enable.}
                shadow: {type: string, default: mie.usie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            ssie:
              type: dict
              schema:
                description: {type: string, default: Supervisor Software Interrupt enable.}
                shadow: {type: string, default: mie.ssie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: s_check
            utie:
              type: dict
              schema:
                description: { type: string, default: User Timer Interrupt enable.}
                shadow: {type: string, default: mie.utie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            stie:
              type: dict
              schema:
                description: { type: string, default: Supervisor Timer Interrupt enable.}
                shadow: {type: string, default: mie.stie , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: s_check
            ueie:
              type: dict
              schema:
                description: { type: string, default: User External Interrupt enable.}
                shadow: {type: string, default: mie.ueie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            seie:
              type: dict
              schema:
                description: { type: string, default: Supervisor External Interrupt enable.}
                shadow: {type: string, default: mie.seie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 9, allowed: [9]}
                lsb: {type: integer, default: 9, allowed: [9]}
                implemented: {type: boolean, default: False}
              default: {implemented: False}
              check_with: s_check
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
    sip:
      type: dict
      schema:
        description:
          type: string
          default: The sip register is an SXLEN-bit read/write register containing interrupt
            pending bits.
        address: {type: integer, default: 0x144, allowed: [0x144]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            usip:
              type: dict
              schema:
                description: {type: string, default: User Software Interrupt enable.}
                shadow: {type: string, default: mip.usip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            ssip:
              type: dict
              schema:
                description: {type: string, default: Supervisor Software Interrupt enable.}
                shadow: {type: string, default: mip.ssip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: s_check
            utip:
              type: dict
              schema:
                description: { type: string, default: User Timer Interrupt enable.}
                shadow: {type: string, default: mip.utip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            stip:
              type: dict
              schema:
                description: { type: string, default: Supervisor Timer Interrupt enable.}
                shadow: {type: string, default: mip.stip , nullable: True}
                shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: s_check
            ueip:
              type: dict
              schema:
                description: { type: string, default: User External Interrupt enable.}
                shadow: {type: string, default: mip.ueip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            seip:
              type: dict
              schema:
                description: { type: string, default: Supervisor External Interrupt enable.}
                shadow: {type: string, default: mip.seip, nullable: True}
                shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 9, allowed: [9]}
                lsb: {type: integer, default: 9, allowed: [9]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: s_check
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            usip:
              type: dict
              schema:
                description: {type: string, default: User Software Interrupt enable.}
                shadow: {type: string, default: mip.usip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            ssip:
              type: dict
              schema:
                description: {type: string, default: Supervisor Software Interrupt enable.}
                shadow: {type: string, default: mip.ssip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: s_check
            utip:
              type: dict
              schema:
                description: { type: string, default: User Timer Interrupt enable.}
                shadow: {type: string, default: mip.utip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            stip:
              type: dict
              schema:
                description: { type: string, default: Supervisor Timer Interrupt enable.}
                shadow: {type: string, default: mip.stip , nullable: True}
                shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: s_check
            ueip:
              type: dict
              schema:
                description: { type: string, default: User External Interrupt enable.}
                shadow: {type: string, default: mip.ueip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            seip:
              type: dict
              schema:
                description: { type: string, default: Supervisor External Interrupt enable.}
                shadow: {type: string, default: mip.seip, nullable: True}
                shadow_type: {type: string, default: ro, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 9, allowed: [9]}
                lsb: {type: integer, default: 9, allowed: [9]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: s_check
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
    sscratch:
      type: dict
      schema:
        description:
          type: string
          default: The sscratch register is an MXLEN-bit read/write register dedicated
            for use by machine mode.
        address: {type: integer, default: 0x140, allowed: [0x140]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              - schema: {ro_variable: {type: boolean}}
              - schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - sscratch[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFFFFFFFFFF}}
              - schema: {ro_variable: {type: boolean}}
              - schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - sscratch[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: false}
    sepc:
      type: dict
      schema:
        description:
          type: string
          default: The sepc is a warl register that must be able to hold all valid physical
            and virtual addresses.
        address: {type: integer, default: 0x141, allowed: [0x141]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - sepc[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - sepc[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              type: boolean
              default: true
              check_with: rv64_check
          default: {accessible: false}
    stval:
      type: dict
      schema:
        description:
          type: string
          default: The stval is a warl register that holds the address of the instruction
            which caused the exception.
        address: {type: integer, default: 0x143, allowed: [0x143]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - stval[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - stval[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: false}
    scause:
      type: dict
      schema:
        description:
          type: string
          default: The scause register stores the information regarding the trap.
        address: {type: integer, default: 0x142, allowed: [0x142]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            interrupt:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether the trap was due to an interrupt.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 31, allowed: [31]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl: 
                    - 0x0:0x1
                  readonly: True
              default: {implemented: False}
              check_with: s_check
            exception_code:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the exception code.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 30, allowed: [30]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl: 
                    - 0:15
              default: {implemented: False}
              check_with: s_check
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            interrupt:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether the trap was due to an interrupt.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 63, allowed: [63]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: False}
              check_with: s_check
            exception_code:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the exception code.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 62, allowed: [62]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0:15
              default: {implemented: false}
              check_with: s_check
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
          default: {accessible: false}
    stvec:
      type: dict
      schema:
        description:
          type: string
          default: SXLEN-bit read/write register that holds trap vector configuration.
        address: {type: integer, default: 0x105, allowed: [0x105]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          check_with:
          - max_length
          default: 0
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            base:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector base address.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  1073741823}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                     warl:
                       dependency_fields: []
                       legal:
                         - "base[29:0] bitmask [0x3FFFFFFF, 0x00000000]"
                       wr_illegal:
                         - "Unchanged"
              default: {implemented: False}
              check_with: s_check
            mode:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  1}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                        dependency_fields: []
                        legal:
                          - 'mode[1:0] in [0x0:0x1]'
                        wr_illegal:
                          - Unchanged
              default: {implemented: false}
              check_with: s_check
            accessible:
              type: boolean
              check_with:
              - rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            base:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector base address.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  4611686018427387903}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                        dependency_fields: []
                        legal:
                          - "base[61:0] bitmask [0x3FFFFFFFFFFFFFFF, 0x0000000000000000]"
                        wr_illegal:
                          - "Unchanged"
              default: {implemented: False}
              check_with: s_check
            mode:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  1}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                        dependency_fields: []
                        legal:
                          - 'mode[1:0] in [0x0:0x1]'
                        wr_illegal:
                          - Unchanged
              default: {implemented: false}
              check_with: s_check
            accessible:
              type: boolean
              check_with:
              - rv64_check
          default: {accessible: false}
    senvcfg:
      type: dict
      schema:
        description:
          type: string
          default: SXLEN-bit read/write register that stores the information regarding machine environment configuration.
        address: {type: integer, default: 0x10A, allowed: [0x10A]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            cbze:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Zero instruction is enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
              check_with: s_check
            cbcfe:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Clean and Flush instructions are enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
              check_with: s_check
            cbie:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Invalidate instruction is enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                       dependency_fields: []
                       legal:
                         - cbie[1:0] in [0x0, 0x1, 0x3]
                       wr_illegal:
                         - unchanged
              default: {implemented: true}
              check_with: s_check
            sse:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Zicfiss extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 3, allowed: [3]}
                lsb: {type: integer, default: 3, allowed: [3]}
                implemented: {type: boolean, default: false, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
              check_with: s_check
            lpe:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Zicfilp extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: false, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
              check_with: s_check
            accessible:
              type: boolean
              check_with:
              - rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            cbze:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Zero instruction is enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
              check_with: s_check
            cbcfe:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Clean and Flush instructions are enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
              check_with: s_check
            cbie:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Invalidate instruction is enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                       dependency_fields: []
                       legal:
                         - cbie[1:0] in [0x0, 0x1, 0x3]
                       wr_illegal:
                         - unchanged
              default: {implemented: true}
              check_with: s_check
            sse:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Zicfiss extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 3, allowed: [3]}
                lsb: {type: integer, default: 3, allowed: [3]}
                implemented: {type: boolean, default: false, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
              check_with: s_check
            lpe:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Zicfilp extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: false, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
              check_with: s_check
            accessible:
              type: boolean
              check_with:
              - rv64_check
          default: {accessible: false}
    satp:
      type: dict
      schema:
        description: { type: string, default: SXLEN-bit register which controls supervisor-mode address translation and protection }
        address: {type: integer, default: 0x180, allowed: [0x180]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val: { type: integer, check_with: max_length , default: 0}
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            ppn:
              type: dict
              schema:
                description: { type: string , default: Physical Page Number }
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 21, allowed: [21]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  4194303}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                        dependency_fields: []
                        legal:
                          - ppn[21:0] in [0x0:0x3FFFFF]
                        wr_illegal:
                          - Unchanged
              default: {implemented: False}
              check_with: s_check
            asid:
              type: dict
              schema:
                description: { type: string, default: Address Space identifier. }
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 30, allowed: [30]}
                lsb: {type: integer, default: 22, allowed: [22]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 511 }}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                        dependency_fields: []
                        legal:
                          - asid[8:0] in [0x0:0x1FF]
                        wr_illegal:
                          - Unchanged
              default: {implemented: False}
              check_with: s_check
            mode:
              type: dict
              schema:
                description: { type: string, default: Vector mode. }
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 31, allowed: [31]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, allowed: [0,1]}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                        dependency_fields: []
                        legal:
                          - mode[0] in [0x0,0x1]
                        wr_illegal:
                          - Unchanged
              default: {implemented: False}
              check_with: s_check
            accessible:
              type: boolean
              check_with:
              - rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            ppn:
              type: dict
              schema:
                description:
                  type: string
                  default: Physical Page Number
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 43, allowed: [43]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  17592186044415}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                        dependency_fields: []
                        legal:
                          - ppn[43:0] in [0x0:0xFFFFFFFFFFF]
                        wr_illegal:
                          - Unchanged
              default: {implemented: False}
              check_with: s_check
            asid:
              type: dict
              schema:
                description:
                  type: string
                  default: Address Space identifier.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 59, allowed: [59]}
                lsb: {type: integer, default: 44, allowed: [44]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 65535}}
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                        dependency_fields: []
                        legal:
                          - asid[15:0] in [0x0:0xFFFF]
                        wr_illegal:
                          - Unchanged
              default: {implemented: False}
              check_with: s_check
            mode:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 60, allowed: [60]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  check_with: satp_modes64
                  oneof:
                  - schema: {ro_constant: {type: integer, allowed: [0,8,9,10,14,15]}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                        dependency_fields: []
                        legal:
                          - mode[3:0] in [0, 8, 9, 10]
                        wr_illegal:
                          - Unchanged
              default: {implemented: False}
              check_with: s_check
            accessible:
              type: boolean
              check_with:
              - rv64_check
          default: {accessible: false}
    ustatus:
      type: dict
      schema:
        description:
          type: string
          default: The ustatus register keeps track of the processor’s current operating state.
        address: {type: integer, default: 0x000, allowed: [0x000]}
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            uie:
              type: dict
              schema:
                description: {type: string,  default: Stores the state of the user mode interrupts.}
                shadow: {type: string, default: mstatus.uie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: n_check
            upie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the user mode interrupts prior to the trap.
                shadow: {type: string, default: mstatus.upie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: n_check
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            uie:
              type: dict
              schema:
                description: {type: string,  default: Stores the state of the user mode interrupts.}
                shadow: {type: string, default: mstatus.uie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: n_check
            upie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the user mode interrupts prior to the trap.
                shadow: {type: string, default: mstatus.upie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: n_check
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
          default: {accessible: False}
    uie:
      type: dict
      schema:
        description:
          type: string
          default: The uie register is an UXLEN-bit read/write register containing interrupt
            enable bits.
        address: {type: integer, default: 0x004, allowed: [0x004]}
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            usie:
              type: dict
              schema:
                description: {type: string, default: User Software Interrupt enable.}
                shadow: {type: string, default: mie.usie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            utie:
              type: dict
              schema:
                description: { type: string, default: User Timer Interrupt enable.}
                shadow: {type: string, default: mie.utie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            ueie:
              type: dict
              schema:
                description: { type: string, default: User External Interrupt enable.}
                shadow: {type: string, default: mie.ueie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            usie:
              type: dict
              schema:
                description: {type: string, default: User Software Interrupt enable.}
                shadow: {type: string, default: mie.usie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            utie:
              type: dict
              schema:
                description: { type: string, default: User Timer Interrupt enable.}
                shadow: {type: string, default: mie.utie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            ueie:
              type: dict
              schema:
                description: { type: string, default: User External Interrupt enable.}
                shadow: {type: string, default: mie.ueie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
    uip:
      type: dict
      schema:
        description:
          type: string
          default: The uip register is an UXLEN-bit read/write register containing interrupt
            pending bits.
        address: {type: integer, default: 0x044, allowed: [0x044]}
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            usip:
              type: dict
              schema:
                description: {type: string, default: User Software Interrupt enable.}
                shadow: {type: string, default: mip.usip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            utip:
              type: dict
              schema:
                description: { type: string, default: User Timer Interrupt enable.}
                shadow: {type: string, default: mip.utip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            ueip:
              type: dict
              schema:
                description: { type: string, default: User External Interrupt enable.}
                shadow: {type: string, default: mip.ueip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            usip:
              type: dict
              schema:
                description: {type: string, default: User Software Interrupt enable.}
                shadow: {type: string, default: mip.usip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            utip:
              type: dict
              schema:
                description: { type: string, default: User Timer Interrupt enable.}
                shadow: {type: string, default: mip.utip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            ueip:
              type: dict
              schema:
                description: { type: string, default: User External Interrupt enable.}
                shadow: {type: string, default: mip.ueip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
              check_with: n_check
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
    uscratch:
      type: dict
      schema:
        description:
          type: string
          default: The uscratch register is an UXLEN-bit read/write register dedicated
            for use by machine mode.
        address: {type: integer, default: 0x040, allowed: [0x040]}
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              - schema: {ro_variable: {type: boolean}}
              - schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - uscratch[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFFFFFFFFFF}}
              - schema: {ro_variable: {type: boolean}}
              - schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - uscratch[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: false}
    uepc:
      type: dict
      schema:
        description:
          type: string
          default: The uepc is a warl register that must be able to hold all valid physical
            and virtual addresses.
        address: {type: integer, default: 0x041, allowed: [0x041]}
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - uepc[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - uepc[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              type: boolean
              default: true
              check_with: rv64_check
          default: {accessible: false}
    utval:
      type: dict
      schema:
        description:
          type: string
          default: The utval is a warl register that holds the address of the instruction
            which caused the exception.
        address: {type: integer, default: 0x043, allowed: [0x043]}
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - utval[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - utval[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: false}
    ucause:
      type: dict
      schema:
        description:
          type: string
          default: The ucause register stores the information regarding the trap.
        address: {type: integer, default: 0x042, allowed: [0x042]}
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            interrupt:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether the trap was due to an interrupt.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 31, allowed: [31]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl: 
                    - 0x0:0x1
                  readonly: True
              default: {implemented: False}
              check_with: n_check
            exception_code:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the exception code.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 30, allowed: [30]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl: 
                    - 0:15
              default: {implemented: False}
              check_with: n_check
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            interrupt:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether the trap was due to an interrupt.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 63, allowed: [63]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: False}
              check_with: n_check
            exception_code:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the exception code.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 62, allowed: [62]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0:15
              default: {implemented: false}
              check_with: n_check
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
          default: {accessible: false}
    utvec:
      type: dict
      schema:
        description:
          type: string
          default: UXLEN-bit read/write register that holds trap vector configuration.
        address: {type: integer, default: 0x005, allowed: [0x005]}
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val:
          type: integer
          check_with:
          - max_length
          default: 0
        rv32:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            base:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector base address.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  1073741823}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                     warl:
                       dependency_fields: []
                       legal:
                         - "base[29:0] bitmask [0x3FFFFFFF, 0x00000000]"
                       wr_illegal:
                         - "Unchanged"
              default: {implemented: False}
              check_with: n_check
            mode:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  1}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                     warl:
                        dependency_fields: []
                        legal:
                          - 'mode[1:0] in [0x0:0x1]'
                        wr_illegal:
                          - Unchanged
              default: {implemented: false}
              check_with: n_check
            accessible:
              type: boolean
              check_with:
              - rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: n_check
          schema:
            fields: {type: list, default: []}
            base:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector base address.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  4611686018427387903}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                     warl:
                        dependency_fields: []
                        legal:
                          - "base[61:0] bitmask [0x3FFFFFFFFFFFFFFF, 0x0000000000000000]"
                        wr_illegal:
                          - "Unchanged"
              default: {implemented: False}
              check_with: n_check
            mode:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  1}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                     warl:
                        dependency_fields: []
                        legal:
                          - 'mode[1:0] in [0x0:0x1]'
                        wr_illegal:
                          - Unchanged
              default: {implemented: false}
              check_with: n_check
            accessible:
              type: boolean
              check_with:
              - rv64_check
          default: {accessible: false}
    scounteren:
      type: dict
      schema:
        description:
          type: string
          default: The scounteren is a 32-bit register that controls the availability
            of the hardware performance-monitoring counters to the next-lowest privileged
            mode.
        address: {type: integer, default: 0x106, allowed: [0x106]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val: {type: integer, check_with: max_length32, default: 0}
        rv32:
          type: dict
          check_with: u_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer}}
              - schema: { warl: *ref_warl }
              default:
                ro_constant: 0
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: u_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer}}
              - schema: { warl: *ref_warl }
              default:
                ro_constant: 0
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: false}
    hstatus:
      type: dict
      schema:
        description:
          type: string
          default: The hstatus register keeps track of and controls the hart’s current
            operating state.
        address: {type: integer, default: 1536, allowed: [1536]}
        priv_mode: {type: string, default: H, allowed: [H]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            vsbe:
              type: dict
              schema:
                description: {type: string,  default: WARL field that controls the endianness of explicit memory accesses made from VS-mode}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
            gva:
              type: dict
              schema:
                description: { type: string, default: Guest Virtual Address is written by the implementation whenever a trap is taken into HS-mode}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
              check_with: h_check
            spv:
              type: dict
              schema:
                description:
                  type: string
                  default: Supervisor Previous Virtualization mode is written by the implementation whenever a trap is taken into HS-mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default: { wlrl: [0:1] }
              default: {implemented: false}
              check_with: h_check
            spvp:
              type: dict
              schema:
                description:
                  type: string
                  default: set to the privilege mode at the time of the trap
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
              check_with: h_check
            hu:
              type: dict
              schema:
                description:
                  type: string
                  default: Controls whether the virtual-machine load/store instructions can be used also in U-mode
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 9, allowed: [9]}
                lsb: {type: integer, default: 9, allowed: [9]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
              check_with: h_check
            vgein:
              type: dict
              schema:
                description:
                  type: string
                  default: vgein field selects a guest external interrupt source for VS-level external interrupt
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 17, allowed: [17]}
                lsb: {type: integer, default: 12, allowed: [12]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: {ro_constant: {type: integer, max:  64, min : 0}}
                  default: {ro_constant: 0}
              default: {implemented: true}
            vtvm:
              type: dict
              schema:
                description:
                  type: string
                  default: Supports intercepting supervisor virtual-memory management operations.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 20, allowed: [20]}
                lsb: {type: integer, default: 20, allowed: [20]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
            vtw:
              type: dict
              schema:
                description:
                  type: string
                  default: Supports intercepting the WFI instruction.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 21, allowed: [21]}
                lsb: {type: integer, default: 21, allowed: [21]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: true}
            vtsr:
              type: dict
              schema:
                description:
                  type: string
                  default: Supports intercepting the virtual supervisor exception return instruction.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 22, allowed: [22]}
                lsb: {type: integer, default: 22, allowed: [22]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                       dependency_fields: []
                       legal:
                         - vtsr[0] in [0x0]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
            accessible:
              type: boolean
              default: false
              check_with: rv32_check 
        rv64:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            vsbe:
              type: dict
              schema:
                description: {type: string,  default: WARL field that controls the endianness of explicit memory accesses made from VS-mode}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
            gva:
              type: dict
              schema:
                description: { type: string, default: Guest Virtual Address is written by the implementation whenever a trap is taken into HS-mode}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
              check_with: h_check
            spv:
              type: dict
              schema:
                description:
                  type: string
                  default: Supervisor Previous Virtualization mode is written by the implementation whenever a trap is taken into HS-mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default: { wlrl: [0:1] }
              default: {implemented: false}
              check_with: h_check
            spvp:
              type: dict
              schema:
                description:
                  type: string
                  default: set to the privilege mode at the time of the trap
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
              check_with: h_check
            hu:
              type: dict
              schema:
                description:
                  type: string
                  default: Controls whether the virtual-machine load/store instructions can be used also in U-mode
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 9, allowed: [9]}
                lsb: {type: integer, default: 9, allowed: [9]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
              check_with: h_check
            vgein:
              type: dict
              schema:
                description:
                  type: string
                  default: vgein field selects a guest external interrupt source for VS-level external interrupt
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 17, allowed: [17]}
                lsb: {type: integer, default: 12, allowed: [12]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema:  {ro_constant: {type: integer, max:  64, min : 0}}
                  default: {ro_constant: 0}
              default: {implemented: true}
            vtvm:
              type: dict
              schema:
                description:
                  type: string
                  default: Supports intercepting supervisor virtual-memory management operations.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 20, allowed: [20]}
                lsb: {type: integer, default: 20, allowed: [20]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: false}
            vtw:
              type: dict
              schema:
                description:
                  type: string
                  default: Supports intercepting the WFI instruction.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 21, allowed: [21]}
                lsb: {type: integer, default: 21, allowed: [21]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: true}
            vtsr:
              type: dict
              schema:
                description:
                  type: string
                  default: Supports intercepting the virtual supervisor exception return instruction.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 22, allowed: [22]}
                lsb: {type: integer, default: 22, allowed: [22]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                       dependency_fields: []
                       legal:
                         - vtsr[0] in [0x0]
                       wr_illegal:
                         - unchanged
              default: {implemented: false}
            vsxl:
              type: dict
              schema:
                description:
                  type: string
                  default: controls the effective XLEN for VS-mode (known as VSXLEN)
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 33, allowed: [33]}
                lsb: {type: integer, default: 32, allowed: [32]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 2, min: 1}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 2}
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
          default: {accessible: false}
    hideleg:
      type: dict
      schema:
        description:
          type: string
          default: Hypervisor Interrupt delegation Register.
        address: {type: integer, default: 1539, allowed: [1539]}
        priv_mode: {type: string, default: H, allowed: [H]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                   - "hideleg[31:0] bitmask [0x00000444, 0x0000000]"
                  wr_illegal:
                   - 'unchanged'
            accessible:
              type: boolean
              default: true
              check_with:
              - rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - "hideleg[63:0] bitmask [0x0000000000000444, 0x0000000000000000]"
                  wr_illegal:
                  - 'unchanged'
            accessible:
              type: boolean
              default: true
              check_with:
              - rv64_check
          default: {accessible: false}
    hedeleg:
      type: dict
      schema:
        description:
          type: string
          default: Hypervisor Exception delegation Register.
        address: {type: integer, default: 1538, allowed: [1538]}
        priv_mode: {type: string, default: H, allowed: [H]}
        reset-val:
          type: integer
          default: 0
          check_with:
          - max_length
        rv32:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - "medeleg[31:0] bitmask [0x00001BFE, 0x0000000]"
                  wr_illegal:
                  - 'unchanged'
            accessible:
              type: boolean
              default: true
              check_with:
              - rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - "medeleg[63:0] bitmask [0x0000000000001BFE, 0x000000000000000]"
                  wr_illegal:
                  - 'unchanged'
            accessible:
              type: boolean
              default: true
              check_with:
              - rv64_check
          default: {accessible: false}
    hip:
      type: dict
      schema:
        description:
          type: string
          default: The hip register is an HXLEN-bit read/write register containing information on pending interrupts.
        address: {type: integer, default: 1604, allowed: [1604]}
        priv_mode: {type: string, default: H, allowed: [H]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            vssip:
              type: dict
              schema:
                description:
                  type: string
                  default: VS-level Software Interrupt Pending.
                shadow: {type: string, default: mip.vssip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 1 , min : 0}}
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vssip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            vstip:
              type: dict
              schema:
                description:
                  type: string
                  default: VS-level Timer Interrupt Pending.
                shadow: {type: string, default: mip.vstip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max:  1, min : 0}}
                  default: {ro_constant: 0}
              default: {implemented: False}
            vseip:
              type: dict
              schema:
                description:
                  type: string
                  default: VS-level External Interrupt Pending.
                shadow: {type: string, default: mip.vseip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 10, allowed: [10]}
                lsb: {type: integer, default: 10, allowed: [10]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max:  1, min : 0}}
                  default: {ro_constant: 0}
              default: {implemented: False}
            sgeip:
              type: dict
              check_with: h_check
              schema:
                description:
                  type: string
                  default: HS-level External Interrupt Pending.
                shadow: {type: string, default: mip.sgeip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 12, allowed: [12]}
                lsb: {type: integer, default: 12, allowed: [12]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: {ro_variable: {type: boolean, allowed: [True]}}
                  readonly: true
                  default: {ro_variable: True}
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            vssip:
              type: dict
              schema:
                description:
                  type: string
                  default: VS-level Software Interrupt Pending.
                shadow: {type: string, default: mip.vssip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vssip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            vstip:
              type: dict
              schema:
                description:
                  type: string
                  default: VS-level Timer Interrupt Pending.
                shadow: {type: string, default: mip.vstip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max:  1, min : 0}}
                  default: {ro_constant: 0}
              default: {implemented: False}
            vseip:
              type: dict
              schema:
                description:
                  type: string
                  default: VS-level External Interrupt Pending.
                shadow: {type: string, default: mip.vseip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 10, allowed: [10]}
                lsb: {type: integer, default: 10, allowed: [10]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max:  1, min : 0}}
                  default: {ro_constant: 0}
              default: {implemented: False}
            sgeip:
              type: dict
              check_with: h_check
              schema:
                description:
                  type: string
                  default: HS-level External Interrupt Pending.
                shadow: {type: string, default: mip.sgeip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 12, allowed: [12]}
                lsb: {type: integer, default: 12, allowed: [12]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: {ro_variable: {type: boolean, allowed: [True]}}
                  readonly: true
                  default: {ro_variable: True}
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
    hvip:
      type: dict
      schema:
        description:
          type: string
          default: The hvip register is an HSXLEN-bit read/write register that a hypervisor can write to indicate virtual interrupts intended for VS-mode.
        address: {type: integer, default: 1605, allowed: [1605]}
        priv_mode: {type: string, default: H, allowed: [H]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            vssip:
              type: dict
              schema:
                description:
                  type: string
                  default: VS-level Software Interrupt Pending.
                shadow: {type: string, default: mip.vssip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vssip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            vstip:
              type: dict
              schema:
                description:
                  type: string
                  default: VS-level Timer Interrupt Pending.
                shadow: {type: string, default: mip.vstip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vstip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            vseip:
              type: dict
              schema:
                description:
                  type: string
                  default: VS-level External Interrupt Pending.
                shadow: {type: string, default: mip.vseip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 10, allowed: [10]}
                lsb: {type: integer, default: 10, allowed: [10]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vseip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            accessible:
              type: boolean
              default: false
              check_with: rv32_check 
        rv64:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            vssip:
              type: dict
              schema:
                description:
                  type: string
                  default: VS-level Software Interrupt Pending.
                shadow: {type: string, default: mip.vssip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vssip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            vstip:
              type: dict
              schema:
                description:
                  type: string
                  default: VS-level Timer Interrupt Pending.
                shadow: {type: string, default: mip.vstip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vstip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            vseip:
              type: dict
              schema:
                description:
                  type: string
                  default: VS-level External Interrupt Pending.
                shadow: {type: string, default: mip.vseip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 10, allowed: [10]}
                lsb: {type: integer, default: 10, allowed: [10]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                      dependency_fields: []
                      legal:
                        - vseip[0] in [0x0, 0x1]
                      wr_illegal:
                        - unchanged
              default: {implemented: False}
            accessible:
              type: boolean
              default: false
              check_with: rv64_check    
    hgeip:
      type: dict
      schema:
        description:
          type: string
          default: The hgeip register is an HSXLEN-bit read-only register that indicates pending guest external interrupts for this hart.
        address: {type: integer, default: 0xE12, allowed: [0xE12]}
        priv_mode: {type: string, default: H, allowed: [H]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
                    - schema: {ro_constant: {type: integer, max: 0x3, min: 0x1}}
                    - schema: {ro_variable: {type: boolean}}  
              default: {ro_variable: True}                                  
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
                    - schema: {ro_constant: {type: integer, max: 0x3, min: 0x1}}
                    - schema: {ro_variable: {type: boolean}}
              default: {ro_variable: True}
            accessible:
              type: boolean
              default: true
              check_with: rv64_check
          default: {accessible: false}
    hgeie:
      type: dict
      schema:
        description:
          type: string
          default: The hgeie register is an HSXLEN-bit read/write register that contains enable bits for the guest external interrupts at this hart.
        address: {type: integer, default: 0x607, allowed: [0x607]}
        priv_mode: {type: string, default: H, allowed: [H]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - hgeie[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged    
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - hgeie[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged    
            accessible:
              type: boolean
              default: true
              check_with: rv64_check
          default: {accessible: false}
    henvcfg:
      type: dict
      schema:
        description:
          type: string
          default: The henvcfg register is an HSXLEN-bit read/write register that stores the information regarding hypervisor environment configuration.
        address: {type: integer, default: 0x60A, allowed: [0x60A]}
        priv_mode: {type: string, default: H, allowed: [H]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            cbze:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Zero instruction is enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            cbcfe:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Clean and Flush instructions are enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            cbie:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Invalidate instruction is enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                       dependency_fields: []
                       legal:
                         - cbie[1:0] in [0x0, 0x1, 0x3]
                       wr_illegal:
                         - unchanged
              default: {implemented: true}
            sse:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Zicfiss extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 3, allowed: [3]}
                lsb: {type: integer, default: 3, allowed: [3]}
                implemented: {type: boolean, default: false, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            lpe:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Zicfilp extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: false, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            cbze:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Zero instruction is enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            cbcfe:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Clean and Flush instructions are enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 6, allowed: [6]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            cbie:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether Cache Block Invalidate instruction is enabled.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 4, allowed: [4]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: { warl: *ref_warl }
                  default:
                    warl:
                       dependency_fields: []
                       legal:
                         - cbie[1:0] in [0x0, 0x1, 0x3]
                       wr_illegal:
                         - unchanged
              default: {implemented: true}
            sse:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Zicfiss extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 3, allowed: [3]}
                lsb: {type: integer, default: 3, allowed: [3]}
                implemented: {type: boolean, default: false, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            lpe:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Zicfilp extension.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 2, allowed: [2]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: false, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            accessible:
              type: boolean
              default: true
              check_with: rv64_check
          default: {accessible: false}
    htval:
      type: dict
      schema:
        description:
          type: string
          default: The htval is a warl register that holds the address of the instruction
            which caused the exception.
        address: {type: integer, default: 0x643, allowed: [0x643]}
        priv_mode: {type: string, default: H, allowed: [H]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - htval[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged    
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - htval[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged    
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: false}
    htinst:
      type: dict
      schema:
        description:
          type: string
          default: The htinst is a warl register that need only be able to hold the values that the implementation may automatically write to it on a trap.
        address: {type: integer, default: 0x64A, allowed: [0x64A]}
        priv_mode: {type: string, default: H, allowed: [H]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - htinst[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged    
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - htinst[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged    
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: false}
    mtval2:
      type: dict
      schema:
        description:
          type: string
          default: When a trap is taken into M-mode, mtval2 is written with additional exception-specific information to assist software in handling the trap.
        address: {type: integer, default: 0x34B, allowed: [0x34B]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict          
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - mtval2[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged    
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict          
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - mtval2[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged    
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: false}
    mtinst:
      type: dict
      schema:
        description:
          type: string
          default: The mtinst is a warl register that need only be able to hold the values that the implementation may automatically write to it on a trap.
        address: {type: integer, default: 0x34A, allowed: [0x34A]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - mtinst[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged    
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - mtinst[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged    
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: false}
    
    hgatp:
      type: dict
      schema:
        description: { type: string, default: HSXLEN-bit register which controls G-stage address translation and protection }
        address: {type: integer, default: 0x680, allowed: [0x680]}
        priv_mode: {type: string, default: H, allowed: [H]}
        reset-val: { type: integer, check_with: max_length , default: 0}
        rv32:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            ppn:
              type: dict
              schema:
                description: { type: string , default: Physical Page Number }
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 21, allowed: [21]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  4194303}}
                  - schema: { warl: *ref_warl }
                  default: {ro_constant : 0}
              default: {implemented: False}
            vmid:
              type: dict
              schema:
                description: { type: string, default: Address Space identifier. }
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 28, allowed: [28]}
                lsb: {type: integer, default: 22, allowed: [22]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 511 }}
                  - schema: { warl: *ref_warl }
                  default: {ro_constant : 0}
              default: {implemented: False}
            mode:
              type: dict
              schema:
                description: { type: string, default: Vector mode. }
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 31, allowed: [31]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  1}}
                  - schema: { warl: *ref_warl }
                  default: {ro_constant : 0}
              default: {implemented: False}
            accessible:
              type: boolean
              check_with:
              - rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: h_check
          schema:
            fields: {type: list, default: []}
            ppn:
              type: dict
              schema:
                description:
                  type: string
                  default: Physical Page Number
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 43, allowed: [43]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  17592186044415}}
                  - schema: { warl: *ref_warl }
                  default: {ro_constant : 0}
              default: {implemented: False}
            vmid:
              type: dict
              schema:
                description:
                  type: string
                  default: Address Space identifier.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 57, allowed: [57]}
                lsb: {type: integer, default: 44, allowed: [44]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 65535}}
                  - schema: { warl: *ref_warl }
                  default: {ro_constant : 0}
              default: {implemented: False}
            mode:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 60, allowed: [60]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  15}}
                  - schema: { warl: *ref_warl }
                  default: {ro_constant : 0}
              default: {implemented: False}
            accessible:
              type: boolean
              check_with:
              - rv64_check
          default: {accessible: false}
    hcounteren:
      type: dict
      schema:
        description:
          type: string
          default: The hcounteren is a 32-bit register that controls the availability
            of the hardware performance-monitoring counters to the next-lowest privileged
            mode.
        address: {type: integer, default: 0x606, allowed: [0x606]}
        priv_mode: {type: string, default: H, allowed: [H]}
        reset-val: {type: integer, check_with: max_length, default: 0}
        rv32:
          type: dict
          check_with: u_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - hcounteren[31:0] in [0x00000000]
                  wr_illegal:
                  - unchanged
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: u_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - hcounteren[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: false}
    htimedelta:
      type: dict
      schema:
        description: {type: string, default: The htimedelta CSR is a read/write register that contains the delta between the value of the time
CSR and the value returned in VS-mode or VU-mode.}
        priv_mode: {type: string, default: H, allowed: [H]}
        address: {type: integer, default: 0x605, allowed: [0x605]}
        reset-val: {type: integer, default: 0,  check_with: [max_length]}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - htimedelta[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
            accessible: {type: boolean, default: true, check_with: [rv32_check]}
          check_with: h_check
          default: {accessible: true}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict              
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - htimedelta[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged
            accessible: {default: true, check_with: [rv64_check]}
          check_with: h_check
          default: {accessible: true}    
    htimedeltah:
      type: dict
      schema:
        description:
          type: string
          default: Upper 32-bits of htimedelta
        address: {type: integer, default: 0x615, allowed: [0x615]}
        priv_mode: {type: string, default: H, allowed: [H]}
        reset-val: {type: integer, default: 0, check_with: [max_length]}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - htimedeltah[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
            accessible: {type: boolean,  default: true,  check_with: [rv32_check]}
          check_with: h_check
          default: {accessible: true}
        rv64:
            type: dict
            schema: {accessible: {default: False}}
            default: {accessible: False}
    vsstatus:
      type: dict
      schema:
        description:
          type: string
          default: The vsstatus register keeps track of the processor’s current operating state.
        address: {type: integer, default: 0x200, allowed: [0x200]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            uie:
              type: dict
              schema:
                description: {type: string,  default: Stores the state of the user mode interrupts.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: n_check
            sie:
              type: dict
              schema:
                description: { type: string, default: Stores the state of the supervisor mode interrupts.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            upie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the user mode interrupts prior to the trap.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: n_check
            spie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the supervisor mode interrupts prior to
                    the trap.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            spp:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the previous priority mode for supervisor.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            fs:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the status of the floating-point unit, including the
                    CSR fcsr and floating-point data registers.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 14, allowed: [14]}
                lsb: {type: integer, default: 13, allowed: [13]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
            xs:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the status of additional user-mode extensions and associated
                    state.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 16, allowed: [16]}
                lsb: {type: integer, default: 15, allowed: [15]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
            sum:
              type: dict
              schema:
                description:
                  type: string
                  default: Modifies the privilege with which S-mode loads and stores access
                    virtual memory.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 18, allowed: [18]}
                lsb: {type: integer, default: 18, allowed: [18]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            mxr:
              type: dict
              schema:
                description:
                  type: string
                  default: Modifies the privilege with which loads access virtual memory.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 19, allowed: [19]}
                lsb: {type: integer, default: 19, allowed: [19]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            spelp:
              type: dict
              schema:
                description:
                  type: string
                  default: Virtual Supervisor mode previous expected-landing-pad (ELP) state.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 23, allowed: [23]}
                lsb: {type: integer, default: 23, allowed: [23]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            sd:
              type: dict
              schema:
                description:
                  type: string
                  default: Read-only bit that summarizes whether either the FS field or
                    XS field signals the presence of some dirty state.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 31, allowed: [31]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            uie:
              type: dict
              schema:
                description: {type: string,  default: Stores the state of the user mode interrupts.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: n_check
            sie:
              type: dict
              schema:
                description: { type: string, default: Stores the state of the supervisor mode interrupts.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            upie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the user mode interrupts prior to the trap.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 4, allowed: [4]}
                lsb: {type: integer, default: 4, allowed: [4]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: n_check
            spie:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the state of the supervisor mode interrupts prior to
                    the trap.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            spp:
              type: dict
              schema:
                description:
                  type: string
                  default: Stores the previous priority mode for supervisor.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 8, allowed: [8]}
                lsb: {type: integer, default: 8, allowed: [8]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            fs:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the status of the floating-point unit, including the
                    CSR fcsr and floating-point data registers.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 14, allowed: [14]}
                lsb: {type: integer, default: 13, allowed: [13]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
            xs:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the status of additional user-mode extensions and associated
                    state.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 16, allowed: [16]}
                lsb: {type: integer, default: 15, allowed: [15]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
            sum:
              type: dict
              schema:
                description:
                  type: string
                  default: Modifies the privilege with which S-mode loads and stores access
                    virtual memory.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 18, allowed: [18]}
                lsb: {type: integer, default: 18, allowed: [18]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            mxr:
              type: dict
              schema:
                description:
                  type: string
                  default: Modifies the privilege with which loads access virtual memory.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 19, allowed: [19]}
                lsb: {type: integer, default: 19, allowed: [19]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            uxl:
              type: dict
              schema:
                description: {type: string, default: Controls the xlen for User mode.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 33, allowed: [33]}
                lsb: {type: integer, default: 32, allowed: [32]}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  2, min: 1}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 2}
                implemented: {type: boolean, default: true}
              default: {implemented: true}
              check_with: u_check
            spelp:
              type: dict
              schema:
                description:
                  type: string
                  default: Virtual Supervisor mode previous expected-landing-pad (ELP) state.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 23, allowed: [23]}
                lsb: {type: integer, default: 23, allowed: [23]}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
                implemented: {type: boolean, default: true}
              default: {implemented: false}
              check_with: s_check
            sd:
              type: dict
              schema:
                description:
                  type: string
                  default: Read-only bit that summarizes whether either the FS field or
                    XS field signals the presence of some dirty state.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 63, allowed: [63]}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: {wlrl: [0:1]}
                implemented: {type: boolean, default: true}
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
          default: {accessible: false}
    vsie:
      type: dict
      schema:
        description:
          type: string
          default: The vsie register is an VSXLEN-bit read/write register containing interrupt
            enable bits.
        address: {type: integer, default: 0x204, allowed: [0x204]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            ssie:
              type: dict
              schema:
                description: {type: string, default: Supervisor Software Interrupt enable.}
                shadow: {type: string, default: mie.vssie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            stie:
              type: dict
              schema:
                description: { type: string, default: Supervisor Timer Interrupt enable.}
                shadow: {type: string, default: mie.vstie , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            seie:
              type: dict
              schema:
                description: { type: string, default: Supervisor External Interrupt enable.}
                shadow: {type: string, default: mie.vseie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 9, allowed: [9]}
                lsb: {type: integer, default: 9, allowed: [9]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            ssie:
              type: dict
              schema:
                description: {type: string, default: Supervisor Software Interrupt enable.}
                shadow: {type: string, default: mie.vssie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            stie:
              type: dict
              schema:
                description: { type: string, default: Supervisor Timer Interrupt enable.}
                shadow: {type: string, default: mie.vstie , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            seie:
              type: dict
              schema:
                description: { type: string, default: Supervisor External Interrupt enable.}
                shadow: {type: string, default: mie.vseie, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 9, allowed: [9]}
                lsb: {type: integer, default: 9, allowed: [9]}
                implemented: {type: boolean, default: False}
              default: {implemented: False}
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
    vsip:
      type: dict
      schema:
        description:
          type: string
          default: The vsip register is an VSXLEN-bit read/write register containing interrupt
            pending bits.
        address: {type: integer, default: 0x244, allowed: [0x244]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            ssip:
              type: dict
              schema:
                description: {type: string, default: Supervisor Software Interrupt enable.}
                shadow: {type: string, default: mip.vssip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            stip:
              type: dict
              schema:
                description: { type: string, default: Supervisor Timer Interrupt enable.}
                shadow: {type: string, default: mip.vstip , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            seip:
              type: dict
              schema:
                description: { type: string, default: Supervisor External Interrupt enable.}
                shadow: {type: string, default: mip.vseip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 9, allowed: [9]}
                lsb: {type: integer, default: 9, allowed: [9]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            ssip:
              type: dict
              schema:
                description: {type: string, default: Supervisor Software Interrupt enable.}
                shadow: {type: string, default: mip.vssip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 1, allowed: [1]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            stip:
              type: dict
              schema:
                description: { type: string, default: Supervisor Timer Interrupt enable.}
                shadow: {type: string, default: mip.vstip , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 5, allowed: [5]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            seip:
              type: dict
              schema:
                description: { type: string, default: Supervisor External Interrupt enable.}
                shadow: {type: string, default: mip.vseip, nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 9, allowed: [9]}
                lsb: {type: integer, default: 9, allowed: [9]}
                implemented: {type: boolean, default: true}
              default: {implemented: False}
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
    vsscratch:
      type: dict
      schema:
        description:
          type: string
          default: The vsscratch register is an VSXLEN-bit read/write register dedicated
            for use by machine mode.
        address: {type: integer, default: 0x240, allowed: [0x240]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              - schema: {ro_variable: {type: boolean}}
              - schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - vsscratch[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFFFFFFFFFF}}
              - schema: {ro_variable: {type: boolean}}
              - schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - vsscratch[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: false}
    vsepc:
      type: dict
      schema:
        description:
          type: string
          default: The vsepc is a warl register that must be able to hold all valid physical
            and virtual addresses.
        address: {type: integer, default: 0x241, allowed: [0x241]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - vsepc[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged    
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - vsepc[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged    
            accessible:
              type: boolean
              default: true
              check_with: rv64_check
          default: {accessible: false}
    vstval:
      type: dict
      schema:
        description:
          type: string
          default: The vstval is a warl register that holds the address of the instruction
            which caused the exception.
        address: {type: integer, default: 0x243, allowed: [0x243]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - vstval[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - vstval[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              default: true
              check_with: rv64_check
          default: {accessible: false}
    vscause:
      type: dict
      schema:
        description:
          type: string
          default: The scause register stores the information regarding the trap.
        address: {type: integer, default: 0x242, allowed: [0x242]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            interrupt:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether the trap was due to an interrupt.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 31, allowed: [31]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl: 
                    - 0x0:0x1
                  readonly: True
              default: {implemented: False}
            exception_code:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the exception code.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 30, allowed: [30]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl: 
                    - 0:15
              default: {implemented: False}
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            interrupt:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether the trap was due to an interrupt.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 63, allowed: [63]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: False}
            exception_code:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the exception code.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 62, allowed: [62]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0:15
              default: {implemented: false}
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
          default: {accessible: false}
    vstvec:
      type: dict
      schema:
        description:
          type: string
          default: SXLEN-bit read/write register that holds trap vector configuration.
        address: {type: integer, default: 0x205, allowed: [0x205]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val:
          type: integer
          check_with:
          - max_length
          default: 0
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            base:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector base address.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  1073741823}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                      warl:
                       dependency_fields: []
                       legal:
                         - base[29:0] in [0x00000000:0x3FFFFFFF]
                       wr_illegal:
                         - "Unchanged"
              default: {implemented: False}
            mode:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  1}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                     warl:
                      dependency_fields: []
                      legal:
                        - "mode[1:0] in [0x0,0x1]"
                      wr_illegal:
                        - "Unchanged"
              default: {implemented: false}
            accessible:
              type: boolean
              check_with:
              - rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            base:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector base address.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 2, allowed: [2]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  4611686018427387903}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                    warl:
                       dependency_fields: []
                       legal:
                         - "base[61:0] bitmask [0x3FFFFFFFFFFFFFFF, 0x0000000000000000]"
                       wr_illegal:
                         - "Unchanged"
              default: {implemented: False}
            mode:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 1, allowed: [1]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  1}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                     warl:
                      dependency_fields: []
                      legal:
                        - "mode[1:0] in [0x0,0x1]"
                      wr_illegal:
                        - "Unchanged"
              default: {implemented: false}
            accessible:
              type: boolean
              check_with:
              - rv64_check
          default: {accessible: false}
    vsatp:
      type: dict
      schema:
        description: { type: string, default: VSXLEN-bit register which controls supervisor-mode address translation and protection }
        address: {type: integer, default: 0x280, allowed: [0x280]}
        priv_mode: {type: string, default: S, allowed: [S]}
        reset-val: { type: integer, check_with: max_length , default: 0}
        rv32:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            ppn:
              type: dict
              schema:
                description: { type: string , default: Physical Page Number }
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 21, allowed: [21]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  4194303}}
                  - schema: { warl: *ref_warl }
                  default: {ro_constant : 0}
              default: {implemented: False}
            asid:
              type: dict
              schema:
                description: { type: string, default: Address Space identifier. }
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 30, allowed: [30]}
                lsb: {type: integer, default: 22, allowed: [22]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 511 }}
                  - schema: { warl: *ref_warl }
                  default: {ro_constant : 0}
              default: {implemented: False}
            mode:
              type: dict
              schema:
                description: { type: string, default: Vector mode. }
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 31, allowed: [31]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  1}}
                  - schema: { warl: *ref_warl }
                  default: {ro_constant : 0}
              default: {implemented: False}
            accessible:
              type: boolean
              check_with:
              - rv32_check
          default: {accessible: false}
        rv64:
          type: dict
          check_with: s_check
          schema:
            fields: {type: list, default: []}
            ppn:
              type: dict
              schema:
                description:
                  type: string
                  default: Physical Page Number
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 43, allowed: [43]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  17592186044415}}
                  - schema: { warl: *ref_warl }
                  default: {ro_constant : 0}
              default: {implemented: False}
            asid:
              type: dict
              schema:
                description:
                  type: string
                  default: Address Space identifier.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 59, allowed: [59]}
                lsb: {type: integer, default: 44, allowed: [44]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max: 65535}}
                  - schema: { warl: *ref_warl }
                  default: {ro_constant : 0}
              default: {implemented: False}
            mode:
              type: dict
              schema:
                description:
                  type: string
                  default: Vector mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 60, allowed: [60]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  15}}
                  - schema: { warl: *ref_warl }
                  default: {ro_constant : 0}
              default: {implemented: False}
            accessible:
              type: boolean
              check_with:
              - rv64_check
          default: {accessible: false}
    vxsat:
      type: dict
      check_with: vxsat_check
      schema:
        description:
          type: string
          default: The vxsat register records the overflow saturation condition of P and V instructions.
        address: {type: integer, default: 9, allowed: [9]}
        priv_mode: {type: string, default: U, allowed: [U]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            ov:
              type: dict
              schema:
                description: {type: string,  default: Stores the state of overflow flag.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: false}
            accessible:
              type: boolean
              default: true
              check_with: rv32_check
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            ov:
              type: dict
              schema:
                description: {type: string,  default: Stores the state of overflow flag.}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 0, allowed: [0]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { wlrl: *ref_wlrl }
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 0 , min : 0}}
                  default:
                    wlrl:
                    - 0:1
              default: {implemented: false}
            accessible:
              type: boolean
              default: true
              check_with: rv64_check
          default: {accessible: False}
    mnscratch:
      type: dict
      schema:
        description:
          type: string
          default: |-
            The mnscratch CSR holds an MXLEN-bit read-write register which enables the NMI trap 
            handler to save and restore the context that was interrupted.
        address: {type: integer, default: 0x740, allowed: [0x740]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFF}}
              - schema: {ro_variable: {type: boolean}}
              - schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - mnscratch[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
            accessible:
              type: boolean
              default: false
              check_with: 
                - rv32_check
                - smrnmi_check
          default: {accessible: false}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              oneof:
              - schema: {ro_constant: {type: integer, max:  0xFFFFFFFFFFFFFFFF}}
              - schema: {ro_variable: {type: boolean}}
              - schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - mnscratch[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              default: false
              check_with: 
                - rv64_check
                - smrnmi_check
          default: {accessible: false}
    mnepc:
      type: dict
      schema:
        description:
          type: string
          default: |-
            The mnepc CSR is an MXLEN-bit read-write register which on entry to the NMI trap handler holds
            the PC of the instruction that took the interrupt.

            The low bit of mnepc (mnepc[0]) is always zero. On implementations that support only
            IALIGN=32, the two low bits (mnepc[1:0]) are always zero.

            If an implementation allows IALIGN to be either 16 or 32 (by changing CSR misa, for example),
            then, whenever IALIGN=32, bit mnepc[1] is masked on reads so that it appears to be 0. This
            masking occurs also for the implicit read by the MRET instruction. Though masked, mnepc[1]
            remains writable when IALIGN=32.

            mnepc is a WARL register that must be able to hold all valid virtual addresses. It need not be
            capable of holding all possible invalid addresses. Prior to writing mnepc, implementations may
            convert an invalid address into some other invalid address that mnepc is capable of holding.
        address: {type: integer, default: 0x741, allowed: [0x741]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          default: 0
          check_with: max_length
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 31, allowed: [31]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - mnepc[31:0] in [0x00000000:0xFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              type: boolean
              default: false
              check_with: 
                - rv32_check
                - smrnmi_check
          default: {accessible: false}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            shadow: {type: string, default: , nullable: True}
            shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
            msb: {type: integer, default: 63, allowed: [63]}
            lsb: {type: integer, default: 0, allowed: [0]}
            type:
              type: dict
              schema: { warl: *ref_warl }
              default:
                warl:
                  dependency_fields: []
                  legal:
                  - mnepc[63:0] in [0x00000000:0xFFFFFFFFFFFFFFFF]
                  wr_illegal:
                  - unchanged
    
            accessible:
              type: boolean
              default: false
              check_with: 
                - rv64_check
                - smrnmi_check
          default: {accessible: false}
    mncause:
      type: dict
      schema:
        description:
          type: string
          default: |-
            The mncause CSR holds the reason for the NMI, with bit MXLEN-1 set to 1, 
            and the NMI cause encoded in the least-significant bits or zero if NMI causes are not supported.
        address: {type: integer, default: 0x742,  allowed: [0x742]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            interrupt:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether the trap was due to an interrupt.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 31, allowed: [31]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: {ro_constant: {type: integer, max: 0x1, min: 0x1}}
                  default: {ro_constant: 1 }
              default: {implemented: true}
            exception_code:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the exception code.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 30, allowed: [30]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl: 
                    - 0:15
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: 
                - rv32_check
                - smrnmi_check
          default: {accessible: false}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            interrupt:
              type: dict
              schema:
                description:
                  type: string
                  default: Indicates whether the trap was due to an interrupt.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 63, allowed: [63]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: {ro_constant: {type: integer, max: 0x1, min: 0x1}}
                  default: {ro_constant: 1 }
              default: {implemented: true}
            exception_code:
              type: dict
              schema:
                description:
                  type: string
                  default: Encodes the exception code.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 62, allowed: [62]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0:15
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
          default: {accessible: false}
    mnstatus:
      type: dict
      schema:
        description:
          type: string
          default: |-

            The mnstatus CSR holds a two-bit field, MNPP, which on entry to the trap handler holds the
            privilege mode of the interrupted context, encoded in the same manner as mstatus.MPP. It also
            
            holds a one-bit field, MNPV, which on entry to the trap handler holds the virtualization mode of
            the interrupted context, encoded in the same manner as mstatus.MPV.
            mnstatus also holds the NMIE bit. When NMIE=1, nonmaskable interrupts are enabled. When
            NMIE=0, all interrupts are disabled.
            When NMIE=0, the hart behaves as though mstatus.MPRV were clear, regardless of the current
            setting of mstatus.MPRV.

            Upon reset, NMIE contains the value 0.

        address: {type: integer, default: 0x744, allowed: [0x744]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            nmie:
              type: dict
              schema:
                description:
                  type: string
                  default: |-
                    When NMIE=1, nonmaskable interrupts are enabled. When
                    NMIE=0, all interrupts are disabled. When NMIE=0, the hart behaves as though mstatus.MPRV were 
                    clear, regardless of the current setting of mstatus.MPRV.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 3, allowed: [3]}
                lsb: {type: integer, default: 3, allowed: [3]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    warl:
                      dependency_fields: [writeval]
                      legal:
                        - writeval[0] in [1] -> nmie[0] bitmask [1,0]
                      wr_illegal:
                        - Unchanged
              default: {implemented: true}
            mnpv:
              type: dict
              schema:
                description:
                  type: string
                  default: |-
                    on entry to the trap handler holds the virtualization mode of the interrupted 
                    context, encoded in the same manner as mstatus.MPV.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default: { wlrl: [0:1]}
              default: {implemented: false}
              check_with: h_check
            mnpp:
              type: dict
              schema:
                description:
                  type: string
                  default: |-
                    on entry to the trap handler holds the
                    privilege mode of the interrupted context, encoded in the same manner as mstatus.MPP.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 12, allowed: [12]}
                lsb: {type: integer, default: 11, allowed: [11]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: 
                - rv32_check
                - smrnmi_check
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            nmie:
              type: dict
              schema:
                description:
                  type: string
                  default: |-
                    When NMIE=1, nonmaskable interrupts are enabled. When
                    NMIE=0, all interrupts are disabled. When NMIE=0, the hart behaves as though mstatus.MPRV were 
                    clear, regardless of the current setting of mstatus.MPRV.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 3, allowed: [3]}
                lsb: {type: integer, default: 3, allowed: [3]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: { wlrl: *ref_wlrl }
                  default: 
                    warl:
                      dependency_fields: [writeval]
                      legal:
                        - writeval[0] in [1] -> nmie[0] bitmask [1,0]
                      wr_illegal:
                        - Unchanged
              default: {implemented: true}
            mnpv:
              type: dict
              schema:
                description:
                  type: string
                  default: |-
                    on entry to the trap handler holds the virtualization mode of
                    the interrupted context, encoded in the same manner as mstatus.MPV.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 7, allowed: [7]}
                lsb: {type: integer, default: 7, allowed: [7]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default: { wlrl: [0:1]}
              default: {implemented: false}
              check_with: h_check
            mnpp:
              type: dict
              schema:
                description:
                  type: string
                  default: |-
                    on entry to the trap handler holds the
                    privilege mode of the interrupted context, encoded in the same manner as mstatus.MPP.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 12, allowed: [12]}
                lsb: {type: integer, default: 11, allowed: [11]}
                implemented: {type: boolean, default: true}
                type:
                  type: dict
                  oneof:
                  - schema: { warl: *ref_warl }
                  - schema: {ro_constant: {type: integer, max: 3 , min : 0}}
                  - schema: { wlrl: *ref_wlrl }
                  default: {ro_constant: 0}
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: 
                - rv64_check
                - smrnmi_check
          default: {accessible: false}
    jvt:
      type: dict
      schema:
        description: { type: string, default: Table jump base vector and control register }
        address: {type: integer, default: 0x0017, allowed: [0x0017]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val: { type: integer, check_with: max_length , default: 0}
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            mode:
              type: dict
              schema:
                description: {type: string, default: Jump Table mode}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type: 
                  type: dict
                  oneof:
                    - schema: {ro_constant: {type: integer, max:  64}}
                    - schema: {ro_variable: {type: boolean}}
                    - schema: { warl: *ref_warl }
                  default:
                    ro_constant: 0
              default: {implemented: True}
            base: 
              type: dict
              schema:
                description: {type: string, default: Jump Table base address}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 31, allowed: [31]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  67108864}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                     warl:
                       dependency_fields: []
                       legal:
                         - "base[31:6] bitmask [0x3FFFFFF, 0x0000000]"
                       wr_illegal:
                         - "Unchanged"
              default: {implemented: true}
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            mode:
              type: dict
              schema:
                description: {type: string, default: Jump Table mode}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 5, allowed: [5]}
                lsb: {type: integer, default: 0, allowed: [0]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type: 
                  type: dict
                  oneof:
                    - schema: {ro_constant: {type: integer, max:  64}}
                    - schema: {ro_variable: {type: boolean}}
                    - schema: { warl: *ref_warl }
                  default:
                    ro_constant: 0
              default: {implemented: True}
            base: 
              type: dict
              schema:
                description: {type: string, default: Jump Table base address}
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 63, allowed: [63]}
                lsb: {type: integer, default: 6, allowed: [6]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  oneof:
                  - schema: {ro_constant: {type: integer, max:  288230376151711744}}
                  - schema: {ro_variable: {type: boolean}}
                  - schema: { warl: *ref_warl }
                  default: 
                     warl:
                       dependency_fields: []
                       legal:
                         - "base[63:6] bitmask [0x3FFFFFFFFFFFFFF, 0x000000000000000]"
                       wr_illegal:
                         - "Unchanged"
              default: {implemented: true}
    mseccfg:
      type: dict
      schema:
        description:
          type: string
          default: Machine Security Configuration Register
        address: {type: integer, default: 0x747, allowed: [0x747]}
        priv_mode: {type: string, default: M, allowed: [M]}
        reset-val:
          type: integer
          check_with: max_length
          default: 0
        rv32:
          type: dict
          schema:
            fields: {type: list, default: []}
            mlpe:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Zicfilp extension in M-mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 10, allowed: [10]}
                lsb: {type: integer, default: 10, allowed: [10]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: rv32_check
        rv64:
          type: dict
          schema:
            fields: {type: list, default: []}
            mlpe:
              type: dict
              schema:
                description:
                  type: string
                  default: Enables use of Zicfilp extension in M-mode.
                shadow: {type: string, default: , nullable: True}
                shadow_type: {type: string, default: rw, nullable: True, allowed: ['rw','ro']}
                msb: {type: integer, default: 10, allowed: [10]}
                lsb: {type: integer, default: 10, allowed: [10]}
                implemented: {type: boolean, default: true, allowed: [true]}
                type:
                  type: dict
                  schema: { wlrl: *ref_wlrl }
                  default:
                    wlrl:
                    - 0x0:0x1
              default: {implemented: true}
            accessible:
              type: boolean
              default: false
              check_with: rv64_check
          default: {accessible: false}